handsontable 18.0.0 → 18.1.0-rc1

package/plugins/formulas/formulas.mjs

@@ -4,15 +4,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    if (descriptor.get) return descriptor.get.call(receiver);
     return descriptor.value;
 }
 function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
     return privateMap.get(receiver);
 }
 function _class_private_field_get(receiver, privateMap) {
@@ -39,9 +34,7 @@ function _class_private_field_set(receiver, privateMap, value) {
     return value;
 }
 function _class_private_method_get(receiver, privateSet, fn) {
-    if (!privateSet.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {
@@ -50,18 +43,20 @@ function _class_private_method_init(obj, privateSet) {
 }
 import { BasePlugin } from '../base/index.mjs';
 import { staticRegister } from '../../utils/staticRegister.mjs';
-import { error, warn } from '../../helpers/console.mjs';
+import { error, warn, warnOnce } from '../../helpers/console.mjs';
 import { isNumeric } from '../../helpers/number.mjs';
 import { isObject } from '../../helpers/object.mjs';
 import { isDefined, isUndefined } from '../../helpers/mixed.mjs';
 import { getRegisteredHotInstances, setupEngine, setupSheet, unregisterEngine } from './engine/register.mjs';
-import { getDateFromExcelDate, getDateInHfFormat, getDateInHotFormat, getTimeFromHfTimeFraction, isDate, isDateValid, isFormula, normalizeValueForFormulaEngine, unescapeFormulaExpression } from './utils.mjs';
+import { coalesceIndexesToSpans, getDateFromExcelDate, getDateInHfFormat, getDateInHotFormat, getTimeFromHfTimeFraction, isDate, isDateValid, isFormula, normalizeValueForFormulaEngine, unescapeFormulaExpression } from './utils.mjs';
+import { resolveHyperlinkUrl } from './hyperlinkUrl.mjs';
 import { getEngineSettingsWithOverrides, haveEngineSettingsChanged } from './engine/settings.mjs';
 import { isArrayOfArrays } from '../../helpers/data.mjs';
 import { toUpperCaseFirst } from '../../helpers/string.mjs';
 import { getValueGetterValue } from '../../utils/valueAccessors.mjs';
 import { Hooks } from '../../core/hooks/index.mjs';
 import IndexSyncer from './indexSyncer/index.mjs';
+import { isCellRangeLike } from '../../3rdparty/walkontable/src/cell/range.mjs';
 /**
  * Narrow an arbitrary value to a HyperFormula cell change shape.
  *
@@ -87,6 +82,8 @@ import IndexSyncer from './indexSyncer/index.mjs';
     return typeof candidate === 'object' && candidate !== null && 'value' in candidate;
 }
 export const PLUGIN_KEY = 'formulas';
+// `maxRows` and `maxColumns` no longer reach the engine at all (GH #10672), but they stay here:
+// `updatePlugin` also creates or switches the sheet, and dropping them would skip that.
 export const SETTING_KEYS = [
     'maxRows',
     'maxColumns',
@@ -104,17 +101,90 @@ Hooks.getSingleton().register('afterFormulasValuesUpdate');
 // HyperFormula's `undo` and `redo` methods will do it instead. Please keep in mind that undo/redo stacks inside
 // instances of Handsontable and HyperFormula should be synced (number of actions should be the same).
 const isBlockedSource = (source)=>source === 'UndoRedo.undo' || source === 'UndoRedo.redo' || source === 'auto';
+// Maximum number of `[startIndex, amount]` spans passed to a single variadic engine
+// `removeRows`/`removeColumns` call. An unbounded argument spread could overflow the call stack.
+const REMOVAL_SPANS_CHUNK_SIZE = 1000;
+// Group under which the plugin's grid shortcuts are registered, so `disablePlugin` can drop them all.
+const SHORTCUTS_GROUP = PLUGIN_KEY;
+// Class name of the anchor that wraps the content of a `HYPERLINK` cell. It is also the marker that
+// keeps the wrapping idempotent when a renderer leaves the previous DOM in place.
+const HYPERLINK_CLASS_NAME = 'ht-hyperlink';
+// `warnOnce` key for a `HYPERLINK` URL refused by the protocol allowlist. Warning per cell would
+// flood the console on every render pass.
+const HYPERLINK_WARN_KEY = 'formulas-hyperlink-refused';
 var /**
    * Flag used to bypass hooks in internal operations.
    *
    * @private
    * @type {boolean}
    */ _internalOperationPending = /*#__PURE__*/ new WeakMap(), /**
+   * Whether `HYPERLINK` cells are rendered as links. Mirrors the `hyperlinks` plugin setting, cached
+   * because it is read once per rendered cell.
+   */ _hyperlinksEnabled = /*#__PURE__*/ new WeakMap(), /**
    * Flag needed to mark if Handsontable was initialized with no data.
    * (Required to work around the fact, that Handsontable auto-generates sample data, when no data is provided).
    *
    * @type {boolean}
    */ _hotWasInitializedWithEmptyData = /*#__PURE__*/ new WeakMap(), /**
+   * Stores the HyperFormula source range and destination address prepared in `beforeMoveCells` so that
+   * `commitPendingMoveCells` can execute the corresponding HF operation without recomputing
+   * visual-to-HF coordinates. `rect` carries the same operation in visual coordinates for the
+   * post-commit data sync.
+   *
+   * Set to `null` when no move is in flight.
+   *
+   * @private
+   * @type {{ source: object, dest: object, isCopy: boolean, rect: object }|null}
+   */ _pendingMoveCells = /*#__PURE__*/ new WeakMap(), /**
+   * The visual rectangle of the operation `commitPendingMoveCells` committed to the engine (or
+   * intentionally skipped during undo/redo replay). Consumed by the `afterMoveCells` listener,
+   * which runs the HOT-data sync only for committed operations and only off this value — never
+   * off its own hook arguments, which a preceding listener's return value can replace.
+   *
+   * Set to `null` when no committed move is awaiting its sync.
+   *
+   * @private
+   * @type {object|null}
+   */ _committedMoveCells = /*#__PURE__*/ new WeakMap(), /**
+   * `true` while a move-cells redo is replaying through the MoveCells plugin.
+   *
+   * Unlike other redo actions, it must validate the Handsontable move before advancing
+   * HyperFormula, so `commitPendingMoveCells` performs the engine operation itself.
+   */ _isRedoingMoveCells = /*#__PURE__*/ new WeakMap(), /**
+   * The dependent-cell changes returned by the engine operation in `commitPendingMoveCells`,
+   * consumed by the `afterMoveCells` listener to re-render dependent sheets. `null` when the
+   * engine step was skipped (undo/redo replay re-renders everything anyway).
+   *
+   * @private
+   * @type {unknown[]|null}
+   */ _moveCellsChanges = /*#__PURE__*/ new WeakMap(), /**
+   * Guard flag set while writing synced values back to HOT after a `moveCells` operation.
+   * Prevents the `afterSetDataAtCell` / `afterSetSourceDataAtCell` hooks from re-writing
+   * the same values into HyperFormula a second time.
+   *
+   * @private
+   * @type {boolean}
+   */ _moveCellsSyncPending = /*#__PURE__*/ new WeakMap(), /**
+   * The changes that the engine reported while undoing or redoing an action. They are collected in
+   * `beforeUndo`/`beforeRedo` and consumed in `afterUndo`/`afterRedo`, where the dependent cells get
+   * validated.
+   *
+   * @type {Array}
+   */ _undoRedoDependentCells = /*#__PURE__*/ new WeakMap(), /**
+   * The addresses of the cells that the `UndoRedo` plugin writes through `setDataAtCell`. The Core
+   * validates those on its own, so they are excluded from the dependent-cell validation.
+   *
+   * Cells restored through `setSourceDataAtCell` are deliberately absent: that path runs
+   * `sourceDataValidator`, which never touches the `valid` flag, so excluding them would leave them
+   * unvalidated by anyone.
+   *
+   * @type {Array}
+   */ _undoRedoChangedCells = /*#__PURE__*/ new WeakMap(), /**
+   * Whether the action being undone or redone wrote any cell data. Only then are the dependent cells
+   * worth validating.
+   *
+   * @type {boolean}
+   */ _undoRedoWroteData = /*#__PURE__*/ new WeakMap(), /**
    * Maps a HyperFormula `ExportedCellChange` to the same change with `newValue` translated to a
    * Handsontable-formatted string when the target cell is of type `date` or `time`. For other cells
    * (or non-numeric values, or named expressions, or trimmed cells, or cells on other sheets), the
@@ -165,6 +235,64 @@ var /**
    *
    * @param {string} [sheetName] The new sheet name.
    */ _updateSheetNameAndSheetId = /*#__PURE__*/ new WeakSet(), /**
+   * Reads the `hyperlinks` plugin setting into the cached flag.
+   */ _refreshHyperlinksSetting = /*#__PURE__*/ new WeakSet(), /**
+   * Unwraps every `HYPERLINK` anchor currently in the grid, including the overlay clones.
+   *
+   * Disabling the plugin removes the `afterRenderer` hook, so a renderer that leaves its previous
+   * DOM in place would keep its cells clickable with nothing left to clean them up. The anchors are
+   * matched by the plugin's own class, so no knowledge of the rendering internals is needed.
+   */ _unwrapRenderedHyperlinks = /*#__PURE__*/ new WeakSet(), /**
+   * Moves an anchor's content up into the anchor's own parent and drops the anchor.
+   *
+   * The insertion goes through `link.parentNode` rather than the cell: a renderer that leaves the
+   * previous DOM in place can wrap an existing anchor, leaving it as `TD > div > a` instead of a
+   * direct child. Inserting relative to the cell would then throw `NotFoundError` and, because this
+   * runs inside `afterRenderer`, take the whole draw down with it.
+   *
+   * @param {Element} link The anchor to unwrap.
+   */ _unwrapLink = /*#__PURE__*/ new WeakSet(), /**
+   * Moves the content of a cell's `HYPERLINK` anchor back into the cell and drops the anchor. Loops
+   * so that anchors nested by an older render pass are unwrapped as well.
+   *
+   * @param {HTMLTableCellElement} TD The rendered cell element.
+   */ _unwrapHyperlink = /*#__PURE__*/ new WeakSet(), /**
+   * Returns the URL that a cell should link to, or `null` when the cell must not become a link.
+   *
+   * The engine reports a hyperlink only for a cell whose root expression is `HYPERLINK()`, so a
+   * nested call such as `=CONCATENATE("see ", HYPERLINK(...))` resolves to `null` here.
+   *
+   * @param {number} row Visual row index.
+   * @param {number} column Visual column index.
+   * @returns {string|null} The resolved absolute URL, or `null`.
+   */ _getHyperlinkHref = /*#__PURE__*/ new WeakSet(), /**
+   * Records that the action being undone or redone wrote cell data, and - when the Core validates
+   * that write itself - which cells it wrote, so that `#validateUndoRedoDependentCells` can skip
+   * them.
+   *
+   * `coreValidatesWrite` separates the two write paths. `setDataAtCell` ends in the Core's own
+   * `validateCell`, so those cells must be excluded to avoid validating them twice.
+   * `setSourceDataAtCell` does not - it runs `sourceDataValidator`, which never touches the `valid`
+   * flag - so its cells must stay in the validation pass. Skipping them is also why their row index
+   * is never translated here: that hook reports physical rows, unlike `afterSetDataAtCell`.
+   *
+   * @param {Array[]} changes An array of changes in format [[row, prop, oldValue, value], ...].
+   * @param {string} source String that identifies the source of the hook call.
+   * @param {boolean} coreValidatesWrite `true` when the Core validates the written cells itself.
+   */ _registerUndoRedoWrite = /*#__PURE__*/ new WeakSet(), /**
+   * Validates the cells that the engine recalculated while an action was undone or redone.
+   *
+   * The `afterSetDataAtCell` and `afterSetSourceDataAtCell` listeners ignore changes coming from the
+   * `UndoRedo` plugin, because the engine reverts them through its own undo stack. Without this step
+   * the dependent formula cells would keep the `valid` flag they were given before the action was
+   * reverted - a formula cell that turned into an error, and is a correct value again after the undo,
+   * would stay marked as invalid.
+   *
+   * Runs only when the action wrote cell data. That covers undoing an edit (`setDataAtCell`) and
+   * undoing a row or column removal, which restores the data with `setSourceDataAtCell`. Actions
+   * that only reorder or hide - moving, sorting, filtering, merging - write no data, do not validate
+   * dependent cells outside of undo either, and are skipped.
+   */ _validateUndoRedoDependentCells = /*#__PURE__*/ new WeakSet(), /**
    * Get the value to be passed to the formula engine.
    * If the value is an object, utilize the valueGetter for that cell, otherwise return the value as is.
    *
@@ -220,6 +348,14 @@ var /**
    *   property.
    * @param {string} ioMode String which indicates for what operation hook is fired (`get` or `set`).
    */ _onModifyData = /*#__PURE__*/ new WeakMap(), /**
+   * `afterRenderer` hook callback. Wraps the already rendered content of a `HYPERLINK` cell in an
+   * anchor. The cell keeps its own renderer and its cell meta is left untouched, so disabling the
+   * plugin or clearing the formula needs no cleanup.
+   *
+   * @param {HTMLTableCellElement} TD The rendered cell element.
+   * @param {number} row Visual row index.
+   * @param {number} column Visual column index.
+   */ _onAfterRenderer = /*#__PURE__*/ new WeakMap(), /**
    * `modifySourceData` hook callback.
    *
    * @param {number} row Physical row index.
@@ -232,13 +368,13 @@ var /**
    *
    * @param {Array[]} changes An array of changes in format [[row, prop, oldValue, value], ...].
    * @param {string} [source] String that identifies source of hook call
-   *                          ([list of all available sources]{@link https://handsontable.com/docs/javascript-data-grid/events-and-hooks/#handsontable-hooks}).
+   *                          ([list of all available sources](@/guides/getting-started/events-and-hooks/events-and-hooks.md#definition-for-source-argument)).
    */ _onAfterSetDataAtCell = /*#__PURE__*/ new WeakMap(), /**
    * `onAfterSetSourceDataAtCell` hook callback.
    *
    * @param {Array[]} changes An array of changes in format [[row, column, oldValue, value], ...].
    * @param {string} [source] String that identifies source of hook call
-   *                          ([list of all available sources]{@link https://handsontable.com/docs/javascript-data-grid/events-and-hooks/#handsontable-hooks}).
+   *                          ([list of all available sources](@/guides/getting-started/events-and-hooks/events-and-hooks.md#definition-for-source-argument)).
    */ _onAfterSetSourceDataAtCell = /*#__PURE__*/ new WeakMap(), /**
    * `beforeCreateRow` hook callback.
    *
@@ -271,14 +407,14 @@ var /**
    * @param {number} visualRow Represents the visual index of first newly created row in the data source array.
    * @param {number} amount Number of newly created rows in the data source array.
    * @param {string} [source] String that identifies source of hook call
-   *                          ([list of all available sources]{@link https://handsontable.com/docs/javascript-data-grid/events-and-hooks/#handsontable-hooks}).
+   *                          ([list of all available sources](@/guides/getting-started/events-and-hooks/events-and-hooks.md#definition-for-source-argument)).
    */ _onAfterCreateRow = /*#__PURE__*/ new WeakMap(), /**
    * `afterCreateCol` hook callback.
    *
    * @param {number} visualColumn Represents the visual index of first newly created column in the data source.
    * @param {number} amount Number of newly created columns in the data source.
    * @param {string} [source] String that identifies source of hook call
-   *                          ([list of all available sources]{@link https://handsontable.com/docs/javascript-data-grid/events-and-hooks/#handsontable-hooks}).
+   *                          ([list of all available sources](@/guides/getting-started/events-and-hooks/events-and-hooks.md#definition-for-source-argument)).
    */ _onAfterCreateCol = /*#__PURE__*/ new WeakMap(), /**
    * `afterRemoveRow` hook callback.
    *
@@ -286,7 +422,7 @@ var /**
    * @param {number} amount An amount of removed rows.
    * @param {number[]} physicalRows An array of physical rows removed from the data source.
    * @param {string} [source] String that identifies source of hook call
-   *                          ([list of all available sources]{@link https://handsontable.com/docs/javascript-data-grid/events-and-hooks/#handsontable-hooks}).
+   *                          ([list of all available sources](@/guides/getting-started/events-and-hooks/events-and-hooks.md#definition-for-source-argument)).
    */ _onAfterRemoveRow = /*#__PURE__*/ new WeakMap(), /**
    * `afterRemoveCol` hook callback.
    *
@@ -294,8 +430,73 @@ var /**
    * @param {number} amount An amount of removed columns.
    * @param {number[]} physicalColumns An array of physical columns removed from the data source.
    * @param {string} [source] String that identifies source of hook call
-   *                          ([list of all available sources]{@link https://handsontable.com/docs/javascript-data-grid/events-and-hooks/#handsontable-hooks}).
+   *                          ([list of all available sources](@/guides/getting-started/events-and-hooks/events-and-hooks.md#definition-for-source-argument)).
    */ _onAfterRemoveCol = /*#__PURE__*/ new WeakMap(), /**
+   * Checks whether every visual index in the `[visualFrom, visualTo]` span maps to consecutive
+   * HyperFormula indexes on the given axis. Only then is a visual rectangle equivalent to the
+   * single HF rectangle the `moveCells` engine operation works on.
+   *
+   * @param {AxisSyncer} syncer The row or column axis syncer.
+   * @param {number} visualFrom The first visual index of the span.
+   * @param {number} visualTo The last visual index of the span.
+   * @returns {boolean}
+   */ _mapsToContiguousHfBlock = /*#__PURE__*/ new WeakSet(), /**
+   * `beforeMoveCells` hook callback.
+   *
+   * Converts the visual source range and target top-left corner to HyperFormula
+   * (physical) coordinates, validates feasibility for a MOVE operation, and stores
+   * the converted addresses for use in the `afterMoveCells` handler.
+   *
+   * Returns `false` to veto the whole operation when the source range is not a valid range
+   * (the documented `false` veto value, or garbage folded into the argument by a preceding
+   * listener's truthy return value), when HyperFormula reports the move is not possible
+   * (e.g. the source or target contains an array formula), or when the visual ranges do not map
+   * to contiguous HF blocks (trimmed/filtered/reordered indexes), because the engine rectangle
+   * would then cover cells outside the visual operation.
+   *
+   * @param {CellRange|boolean} sourceRange The visual source range, or `false` after an earlier veto.
+   * @param {CellCoords} targetTopLeft The visual top-left of the destination.
+   * @param {boolean} isCopy `true` when copying (not moving) cells.
+   * @returns {boolean|undefined} `false` to cancel the operation; `undefined` otherwise.
+   */ _onBeforeMoveCells = /*#__PURE__*/ new WeakMap(), /**
+   * `afterMoveCells` hook callback.
+   *
+   * Runs after the engine operation already executed in `commitPendingMoveCells` (the core
+   * calls it before mutating the grid, so a failed engine operation never reaches this hook).
+   * Synchronises HOT's source data array with HF's state so that `getDataAtCell` returns
+   * correct values for plain VALUE / EMPTY cells (formula cells are already served from HF
+   * via the `modifyData` hook), then re-renders the dependent sheets. The sync is guarded by
+   * `#moveCellsSyncPending` so that `afterSetDataAtCell` does not re-write the same values
+   * back into HyperFormula.
+   *
+   * Takes no arguments on purpose. The engine has already moved the cells by the time this runs, so
+   * there is nothing left to veto and bailing out would strand the data source out of sync with the
+   * engine — which is what reading the replaceable `sourceRange` argument used to cause. The
+   * operation is read from `#committedMoveCells` instead, captured before any listener could run.
+   */ _onAfterMoveCells = /*#__PURE__*/ new WeakMap(), /**
+   * Synchronises HOT's raw data source array with HyperFormula's state after a
+   * `moveCells` or copy operation.
+   *
+   * Formula cells are already served correctly through `modifyData` via `getCellValue`.
+   * Plain VALUE / EMPTY cells, however, fall back to the raw HOT data, so after HF
+   * moves the data the old raw values must be cleared from the source cells and the
+   * serialised HF content must be written to the target cells.
+   *
+   * The write is fenced with `#moveCellsSyncPending` to prevent the `afterSetDataAtCell`
+   * hook from re-syncing the same data back into HyperFormula.
+   *
+   * @private
+   * @param {object} rect The committed operation in visual coordinates.
+   */ _syncHotDataAfterMoveCells = /*#__PURE__*/ new WeakSet(), /**
+   * Removes the provided `[startIndex, amount]` spans from the engine in as few calls as possible.
+   * One call handles many spans, so the engine pays its dependency-graph remap once per call instead
+   * of once per removed row or column. The engine methods are variadic, so the spans are chunked to
+   * keep the argument spread within call-stack limits; chunks run from the highest spans down, which
+   * keeps the original coordinates of the not-yet-removed lower spans valid.
+   *
+   * @param {Array<Array<number>>} spans Ascending list of `[startIndex, amount]` spans to remove.
+   * @param {'removeRows'|'removeColumns'} engineMethodName The engine removal method to call.
+   */ _removeSpansFromEngine = /*#__PURE__*/ new WeakSet(), /**
    * `afterDetachChild` hook callback.
    * Used to sync the data of the rows detached in the Nested Rows plugin with the engine's dataset.
    *
@@ -424,27 +625,61 @@ var /**
         // Handling undo actions on data just using HyperFormula's UndoRedo mechanism
         this.addHook('beforeUndo', ()=>{
             this.indexSyncer.setPerformUndo(true);
-            this.engine.undo();
+            _class_private_field_set(this, _undoRedoChangedCells, []);
+            _class_private_field_set(this, _undoRedoWroteData, false);
+            _class_private_field_set(this, _undoRedoDependentCells, this.engine.undo() ?? []);
         });
-        // Handling redo actions on data just using HyperFormula's UndoRedo mechanism
-        this.addHook('beforeRedo', ()=>{
+        // Handling redo actions on data just using HyperFormula's UndoRedo mechanism.
+        this.addHook('beforeRedo', (action)=>{
+            // Defensive: `Hooks.run` threads a preceding listener's non-`undefined` return value into
+            // this argument, and the global bucket runs before this one. Without a trustworthy
+            // `actionType` the engine step cannot be dispatched safely (`engine.redo()` vs the
+            // `move_cells` replay path — the wrong branch runs the engine operation twice), so cancel
+            // the redo instead of desyncing HyperFormula. The guard runs BEFORE `setPerformRedo(true)`
+            // — a cancelled redo never fires `afterRedo`, so a flag set here would leak.
+            if (typeof action !== 'object' || action === null || !('actionType' in action)) {
+                return false;
+            }
             this.indexSyncer.setPerformRedo(true);
-            this.engine.redo();
+            _class_private_field_set(this, _isRedoingMoveCells, action.actionType === 'move_cells');
+            _class_private_field_set(this, _undoRedoChangedCells, []);
+            _class_private_field_set(this, _undoRedoWroteData, false);
+            // For a `move_cells` redo the engine operation runs in `commitPendingMoveCells` (the
+            // Handsontable move must be validated first), so `engine.redo()` is not called here and
+            // there are no engine-reported dependent cells to collect.
+            _class_private_field_set(this, _undoRedoDependentCells, _class_private_field_get(this, _isRedoingMoveCells) ? [] : this.engine.redo() ?? []);
         });
         this.addHook('afterUndo', ()=>{
             this.indexSyncer.setPerformUndo(false);
+            // Also clears the redo flags: a redo cancelled by a `beforeRedo` listener never fires
+            // `afterRedo`, so without these resets the flags set in `beforeRedo` would leak until the
+            // next successful redo.
+            this.indexSyncer.setPerformRedo(false);
+            _class_private_field_set(this, _isRedoingMoveCells, false);
+            _class_private_method_get(this, _validateUndoRedoDependentCells, validateUndoRedoDependentCells).call(this);
         });
-        this.addHook('afterUndo', ()=>{
+        this.addHook('afterRedo', ()=>{
             this.indexSyncer.setPerformRedo(false);
+            _class_private_method_get(this, _validateUndoRedoDependentCells, validateUndoRedoDependentCells).call(this);
+        });
+        this.addHook('afterRedo', ()=>{
+            _class_private_field_set(this, _isRedoingMoveCells, false);
         });
         this.addHook('afterDetachChild', _class_private_field_get(this, _onAfterDetachChild));
         this.addHook('beforeAutofill', _class_private_field_get(this, _onBeforeAutofill));
+        this.addHook('beforeMoveCells', _class_private_field_get(this, _onBeforeMoveCells));
+        this.addHook('afterMoveCells', _class_private_field_get(this, _onAfterMoveCells));
+        this.addHook('afterRenderer', _class_private_field_get(this, _onAfterRenderer));
         _class_private_field_get(this, _engineListeners)?.forEach(([eventName, listener])=>this.engine.on(eventName, listener));
+        _class_private_method_get(this, _refreshHyperlinksSetting, refreshHyperlinksSetting).call(this);
+        this.registerShortcuts();
         super.enablePlugin();
     }
     /**
    * Disables the plugin functionality for this Handsontable instance.
    */ disablePlugin() {
+        _class_private_method_get(this, _unwrapRenderedHyperlinks, unwrapRenderedHyperlinks).call(this);
+        this.unregisterShortcuts();
         _class_private_field_get(this, _engineListeners)?.forEach(([eventName, listener])=>this.engine?.off(eventName, listener));
         if (this.engine) {
             unregisterEngine(this.engine, this.hot);
@@ -463,7 +698,10 @@ var /**
             this.engine.updateConfig(newEngineSettings);
         }
         const pluginSettings = this.hot.getSettings()[PLUGIN_KEY];
-        if (pluginSettings !== undefined && typeof pluginSettings !== 'boolean' && pluginSettings.sheetName !== undefined && pluginSettings.sheetName !== this.sheetName) {
+        if (pluginSettings !== undefined && typeof pluginSettings !== 'boolean' && pluginSettings.sheetName !== undefined && // Sheet ids are compared rather than names, because `sheetName` holds the engine's casing
+        // while the setting keeps the one it was written with. An unknown name has no id, which
+        // still differs from the current one and lets `switchSheet` report it.
+        this.engine?.getSheetId(pluginSettings.sheetName) !== this.sheetId) {
             this.switchSheet(pluginSettings.sheetName);
         }
         // If no data was passed to the `updateSettings` method and no sheet is connected to the instance -> create a
@@ -480,6 +718,7 @@ var /**
                 }
             }
         }
+        _class_private_method_get(this, _refreshHyperlinksSetting, refreshHyperlinksSetting).call(this);
         super.updatePlugin(newSettings);
     }
     /**
@@ -574,6 +813,48 @@ var /**
         });
     }
     /**
+   * Registers the shortcut that opens the link of the selected `HYPERLINK` cell. The anchor is kept
+   * out of the tab order, so this is the only keyboard path to the link.
+   *
+   * @private
+   */ registerShortcuts() {
+        this.hot.getShortcutManager().getContext('grid')?.addShortcut({
+            keys: [
+                [
+                    'Alt',
+                    'Enter'
+                ]
+            ],
+            callback: ()=>{
+                const highlight = this.hot.getSelectedRangeActive()?.highlight;
+                if (!highlight || highlight.row === null || highlight.col === null) {
+                    return;
+                }
+                const href = _class_private_method_get(this, _getHyperlinkHref, getHyperlinkHref).call(this, highlight.row, highlight.col);
+                if (href !== null) {
+                    this.hot.rootWindow.open(href, '_blank', 'noopener,noreferrer');
+                }
+            },
+            stopPropagation: true,
+            // The shortcut prevents the default action and stops propagation whenever `runOnlyIf`
+            // passes, so it must claim the chord only for a cell that actually resolves to a link.
+            // Testing just `isCell()` would swallow `Alt`+`Enter` grid-wide and break a host
+            // application's own handler for it.
+            runOnlyIf: ()=>{
+                const highlight = this.hot.getSelectedRangeActive()?.highlight;
+                return _class_private_field_get(this, _hyperlinksEnabled) && !!highlight?.isCell() && highlight.row !== null && highlight.col !== null && _class_private_method_get(this, _getHyperlinkHref, getHyperlinkHref).call(this, highlight.row, highlight.col) !== null;
+            },
+            group: SHORTCUTS_GROUP
+        });
+    }
+    /**
+   * Removes the shortcuts registered by the plugin.
+   *
+   * @private
+   */ unregisterShortcuts() {
+        this.hot.getShortcutManager().getContext('grid')?.removeShortcutsByGroup(SHORTCUTS_GROUP);
+    }
+    /**
    * Renders dependent sheets (handsontable instances) based on the changes - list of the
    * recalculated dependent cells.
    *
@@ -651,7 +932,7 @@ var /**
             warn(`Not possible to set cell data at ${JSON.stringify(address)}`);
             return;
         }
-        const cellMeta = this.hot.getCellMeta(row, column);
+        const cellMeta = this.hot.getCellMetaTransient(row, column);
         if (isDate(newValue, cellMeta.type)) {
             if (isDateValid(newValue)) {
                 // Rewriting date in HOT format to HF format.
@@ -663,13 +944,97 @@ var /**
         }
         return this.engine?.setCellContents(address, newValue);
     }
+    /**
+   * Executes the HyperFormula move or copy operation prepared in `beforeMoveCells`. Called by
+   * the MoveCells plugin BEFORE any grid mutation (cell meta, selection, undo history),
+   * so a failed engine operation aborts the whole `moveCells` operation atomically instead of
+   * leaving the grid state recording a move whose data write never happened.
+   *
+   * For a MOVE, calls `engine.moveCells`, which physically relocates cell content and adjusts
+   * all dependent formula references (Excel-style). For a COPY, calls `engine.copy` followed
+   * by `engine.paste`, which duplicates the content with adjusted relative references. Note:
+   * `engine.copy` reads cell values and must NOT be wrapped in `engine.batch` because batch
+   * suspends evaluation, causing `copy` to throw `EvaluationSuspendedError`.
+   *
+   * During undo and non-move redo operations, the engine has already been advanced in the
+   * `beforeUndo`/`beforeRedo` hook, so this method only enables the HOT-data sync in the
+   * `afterMoveCells` listener. A move redo is validated first, then executed here to keep a
+   * rejected move from advancing HyperFormula.
+   *
+   * This is the second half of a two-phase protocol with the MoveCells plugin: `beforeMoveCells`
+   * prepares `#pendingMoveCells`, and this method commits it. It is internal despite being reachable
+   * through `getPlugin('formulas')` — not part of the public API.
+   *
+   * @private
+   * @returns {boolean} `true` when the engine operation succeeded (or was intentionally
+   *   skipped); `false` when there is no prepared operation or the engine rejected it.
+   */ commitPendingMoveCells() {
+        if (!this.engine || !_class_private_field_get(this, _pendingMoveCells)) {
+            return false;
+        }
+        const { source, dest, isCopy, rect } = _class_private_field_get(this, _pendingMoveCells);
+        _class_private_field_set(this, _pendingMoveCells, null);
+        _class_private_field_set(this, _moveCellsChanges, null);
+        if (this.indexSyncer?.isPerformingUndoRedo() && !_class_private_field_get(this, _isRedoingMoveCells)) {
+            _class_private_field_set(this, _committedMoveCells, rect);
+            return true;
+        }
+        // HyperFormula can still throw for cases the isItPossibleTo* pre-checks in
+        // `beforeMoveCells` do not cover. Failing here is safe: the core has not mutated
+        // anything yet and aborts the whole operation when `false` is returned.
+        try {
+            if (isCopy) {
+                // copy() reads cell values and cannot run inside batch() (evaluation must not be suspended).
+                this.engine.copy(source);
+                _class_private_field_set(this, _moveCellsChanges, this.engine.paste(dest));
+            } else {
+                _class_private_field_set(this, _moveCellsChanges, this.engine.batch(()=>{
+                    this.engine.moveCells(source, dest);
+                }));
+            }
+        } catch (e) {
+            const operation = isCopy ? 'copy/paste' : 'moveCells';
+            const reason = e instanceof Error ? e.message : String(e);
+            warn(`Formulas: HyperFormula operation failed during ${operation}: ${reason}`);
+            return false;
+        }
+        _class_private_field_set(this, _committedMoveCells, rect);
+        return true;
+    }
     constructor(...args){
-        super(...args), _class_private_method_init(this, _exportChangeValue), _class_private_method_init(this, _updateSheetNameAndSheetId), _class_private_method_init(this, _getValueGetterValue), _class_private_method_init(this, _getProcessedSourceDataArray), _class_private_field_init(this, _internalOperationPending, {
+        super(...args), _class_private_method_init(this, _exportChangeValue), _class_private_method_init(this, _updateSheetNameAndSheetId), _class_private_method_init(this, _refreshHyperlinksSetting), _class_private_method_init(this, _unwrapRenderedHyperlinks), _class_private_method_init(this, _unwrapLink), _class_private_method_init(this, _unwrapHyperlink), _class_private_method_init(this, _getHyperlinkHref), _class_private_method_init(this, _registerUndoRedoWrite), _class_private_method_init(this, _validateUndoRedoDependentCells), _class_private_method_init(this, _getValueGetterValue), _class_private_method_init(this, _getProcessedSourceDataArray), _class_private_method_init(this, _mapsToContiguousHfBlock), _class_private_method_init(this, _syncHotDataAfterMoveCells), _class_private_method_init(this, _removeSpansFromEngine), _class_private_field_init(this, _internalOperationPending, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _hyperlinksEnabled, {
             writable: true,
             value: void 0
         }), _class_private_field_init(this, _hotWasInitializedWithEmptyData, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _pendingMoveCells, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _committedMoveCells, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _isRedoingMoveCells, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _moveCellsChanges, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _moveCellsSyncPending, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _undoRedoDependentCells, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _undoRedoChangedCells, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _undoRedoWroteData, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onEngineValuesUpdated, {
             writable: true,
             value: void 0
@@ -709,6 +1074,9 @@ var /**
         }), _class_private_field_init(this, _onModifyData, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _onAfterRenderer, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onModifySourceData, {
             writable: true,
             value: void 0
@@ -742,10 +1110,16 @@ var /**
         }), _class_private_field_init(this, _onAfterRemoveCol, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _onBeforeMoveCells, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterMoveCells, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onAfterDetachChild, {
             writable: true,
             value: void 0
-        }), _class_private_field_set(this, _internalOperationPending, false), _class_private_field_set(this, _hotWasInitializedWithEmptyData, false), _class_private_field_set(this, _onEngineValuesUpdated, (changes)=>{
+        }), _class_private_field_set(this, _internalOperationPending, false), _class_private_field_set(this, _hyperlinksEnabled, false), _class_private_field_set(this, _hotWasInitializedWithEmptyData, false), _class_private_field_set(this, _pendingMoveCells, null), _class_private_field_set(this, _committedMoveCells, null), _class_private_field_set(this, _isRedoingMoveCells, false), _class_private_field_set(this, _moveCellsChanges, null), _class_private_field_set(this, _moveCellsSyncPending, false), _class_private_field_set(this, _undoRedoDependentCells, []), _class_private_field_set(this, _undoRedoChangedCells, []), _class_private_field_set(this, _undoRedoWroteData, false), _class_private_field_set(this, _onEngineValuesUpdated, (changes)=>{
             const exportedChanges = changes.map((change)=>_class_private_method_get(this, _exportChangeValue, exportChangeValue).call(this, change));
             this.hot.runHooks('afterFormulasValuesUpdate', exportedChanges);
         }), _class_private_field_set(this, _onEngineNamedExpressionsAdded, (namedExpressionName, changes)=>{
@@ -755,7 +1129,14 @@ var /**
         }), _class_private_field_set(this, _onEngineSheetAdded, (addedSheetDisplayName)=>{
             this.hot.runHooks('afterSheetAdded', addedSheetDisplayName);
         }), _class_private_field_set(this, _onEngineSheetRenamed, (oldDisplayName, newDisplayName)=>{
-            _class_private_method_get(this, _updateSheetNameAndSheetId, updateSheetNameAndSheetId).call(this, newDisplayName);
+            // The event is engine-wide, so it also reaches instances that do not own the renamed sheet.
+            // Repointing those would make them operate on a sheet belonging to another instance.
+            // Sheet ids are compared rather than names: the engine matches names without looking at the
+            // case but keeps the casing it was given, so `sheetName` may differ in case from the event's
+            // display names. The rename is already applied here, so the new name resolves to the same id.
+            if (this.engine?.getSheetId(newDisplayName) === this.sheetId) {
+                _class_private_method_get(this, _updateSheetNameAndSheetId, updateSheetNameAndSheetId).call(this, newDisplayName);
+            }
             this.hot.runHooks('afterSheetRenamed', oldDisplayName, newDisplayName);
         }), _class_private_field_set(this, _onEngineSheetRemoved, (removedSheetDisplayName, changes)=>{
             this.hot.runHooks('afterSheetRemoved', removedSheetDisplayName, changes);
@@ -822,7 +1203,7 @@ var /**
                     col: this.columnAxisSyncer.getHfIndexFromVisualIndex(visualColumn),
                     sheet: this.sheetId
                 };
-                const cellMeta = this.hot.getCellMeta(visualRow, visualColumn);
+                const cellMeta = this.hot.getCellMetaTransient(visualRow, visualColumn);
                 let cellValue = this.engine.getCellValue(address); // Date as an integer (Excel-like date).
                 if (cellMeta.type === 'date' && isNumeric(cellValue)) {
                     cellValue = getDateFromExcelDate(cellValue);
@@ -921,8 +1302,11 @@ var /**
             const sourceDataArray = _class_private_method_get(this, _getProcessedSourceDataArray, getProcessedSourceDataArray).call(this);
             sourceDataArray.forEach((rowData, rowIndex)=>{
                 rowData.forEach((cellValue, columnIndex)=>{
-                    const cellMeta = this.hot.getCellMeta(rowIndex, columnIndex, {
-                        skipMetaExtension: true
+                    // The uncached read keeps this full source-data scan from permanently materializing
+                    // one meta object per cell (same no-extension semantics as `skipMetaExtension`).
+                    const cellMeta = this.hot._getMetaManager().getCellMetaUncached(this.hot.toPhysicalRow(rowIndex) ?? rowIndex, this.hot.toPhysicalColumn(columnIndex) ?? columnIndex, {
+                        visualRow: rowIndex,
+                        visualColumn: columnIndex
                     });
                     if (isDate(cellValue, cellMeta.type)) {
                         if (isDateValid(cellValue)) {
@@ -949,7 +1333,10 @@ var /**
             }
             const formulasSettings = this.hot.getSettings()[PLUGIN_KEY];
             const settingsSheetName = isFormulasSettingsObject(formulasSettings) ? formulasSettings.sheetName : undefined;
-            const sheetName = setupSheet(this.engine, settingsSheetName);
+            // Fall back to the sheet this instance already owns. Without it every `loadData`/`updateData`
+            // call adds a sheet and abandons the previous one - with its whole dependency graph - inside
+            // the engine, which the engine then recalculates on every subsequent call.
+            const sheetName = setupSheet(this.engine, settingsSheetName ?? this.sheetName);
             _class_private_method_get(this, _updateSheetNameAndSheetId, updateSheetNameAndSheetId).call(this, sheetName);
             if (source === 'updateSettings') {
                 // For performance reasons, the initialization will be done in afterCellMetaReset hook
@@ -963,6 +1350,17 @@ var /**
                     this.indexSyncer.setupSyncEndpoint(this.engine, this.sheetId);
                     this.renderDependentSheets(dependentCells);
                     _class_private_field_set(this, _internalOperationPending, false);
+                } else {
+                    // The sheet is reused, so leaving it untouched would keep the previous data in the engine
+                    // while the grid already shows the new one. Empty it instead of serving stale values.
+                    _class_private_field_set(this, _internalOperationPending, true);
+                    const dependentCells = this.engine.setSheetContent(this.sheetId, [
+                        []
+                    ]);
+                    // Emptying the sheet changes what the grids reading it compute, so they need a redraw.
+                    this.renderDependentSheets(dependentCells);
+                    _class_private_field_set(this, _internalOperationPending, false);
+                    warn('The loaded data could not be passed to the formula engine, so the formulas were ' + 'cleared. It most likely exceeds the engine\'s `maxRows` or `maxColumns` limit.');
                 }
             } else if (this.sheetName !== null) {
                 this.switchSheet(this.sheetName);
@@ -985,8 +1383,11 @@ var /**
                 sheet: this.sheetId
             };
             let cellValue = this.engine.getCellValue(address); // Date as an integer (Excel like date).
-            const cellMeta = this.hot.getCellMeta(visualRow, visualColumn, {
-                skipMetaExtension: true
+            // The uncached read matters here: this hook fires inside bulk data reads (for example, the
+            // filters column scan), so an eager read would materialize one meta per scanned cell.
+            const cellMeta = this.hot._getMetaManager().getCellMetaUncached(this.hot.toPhysicalRow(visualRow) ?? visualRow, this.hot.toPhysicalColumn(visualColumn) ?? visualColumn, {
+                visualRow,
+                visualColumn
             });
             if (cellMeta.type === 'date' && isNumeric(cellValue)) {
                 cellValue = getDateFromExcelDate(cellValue);
@@ -995,6 +1396,32 @@ var /**
             }
             // If `cellValue` is an object it is expected to be an error
             valueHolder.value = hasValueProperty(cellValue) ? cellValue.value : cellValue;
+        }), _class_private_field_set(this, _onAfterRenderer, (TD, row, column)=>{
+            if (!_class_private_field_get(this, _hyperlinksEnabled) || _class_private_field_get(this, _internalOperationPending)) {
+                return;
+            }
+            // Walkontable recycles TD elements, and a renderer is free to leave its previous DOM in place.
+            // Unwrapping first keeps this idempotent by construction: no anchor nests inside another one
+            // across render passes, and the `href` is always rebuilt from the current formula instead of
+            // inherited from whatever the previous pass resolved. Cleanup for the option being turned off
+            // happens once, in `#refreshHyperlinksSetting`, so this path never runs for a disabled grid.
+            _class_private_method_get(this, _unwrapHyperlink, unwrapHyperlink).call(this, TD);
+            const href = _class_private_method_get(this, _getHyperlinkHref, getHyperlinkHref).call(this, row, column);
+            if (href === null) {
+                return;
+            }
+            const link = this.hot.rootDocument.createElement('a');
+            link.className = HYPERLINK_CLASS_NAME;
+            link.href = href;
+            link.target = '_blank';
+            link.rel = 'noopener noreferrer';
+            // Cell content stays out of the grid's tab order; `Alt`+`Enter` is the keyboard path instead.
+            link.tabIndex = -1;
+            // The nodes are moved, never re-serialized, so a label containing markup stays text.
+            while(TD.firstChild){
+                link.appendChild(TD.firstChild);
+            }
+            TD.appendChild(link);
         }), _class_private_field_set(this, _onModifySourceData, (row, columnOrProp, valueHolder, ioMode)=>{
             if (ioMode !== 'get' || _class_private_field_get(this, _internalOperationPending) || this.sheetName === null || !this.engine?.doesSheetExist(this.sheetName)) {
                 return;
@@ -1024,6 +1451,11 @@ var /**
             valueHolder.value = this.engine.getCellSerialized(address);
         }), _class_private_field_set(this, _onAfterSetDataAtCell, (changes, source)=>{
             if (isBlockedSource(source)) {
+                _class_private_method_get(this, _registerUndoRedoWrite, registerUndoRedoWrite).call(this, changes, source, true);
+                return;
+            }
+            // Skip HF re-sync when we are writing back to HOT after a moveCells HF operation.
+            if (_class_private_field_get(this, _moveCellsSyncPending)) {
                 return;
             }
             // Skip engine sync when there are no changes (e.g. populateFromArray on readOnly cells).
@@ -1077,6 +1509,11 @@ var /**
             this.validateDependentCells(dependentCells, changedCells);
         }), _class_private_field_set(this, _onAfterSetSourceDataAtCell, (changes, source)=>{
             if (isBlockedSource(source)) {
+                _class_private_method_get(this, _registerUndoRedoWrite, registerUndoRedoWrite).call(this, changes, source, false);
+                return;
+            }
+            // Skip HF re-sync when we are writing back to HOT after a moveCells HF operation.
+            if (_class_private_field_get(this, _moveCellsSyncPending)) {
                 return;
             }
             const dependentCells = [];
@@ -1168,30 +1605,121 @@ var /**
             if (isBlockedSource(source)) {
                 return;
             }
-            const descendingHfRows = this.rowAxisSyncer.getRemovedHfIndexes().sort((a, b)=>b - a); // sort numeric values descending
+            const removedSpans = coalesceIndexesToSpans(this.rowAxisSyncer.getRemovedHfIndexes());
             const changes = this.engine.batch(()=>{
-                descendingHfRows.forEach((hfRow)=>{
-                    this.engine.removeRows(this.sheetId, [
-                        hfRow,
-                        1
-                    ]);
-                });
+                _class_private_method_get(this, _removeSpansFromEngine, removeSpansFromEngine).call(this, removedSpans, 'removeRows');
             });
             this.renderDependentSheets(changes);
         }), _class_private_field_set(this, _onAfterRemoveCol, (col, amount, physicalColumns, source)=>{
             if (isBlockedSource(source)) {
                 return;
             }
-            const descendingHfColumns = this.columnAxisSyncer.getRemovedHfIndexes().sort((a, b)=>b - a); // sort numeric values descending
+            const removedSpans = coalesceIndexesToSpans(this.columnAxisSyncer.getRemovedHfIndexes());
             const changes = this.engine.batch(()=>{
-                descendingHfColumns.forEach((hfColumn)=>{
-                    this.engine.removeColumns(this.sheetId, [
-                        hfColumn,
-                        1
-                    ]);
-                });
+                _class_private_method_get(this, _removeSpansFromEngine, removeSpansFromEngine).call(this, removedSpans, 'removeColumns');
             });
             this.renderDependentSheets(changes);
+        }), _class_private_field_set(this, _onBeforeMoveCells, (sourceRange, targetTopLeft, isCopy)=>{
+            if (!isCellRangeLike(sourceRange)) {
+                _class_private_field_set(this, _pendingMoveCells, null);
+                return false;
+            }
+            if (!this.engine || this.sheetId === null) {
+                return;
+            }
+            const topStart = sourceRange.getTopStartCorner();
+            const bottomEnd = sourceRange.getBottomEndCorner();
+            const fromRow = topStart.row;
+            const fromCol = topStart.col;
+            const toRow = bottomEnd.row;
+            const toCol = bottomEnd.col;
+            const targetRow = targetTopLeft.row;
+            const targetCol = targetTopLeft.col;
+            // The engine operates on a single HF rectangle built from the mapped corners below. That is
+            // only equivalent to the visual operation when every visual index in all four spans maps to
+            // consecutive HF indexes. With Filters/TrimRows the HF sheet still contains the trimmed rows,
+            // and sorting or manual move permutes the order — a rectangle would then move cells the grid
+            // never touches, desyncing the engine from the data source. Veto instead.
+            if (!_class_private_method_get(this, _mapsToContiguousHfBlock, mapsToContiguousHfBlock).call(this, this.rowAxisSyncer, fromRow, toRow) || !_class_private_method_get(this, _mapsToContiguousHfBlock, mapsToContiguousHfBlock).call(this, this.columnAxisSyncer, fromCol, toCol) || !_class_private_method_get(this, _mapsToContiguousHfBlock, mapsToContiguousHfBlock).call(this, this.rowAxisSyncer, targetRow, targetRow + (toRow - fromRow)) || !_class_private_method_get(this, _mapsToContiguousHfBlock, mapsToContiguousHfBlock).call(this, this.columnAxisSyncer, targetCol, targetCol + (toCol - fromCol))) {
+                _class_private_field_set(this, _pendingMoveCells, null);
+                return false;
+            }
+            const hfFromRow = this.rowAxisSyncer.getHfIndexFromVisualIndex(fromRow);
+            const hfFromCol = this.columnAxisSyncer.getHfIndexFromVisualIndex(fromCol);
+            const hfToRow = this.rowAxisSyncer.getHfIndexFromVisualIndex(toRow);
+            const hfToCol = this.columnAxisSyncer.getHfIndexFromVisualIndex(toCol);
+            const hfTargetRow = this.rowAxisSyncer.getHfIndexFromVisualIndex(targetRow);
+            const hfTargetCol = this.columnAxisSyncer.getHfIndexFromVisualIndex(targetCol);
+            const source = {
+                start: {
+                    sheet: this.sheetId,
+                    row: hfFromRow,
+                    col: hfFromCol
+                },
+                end: {
+                    sheet: this.sheetId,
+                    row: hfToRow,
+                    col: hfToCol
+                }
+            };
+            const dest = {
+                sheet: this.sheetId,
+                row: hfTargetRow,
+                col: hfTargetCol
+            };
+            if (!isCopy && !this.engine.isItPossibleToMoveCells(source, dest)) {
+                _class_private_field_set(this, _pendingMoveCells, null);
+                return false;
+            }
+            if (isCopy) {
+                // Pre-check the paste target for a COPY the same way isItPossibleToMoveCells guards a
+                // MOVE (e.g. pasting over part of an array formula throws in `engine.paste`), so the
+                // operation vetoes cleanly before the grid mutates instead of failing halfway through.
+                const targetRegion = {
+                    start: dest,
+                    end: {
+                        sheet: this.sheetId,
+                        row: hfTargetRow + (hfToRow - hfFromRow),
+                        col: hfTargetCol + (hfToCol - hfFromCol)
+                    }
+                };
+                if (!this.engine.isItPossibleToSetCellContents(targetRegion)) {
+                    _class_private_field_set(this, _pendingMoveCells, null);
+                    return false;
+                }
+            }
+            _class_private_field_set(this, _pendingMoveCells, {
+                source,
+                dest,
+                isCopy,
+                rect: {
+                    fromRow,
+                    fromCol,
+                    toRow,
+                    toCol,
+                    targetRow,
+                    targetCol,
+                    isCopy
+                }
+            });
+        }), _class_private_field_set(this, _onAfterMoveCells, ()=>{
+            const committed = _class_private_field_get(this, _committedMoveCells);
+            const dependentCells = _class_private_field_get(this, _moveCellsChanges);
+            // Consume the state on every run, including the ones that return early below, so a run without
+            // a committed move behind it cannot pick up the previous operation's leftovers.
+            _class_private_field_set(this, _committedMoveCells, null);
+            _class_private_field_set(this, _moveCellsChanges, null);
+            if (!this.engine || committed === null) {
+                return;
+            }
+            // Sync HOT's source data with HF's updated state so that getDataAtCell returns
+            // correct values for VALUE/EMPTY cells (formula cells are already served via modifyData).
+            _class_private_method_get(this, _syncHotDataAfterMoveCells, syncHotDataAfterMoveCells).call(this, committed);
+            // During undo/redo replay the engine step was skipped (dependentCells is null) and the
+            // HOT re-render after undo/redo refreshes all dependent cells anyway.
+            if (dependentCells !== null) {
+                this.renderDependentSheets(dependentCells, true);
+            }
         }), _class_private_field_set(this, _onAfterDetachChild, (parent, element, finalElementRowIndex)=>{
             _class_private_field_set(this, _internalOperationPending, true);
             const children = element.__children;
@@ -1223,8 +1751,11 @@ function exportChangeValue(change) {
     if (visualRow < 0 || visualColumn < 0) {
         return change;
     }
-    const cellMeta = this.hot.getCellMeta(visualRow, visualColumn, {
-        skipMetaExtension: true
+    // The uncached read keeps the same no-extension semantics as the previous
+    // `skipMetaExtension` read, without permanently materializing the cell meta.
+    const cellMeta = this.hot._getMetaManager().getCellMetaUncached(this.hot.toPhysicalRow(visualRow) ?? visualRow, this.hot.toPhysicalColumn(visualColumn) ?? visualColumn, {
+        visualRow,
+        visualColumn
     });
     let newValue;
     if (cellMeta.type === 'date') {
@@ -1239,16 +1770,116 @@ function exportChangeValue(change) {
     return clone;
 }
 function updateSheetNameAndSheetId(sheetName) {
-    this.sheetName = sheetName;
-    this.sheetId = this.engine?.getSheetId(this.sheetName) ?? null;
+    const sheetId = this.engine?.getSheetId(sheetName) ?? null;
+    // Store the name the engine itself reports. The engine matches names without regard to case
+    // but keeps the casing it was given, so the name passed here may differ from the engine's own.
+    // Keeping them in step makes every exact-string reader of `sheetName` safe by construction.
+    this.sheetName = (sheetId === null ? null : this.engine?.getSheetName(sheetId)) ?? sheetName;
+    this.sheetId = sheetId;
+}
+function refreshHyperlinksSetting() {
+    const pluginSettings = this.hot.getSettings()[PLUGIN_KEY];
+    const wasEnabled = _class_private_field_get(this, _hyperlinksEnabled);
+    _class_private_field_set(this, _hyperlinksEnabled, isFormulasSettingsObject(pluginSettings) && pluginSettings.hyperlinks === true);
+    // Turning the option off is the moment to clean up, not every subsequent draw: a renderer that
+    // leaves its previous DOM in place would keep an anchor that no later render pass rewrites.
+    // Doing it here keeps the per-cell path free for the default, disabled case.
+    if (wasEnabled && !_class_private_field_get(this, _hyperlinksEnabled)) {
+        _class_private_method_get(this, _unwrapRenderedHyperlinks, unwrapRenderedHyperlinks).call(this);
+    }
+}
+function unwrapRenderedHyperlinks() {
+    this.hot.rootElement?.querySelectorAll(`a.${HYPERLINK_CLASS_NAME}`).forEach((link)=>_class_private_method_get(this, _unwrapLink, unwrapLink).call(this, link));
+}
+function unwrapLink(link) {
+    const { parentNode } = link;
+    while(link.firstChild){
+        parentNode?.insertBefore(link.firstChild, link);
+    }
+    link.remove();
+}
+function unwrapHyperlink(TD) {
+    // A cell rendered as plain text has no element children at all, which is the overwhelmingly
+    // common case and the one that must not pay for a selector query on every render pass.
+    if (TD.firstElementChild === null) {
+        return;
+    }
+    let link = TD.querySelector(`a.${HYPERLINK_CLASS_NAME}`);
+    while(link !== null){
+        _class_private_method_get(this, _unwrapLink, unwrapLink).call(this, link);
+        link = TD.querySelector(`a.${HYPERLINK_CLASS_NAME}`);
+    }
+}
+function getHyperlinkHref(row, column) {
+    if (this.sheetName === null || !this.engine?.doesSheetExist(this.sheetName) || !this.rowAxisSyncer || !this.columnAxisSyncer || !this.isFormulaCellType(row, column)) {
+        return null;
+    }
+    const url = this.engine.getCellHyperlink({
+        sheet: this.sheetId,
+        row: this.rowAxisSyncer.getHfIndexFromVisualIndex(row),
+        col: this.columnAxisSyncer.getHfIndexFromVisualIndex(column)
+    });
+    if (url === undefined) {
+        return null;
+    }
+    const href = resolveHyperlinkUrl(url, this.hot.rootDocument.baseURI);
+    if (href === null) {
+        warnOnce(this, HYPERLINK_WARN_KEY, `A "HYPERLINK" formula points at a URL that Handsontable refuses to link to ("${url}"). ` + 'Only the "http", "https", "mailto" and "tel" schemes can be linked.');
+    }
+    return href;
+}
+function registerUndoRedoWrite(changes, source, coreValidatesWrite) {
+    if (source !== 'UndoRedo.undo' && source !== 'UndoRedo.redo') {
+        return;
+    }
+    if (!changes?.length) {
+        return;
+    }
+    _class_private_field_set(this, _undoRedoWroteData, true);
+    if (!coreValidatesWrite) {
+        return;
+    }
+    changes.forEach(([visualRow, prop])=>{
+        if (typeof prop !== 'string' && typeof prop !== 'number') {
+            return;
+        }
+        const visualColumn = this.hot.propToCol(prop);
+        if (!isNumeric(visualRow) || !isNumeric(visualColumn)) {
+            return;
+        }
+        const hfRow = this.rowAxisSyncer.getHfIndexFromVisualIndex(visualRow);
+        const hfColumn = this.columnAxisSyncer.getHfIndexFromVisualIndex(visualColumn);
+        // `-1` marks an index that is out of range or trimmed. Such an address matches no real engine
+        // address, so keeping it would only risk colliding with a genuine dependent cell.
+        if (hfRow === -1 || hfColumn === -1) {
+            return;
+        }
+        _class_private_field_get(this, _undoRedoChangedCells).push({
+            address: {
+                row: hfRow,
+                col: hfColumn,
+                sheet: this.sheetId
+            }
+        });
+    });
+}
+function validateUndoRedoDependentCells() {
+    const dependentCells = _class_private_field_get(this, _undoRedoDependentCells);
+    const changedCells = _class_private_field_get(this, _undoRedoChangedCells);
+    const wroteData = _class_private_field_get(this, _undoRedoWroteData);
+    _class_private_field_set(this, _undoRedoDependentCells, []);
+    _class_private_field_set(this, _undoRedoChangedCells, []);
+    _class_private_field_set(this, _undoRedoWroteData, false);
+    if (wroteData && dependentCells.length) {
+        this.validateDependentCells(dependentCells, changedCells);
+    }
 }
 function getValueGetterValue1(row, column, value) {
     if (isObject(value) && value !== null) {
         const visualRow = this.hot.toVisualRow(row);
         const visualColumn = this.hot.toVisualColumn(column);
-        const cellMeta = this.hot.getCellMeta(visualRow, visualColumn);
-        const valueGetter = cellMeta.valueGetter;
-        value = getValueGetterValue(value, this.hot.getCellMeta(visualRow, visualColumn));
+        const cellMeta = this.hot.getCellMetaTransient(visualRow, visualColumn);
+        value = getValueGetterValue(value, cellMeta);
         if (value !== null && value !== undefined) {
             value = Object(value).toString();
         }
@@ -1290,3 +1921,67 @@ function getProcessedSourceDataArray(row, column, row2, column2) {
         return projected;
     });
 }
+function mapsToContiguousHfBlock(syncer, visualFrom, visualTo) {
+    const hfBase = syncer.getHfIndexFromVisualIndex(visualFrom);
+    if (hfBase < 0) {
+        return false;
+    }
+    for(let offset = 1; offset <= visualTo - visualFrom; offset++){
+        if (syncer.getHfIndexFromVisualIndex(visualFrom + offset) !== hfBase + offset) {
+            return false;
+        }
+    }
+    return true;
+}
+function syncHotDataAfterMoveCells(rect) {
+    const { fromRow: srcFromRow, fromCol: srcFromCol, toRow: srcToRow, toCol: srcToCol, targetRow: tgtFromRow, targetCol: tgtFromCol, isCopy } = rect;
+    const height = srcToRow - srcFromRow + 1;
+    const width = srcToCol - srcFromCol + 1;
+    // Build target values from HF serialized content (formula strings or raw values).
+    const targetData = [];
+    for(let r = 0; r < height; r++){
+        const row = [];
+        for(let c = 0; c < width; c++){
+            const hfRow = this.rowAxisSyncer.getHfIndexFromVisualIndex(tgtFromRow + r);
+            const hfCol = this.columnAxisSyncer.getHfIndexFromVisualIndex(tgtFromCol + c);
+            const serialized = this.engine.getCellSerialized({
+                sheet: this.sheetId,
+                row: hfRow,
+                col: hfCol
+            });
+            row.push(serialized ?? null);
+        }
+        targetData.push(row);
+    }
+    _class_private_field_set(this, _moveCellsSyncPending, true);
+    try {
+        if (!isCopy) {
+            // Clear source cells in HOT's data first (HF already moved them out), so that an
+            // overlapping source/target range does not null out cells the target write is about
+            // to fill — the target data was already snapshotted from HF above.
+            const nullRow = Array.from({
+                length: width
+            }).fill(null);
+            const nullGrid = Array.from({
+                length: height
+            }, ()=>nullRow.slice());
+            this.hot.populateFromArray(srcFromRow, srcFromCol, nullGrid, srcToRow, srcToCol, 'auto');
+        }
+        // Write target cells with HF-serialised content (formula strings preserved).
+        // Use 'auto' source so UndoRedo does not record these writes as separate DataChangeActions
+        // — they are part of the move and are covered by the MoveCellsAction in the undo stack.
+        this.hot.populateFromArray(tgtFromRow, tgtFromCol, targetData, tgtFromRow + height - 1, tgtFromCol + width - 1, 'auto');
+    } finally{
+        _class_private_field_set(this, _moveCellsSyncPending, false);
+    }
+}
+function removeSpansFromEngine(spans, engineMethodName) {
+    for(let end = spans.length; end > 0; end -= REMOVAL_SPANS_CHUNK_SIZE){
+        const chunk = spans.slice(Math.max(0, end - REMOVAL_SPANS_CHUNK_SIZE), end);
+        if (engineMethodName === 'removeRows') {
+            this.engine.removeRows(this.sheetId, ...chunk);
+        } else {
+            this.engine.removeColumns(this.sheetId, ...chunk);
+        }
+    }
+}