@visactor/vtable 0.18.5-alpha.0 → 0.19.0

package/dist/vtable.js

@@ -22470,6 +22470,15 @@
         const pattern = /^-?\d+(\.\d+)?$/;
         return pattern.test(str);
     }
+    function deduplication$1(array) {
+        const result = [];
+        for (let i = 0; i < array.length; i++) {
+            if (result.indexOf(array[i]) === -1) {
+                result.push(array[i]);
+            }
+        }
+        return result;
+    }
 
     const isNode = typeof window === 'undefined' || typeof window.window === 'undefined';
     let arrayFind;
@@ -23032,7 +23041,7 @@
         }
     }
 
-    const indexFirst = (arr, elm) => {
+    const indexFirst$1 = (arr, elm) => {
         let low = 0;
         let high = arr.length - 1;
         while (low <= high) {
@@ -23078,7 +23087,7 @@
             }
             if (sourceIndex > targetIndex) {
                 const sourceVals = [];
-                for (let i = indexFirst(keys, sourceIndex + moveCount - 1); i >= 0; i--) {
+                for (let i = indexFirst$1(keys, sourceIndex + moveCount - 1); i >= 0; i--) {
                     const key = keys[i];
                     if (key >= sourceIndex) {
                         sourceVals.push(this.get(key));
@@ -23097,7 +23106,7 @@
             const { length } = keys;
             if (sourceIndex < targetIndex) {
                 const sourceVals = [];
-                for (let i = indexFirst(keys, sourceIndex); i < length; i++) {
+                for (let i = indexFirst$1(keys, sourceIndex); i < length; i++) {
                     const key = keys[i];
                     if (key >= sourceIndex && key < sourceIndex + moveCount) {
                         sourceVals.push(this.get(key));
@@ -23152,7 +23161,7 @@
                 });
                 this._sorted = true;
             }
-            for (let i = indexFirst(keys, keyFrom); i < length; i++) {
+            for (let i = indexFirst$1(keys, keyFrom); i < length; i++) {
                 const key = keys[i];
                 if (keyFrom <= key && key <= keyTo) {
                     const callRes = fn(this.get(key), key);
@@ -36834,12 +36843,8 @@
                 }
                 if (isAllRowsAuto || table.getDefaultRowHeight(row) === 'auto') {
                     const height = computeRowHeight(row, startCol, endCol, table);
-                    if (update) {
-                        newHeights[row] = Math.round(height);
-                    }
-                    else {
-                        table._setRowHeight(row, height);
-                    }
+                    newHeights[row] = Math.round(height);
+                    table._setRowHeight(row, height);
                 }
             }
             for (let row = table.rowCount - table.bottomFrozenRowCount; row <= rowEnd; row++) {
@@ -36902,7 +36907,7 @@
             }
         }
         else {
-            table.rowHeightsMap.clear();
+            table.clearRowHeightCache();
             for (let row = 0; row < table.rowCount; row++) {
                 newHeights[row] = table.getRowHeight(row);
             }
@@ -36999,7 +37004,22 @@
                     table._setRowHeight(row, newRowHeight);
                 }
             }
-            for (let row = 0; row < table.rowCount; row++) {
+            if (table.heightMode === 'adaptive' ||
+                (table.autoFillHeight && table.getAllRowsHeight() <= table.tableNoFrameHeight)) {
+                for (let row = 0; row <= table.columnHeaderLevelCount - 1; row++) {
+                    const newRowHeight = table.getRowHeight(row);
+                    if (newRowHeight !== oldRowHeights[row]) {
+                        table.scenegraph.updateRowHeight(row, newRowHeight - oldRowHeights[row], true);
+                    }
+                }
+                for (let row = table.rowCount - table.bottomFrozenRowCount; row <= table.rowCount - 1; row++) {
+                    const newRowHeight = table.getRowHeight(row);
+                    if (newRowHeight !== oldRowHeights[row]) {
+                        table.scenegraph.updateRowHeight(row, newRowHeight - oldRowHeights[row], true);
+                    }
+                }
+            }
+            for (let row = table.scenegraph.proxy.rowStart; row <= table.scenegraph.proxy.rowEnd; row++) {
                 const newRowHeight = table.getRowHeight(row);
                 if (newRowHeight !== oldRowHeights[row]) {
                     table.scenegraph.updateRowHeight(row, newRowHeight - oldRowHeights[row], true);
@@ -37369,9 +37389,13 @@
             rowStart = row + 1;
             rowEnd = scene.table.columnHeaderLevelCount - 1;
         }
+        else if (row >= scene.table.rowCount - scene.table.bottomFrozenRowCount) {
+            rowStart = row + 1;
+            rowEnd = scene.table.rowCount - 1;
+        }
         else {
             rowStart = row + 1;
-            rowEnd = scene.bodyRowEnd;
+            rowEnd = Math.min(scene.proxy.rowEnd, scene.table.rowCount - scene.table.bottomFrozenRowCount - 1);
         }
         for (let rowIndex = rowStart; rowIndex <= rowEnd; rowIndex++) {
             for (let colIndex = 0; colIndex < scene.table.colCount; colIndex++) {
@@ -38280,13 +38304,13 @@
         }
         update(backX, lineX, backY, lineY) {
             if (typeof backX === 'number' && typeof lineX === 'number') {
-                this.columnMoverLabel.setAttribute('x', lineX - this.table.stateManager.scroll.horizontalBarPos);
-                this.columnMoverLine.setAttribute('x', lineX - this.table.stateManager.scroll.horizontalBarPos);
+                this.columnMoverLabel.setAttribute('x', lineX);
+                this.columnMoverLine.setAttribute('x', lineX);
                 this.columnMoverBack.setAttribute('x', backX);
             }
             else if (typeof backY === 'number' && typeof lineY === 'number') {
-                this.columnMoverLabel.setAttribute('y', lineY - this.table.stateManager.scroll.verticalBarPos);
-                this.columnMoverLine.setAttribute('y', lineY - this.table.stateManager.scroll.verticalBarPos);
+                this.columnMoverLabel.setAttribute('y', lineY);
+                this.columnMoverLine.setAttribute('y', lineY);
                 this.columnMoverBack.setAttribute('y', backY);
             }
         }
@@ -40785,7 +40809,7 @@
         });
     }
 
-    function updateAutoRow(colStart, colEnd, rowStart, rowEnd, table, direction = 'up') {
+    function updateAutoRow(colStart, colEnd, rowStart, rowEnd, table, direction = 'up', part) {
         if (direction === 'up') {
             for (let col = colStart; col <= colEnd; col++) {
                 for (let row = rowStart; row <= rowEnd; row++) {
@@ -40797,6 +40821,13 @@
                     if (cellGroup._prev) {
                         y = cellGroup._prev?.attribute.y + table.getRowHeight(cellGroup._prev.row);
                     }
+                    else if (part) {
+                        const baseCellGroup = table.scenegraph.highPerformanceGetCell(col, rowEnd + 1, true);
+                        y = baseCellGroup.attribute.y;
+                        for (let r = rowStart; r <= rowEnd; r++) {
+                            y -= table.getRowHeight(r);
+                        }
+                    }
                     else {
                         y = table.getRowsHeight(table.columnHeaderLevelCount, cellGroup.row - 1);
                     }
@@ -40815,6 +40846,13 @@
                     if (cellGroup._next) {
                         y = cellGroup._next?.attribute.y - table.getRowHeight(cellGroup.row);
                     }
+                    else if (part) {
+                        const baseCellGroup = table.scenegraph.highPerformanceGetCell(col, rowStart - 1, true);
+                        y = baseCellGroup.attribute.y;
+                        for (let r = rowStart; r <= rowEnd; r++) {
+                            y += table.getRowHeight(r);
+                        }
+                    }
                     else {
                         y = table.getRowsHeight(table.columnHeaderLevelCount, cellGroup.row - 1);
                     }
@@ -40890,9 +40928,9 @@
             proxy.rowEnd = direction === 'up' ? proxy.rowEnd + count : proxy.rowEnd - count;
             updateRowContent(syncTopRow, syncBottomRow, proxy);
             if (proxy.table.heightMode === 'autoHeight') {
-                updateAutoRow(proxy.bodyLeftCol, proxy.bodyRightCol, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up');
-                updateAutoRow(0, proxy.table.frozenColCount - 1, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up');
-                updateAutoRow(proxy.table.colCount - proxy.table.rightFrozenColCount, proxy.table.colCount - 1, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up');
+                updateAutoRow(proxy.bodyLeftCol, proxy.bodyRightCol, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up', true);
+                updateAutoRow(0, proxy.table.frozenColCount - 1, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up', true);
+                updateAutoRow(proxy.table.colCount - proxy.table.rightFrozenColCount, proxy.table.colCount - 1, syncTopRow, syncBottomRow, proxy.table, distEndRow > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up', true);
                 const cellGroup = proxy.table.scenegraph.highPerformanceGetCell(proxy.colStart, screenTopRow, true);
                 const deltaY = screenTopY - (cellGroup.attribute.y + proxy.table.getFrozenRowsHeight() + proxy.table.scenegraph.proxy.deltaY);
                 proxy.table.scenegraph.proxy.deltaY += deltaY;
@@ -41444,9 +41482,9 @@
             }
             updateRowContent(this.rowUpdatePos, distRow, this);
             if (this.table.heightMode === 'autoHeight') {
-                updateAutoRow(this.bodyLeftCol, this.bodyRightCol, this.rowUpdatePos, distRow, this.table, this.rowUpdateDirection);
-                updateAutoRow(0, this.table.frozenColCount - 1, this.rowUpdatePos, distRow, this.table, this.rowUpdateDirection);
-                updateAutoRow(this.table.colCount - this.table.rightFrozenColCount, this.table.colCount - 1, this.rowUpdatePos, distRow, this.table, this.rowUpdateDirection);
+                updateAutoRow(this.bodyLeftCol, this.bodyRightCol, this.rowUpdatePos, distRow, this.table, this.rowUpdateDirection, true);
+                updateAutoRow(0, this.table.frozenColCount - 1, this.rowUpdatePos, distRow, this.table, this.rowUpdateDirection, true);
+                updateAutoRow(this.table.colCount - this.table.rightFrozenColCount, this.table.colCount - 1, this.rowUpdatePos, distRow, this.table, this.rowUpdateDirection, true);
             }
             this.rowUpdatePos = distRow + 1;
         }
@@ -41614,6 +41652,8 @@
             const columnHeaderGroup = table.scenegraph.getColGroup(col, true);
             const columnGroup = table.scenegraph.getColGroup(col);
             const columnBottomGroup = table.scenegraph.getColGroupInBottom(col);
+            const columnLeftBottomGroup = table.scenegraph.getColGroupInLeftBottomCorner(col);
+            const columnRightBottomGroup = table.scenegraph.getColGroupInRightBottomCorner(col);
             if (columnHeaderGroup) {
                 columnHeaderGroup.setAttribute('width', columnWidth);
                 columnHeaderGroup.forEachChildren((child) => {
@@ -41632,6 +41672,18 @@
                     child.setAttribute('width', columnWidth);
                 });
             }
+            if (columnRightBottomGroup) {
+                columnRightBottomGroup.setAttribute('width', columnWidth);
+                columnRightBottomGroup.forEachChildren((child) => {
+                    child.setAttribute('width', columnWidth);
+                });
+            }
+            if (columnLeftBottomGroup) {
+                columnLeftBottomGroup.setAttribute('width', columnWidth);
+                columnLeftBottomGroup.forEachChildren((child) => {
+                    child.setAttribute('width', columnWidth);
+                });
+            }
         }
         scene.updateContainer();
         if (direction === 'column') {
@@ -42151,7 +42203,7 @@
         });
         const rowHeightsMap = table.rowHeightsMap;
         removeRows.forEach(row => {
-            rowHeightsMap.delAndReorder(row);
+            rowHeightsMap.delete(row);
         });
         if (removeRows.length) {
             resetRowNumber(scene);
@@ -42165,7 +42217,7 @@
         addRows.forEach(row => {
             const needUpdateAfter = addRow(row, scene);
             updateAfter = updateAfter ?? needUpdateAfter;
-            rowHeightsMap.addAndReorder(row);
+            rowHeightsMap.insert(row);
         });
         resetRowNumberAndY(scene);
         if (addRows.length) {
@@ -42273,15 +42325,6 @@
         }
         return row;
     }
-    function deduplication$1(array) {
-        const result = [];
-        for (let i = 0; i < array.length; i++) {
-            if (result.indexOf(array[i]) === -1) {
-                result.push(array[i]);
-            }
-        }
-        return result;
-    }
     function resetRowNumber(scene) {
         scene.bodyGroup.forEachChildren((colGroup) => {
             let rowIndex = scene.bodyRowStart;
@@ -44568,11 +44611,9 @@
             }
         }
         updateRowHeight(row, detaY, skipTableHeightMap) {
-            if (row >= this.proxy.rowStart && row <= this.proxy.rowEnd) {
-                detaY = Math.round(detaY);
-                updateRowHeight(this, row, detaY, skipTableHeightMap);
-                this.updateContainerHeight(row, detaY);
-            }
+            detaY = Math.round(detaY);
+            updateRowHeight(this, row, detaY, skipTableHeightMap);
+            this.updateContainerHeight(row, detaY);
         }
         updateRowsHeight(rows, detaYs, skipTableHeightMap) {
             for (let i = 0; i < rows.length; i++) {
@@ -44640,7 +44681,10 @@
             if (oldHeight === height) {
                 return;
             }
-            this.updateRowHeight(row, height - oldHeight);
+            if ((row >= this.proxy.rowStart && row <= this.proxy.rowEnd) ||
+                (row >= this.table.rowCount - this.table.bottomFrozenRowCount && row <= this.table.rowCount - 1)) {
+                this.updateRowHeight(row, height - oldHeight);
+            }
             this.table._clearRowRangeHeightsMap(row);
         }
         setX(x) {
@@ -44880,7 +44924,7 @@
             this.colHeaderGroup.setDeltaWidth(colHeaderX - this.colHeaderGroup.attribute.width);
             this.rowHeaderGroup.setDeltaWidth(rowHeaderX - this.rowHeaderGroup.attribute.width);
             this.bottomFrozenGroup.setDeltaWidth(colHeaderX - this.bottomFrozenGroup.attribute.width);
-            this.rightFrozenGroup.setDeltaWidth(rightX - this.table.getRightFrozenColsWidth());
+            this.rightFrozenGroup.setDeltaWidth(rightX - this.rightFrozenGroup.attribute.width);
             this.rightTopCornerGroup.setDeltaWidth(rightX - this.rightTopCornerGroup.attribute.width);
             this.rightBottomCornerGroup.setDeltaWidth(rightX - this.rightBottomCornerGroup.attribute.width);
             this.bodyGroup.setDeltaWidth(bodyX - this.bodyGroup.attribute.width);
@@ -45049,9 +45093,30 @@
             this.stage.enableDirtyBounds();
         }
         updateRow(removeCells, addCells, updateCells = []) {
+            const addRows = deduplication$1(addCells.map(cell => cell.row)).sort((a, b) => a - b);
+            const updateRows = deduplication$1(updateCells.map(cell => cell.row)).sort((a, b) => a - b);
+            const isNotFillHeight = this.table.getAllRowsHeight() -
+                [...addRows, ...updateRows].reduce((tolHeight, rowNumber) => {
+                    return tolHeight + this.table.getRowHeight(rowNumber);
+                }, 0) <=
+                this.table.tableNoFrameHeight;
             updateRow(removeCells, addCells, updateCells, this.table);
             this.recalculateColWidths();
-            this.recalculateRowHeights();
+            if (this.table.heightMode === 'adaptive' ||
+                (this.table.autoFillHeight && (this.table.getAllRowsHeight() <= this.table.tableNoFrameHeight || isNotFillHeight))) {
+                this.table.scenegraph.recalculateRowHeights();
+            }
+            else if (this.table.heightMode === 'autoHeight') {
+                for (let i = 0; i < updateRows.length; i++) {
+                    const row = updateRows[i];
+                    const oldHeight = this.table.getRowHeight(row);
+                    const newHeight = computeRowHeight(row, 0, this.table.colCount - 1, this.table);
+                    if ((row >= this.proxy.rowStart && row <= this.proxy.rowEnd) ||
+                        (row >= this.table.rowCount - this.table.bottomFrozenRowCount && row <= this.table.rowCount - 1)) {
+                        this.table.scenegraph.updateRowHeight(row, newHeight - oldHeight);
+                    }
+                }
+            }
             this.table.stateManager.checkFrozen();
             if (!this.isPivot && !this.transpose) {
                 this.component.setFrozenColumnShadow(this.table.frozenColCount - 1);
@@ -45716,20 +45781,44 @@
         let backX;
         let lineY;
         let backY;
-        const cellLocation = state.table.getCellLocation(col, row);
+        const cellLocation = state.table.getCellLocation(state.columnMove.colSource, state.columnMove.rowSource);
         if (cellLocation === 'columnHeader') {
-            (backX = state.columnMove.x),
-                (lineX =
+            backX = state.columnMove.x;
+            if (state.table.isFrozenColumn(col)) {
+                lineX =
                     state.columnMove.colTarget >= state.columnMove.colSource
                         ? state.table.getColsWidth(0, state.columnMove.colTarget)
-                        : state.table.getColsWidth(0, state.columnMove.colTarget - 1));
+                        : state.table.getColsWidth(0, state.columnMove.colTarget - 1);
+            }
+            else if (state.table.isRightFrozenColumn(col)) {
+                lineX = state.table.tableNoFrameWidth - state.table.getColsWidth(targetCell.col + 1, state.table.colCount - 1);
+            }
+            else {
+                lineX =
+                    (state.columnMove.colTarget >= state.columnMove.colSource
+                        ? state.table.getColsWidth(0, state.columnMove.colTarget)
+                        : state.table.getColsWidth(0, state.columnMove.colTarget - 1)) -
+                        state.table.stateManager.scroll.horizontalBarPos;
+            }
         }
         else if (cellLocation === 'rowHeader') {
-            (backY = state.columnMove.y),
-                (lineY =
+            backY = state.columnMove.y;
+            if (state.table.isFrozenRow(row)) {
+                lineY =
                     state.columnMove.rowTarget >= state.columnMove.rowSource
                         ? state.table.getRowsHeight(0, state.columnMove.rowTarget)
-                        : state.table.getRowsHeight(0, state.columnMove.rowTarget - 1));
+                        : state.table.getRowsHeight(0, state.columnMove.rowTarget - 1);
+            }
+            else if (state.table.isBottomFrozenRow(row)) {
+                lineY = state.table.tableNoFrameHeight - state.table.getRowsHeight(targetCell.row + 1, state.table.rowCount - 1);
+            }
+            else {
+                lineY =
+                    (state.columnMove.rowTarget >= state.columnMove.rowSource
+                        ? state.table.getRowsHeight(0, state.columnMove.rowTarget)
+                        : state.table.getRowsHeight(0, state.columnMove.rowTarget - 1)) -
+                        state.table.stateManager.scroll.verticalBarPos;
+            }
         }
         state.table.scenegraph.component.updateMoveCol(backX, lineX, backY, lineY);
         state.table.scenegraph.updateNextFrame();
@@ -45748,6 +45837,28 @@
                 clearWidthsAndHeightsCache(state.columnMove.colSource, state.columnMove.rowSource, state.columnMove.colTarget, state.columnMove.rowTarget, state.table);
                 state.table.clearCellStyleCache();
                 state.table.scenegraph.updateHeaderPosition(state.columnMove.colSource, state.columnMove.rowSource, state.columnMove.colTarget, state.columnMove.rowTarget, sourceMergeInfo, targetMergeInfo);
+                if (state.table.internalProps.frozenColDragHeaderMode === 'adjustFrozenCount' && state.table.isListTable()) {
+                    if (state.table.isFrozenColumn(state.columnMove.colTarget) &&
+                        !state.table.isFrozenColumn(state.columnMove.colSource)) {
+                        state.table.frozenColCount +=
+                            sourceMergeInfo.end.col - sourceMergeInfo.start.col + 1;
+                    }
+                    else if (state.table.isFrozenColumn(state.columnMove.colSource) &&
+                        !state.table.isFrozenColumn(state.columnMove.colTarget)) {
+                        state.table.frozenColCount -=
+                            sourceMergeInfo.end.col - sourceMergeInfo.start.col + 1;
+                    }
+                    if (state.table.isRightFrozenColumn(state.columnMove.colTarget) &&
+                        !state.table.isRightFrozenColumn(state.columnMove.colSource)) {
+                        state.table.rightFrozenColCount +=
+                            sourceMergeInfo.end.col - sourceMergeInfo.start.col + 1;
+                    }
+                    else if (state.table.isRightFrozenColumn(state.columnMove.colSource) &&
+                        !state.table.isRightFrozenColumn(state.columnMove.colTarget)) {
+                        state.table.rightFrozenColCount -=
+                            sourceMergeInfo.end.col - sourceMergeInfo.start.col + 1;
+                    }
+                }
             }
             state.updateCursor();
         }
@@ -47074,14 +47185,15 @@
             if (stateManager.interactionState === InteractionState.scrolling) {
                 return;
             }
-            if (stateManager.interactionState === InteractionState.grabing &&
-                Math.abs(lastX - e.x) + Math.abs(lastY - e.y) >= 1) {
-                if (stateManager.isResizeCol()) ;
-                else if (stateManager.isMoveCol()) {
-                    eventManager.dealColumnMover(eventArgsSet);
-                }
-                else {
-                    eventManager.dealTableSelect(eventArgsSet, true);
+            if (stateManager.interactionState === InteractionState.grabing) {
+                if (Math.abs(lastX - e.x) + Math.abs(lastY - e.y) >= 1) {
+                    if (stateManager.isResizeCol()) ;
+                    else if (stateManager.isMoveCol()) {
+                        eventManager.dealColumnMover(eventArgsSet);
+                    }
+                    else {
+                        eventManager.dealTableSelect(eventArgsSet, true);
+                    }
                 }
                 return;
             }
@@ -48384,7 +48496,9 @@
         }
         dealColumnMover(eventArgsSet) {
             const { eventArgs } = eventArgsSet;
-            this.table.stateManager.updateMoveCol(eventArgs.col, eventArgs.row, eventArgsSet.abstractPos.x, eventArgsSet.abstractPos.y);
+            if (isValid$1(eventArgs.col) && isValid$1(eventArgs.row)) {
+                this.table.stateManager.updateMoveCol(eventArgs.col, eventArgs.row, eventArgsSet.abstractPos.x, eventArgsSet.abstractPos.y);
+            }
         }
         startColumnResize(eventArgsSet) {
         }
@@ -51250,6 +51364,238 @@
         return new DiscreteTableLegend(option, table);
     }
 
+    class NumberRangeMap {
+        data;
+        cumulativeSum;
+        difference;
+        totalSum;
+        table;
+        isUpdate = false;
+        _keys = [];
+        _sorted = false;
+        constructor(table) {
+            this.data = new Map();
+            this._keys.length = 0;
+            this.cumulativeSum = new Map();
+            this.difference = new Map();
+            this.totalSum = 0;
+            this.table = table;
+        }
+        clear() {
+            this.data.clear();
+            this.cumulativeSum.clear();
+            this.difference.clear();
+            this.totalSum = 0;
+        }
+        clearRange() {
+            this.cumulativeSum.clear();
+            this.difference.clear();
+        }
+        add(position, value) {
+            const defaultValue = this.table.getRowHeight(position);
+            if (!this.data.has(position)) {
+                this._keys.push(position);
+                this._sorted = false;
+            }
+            this.data.set(position, value);
+            this.totalSum += value;
+            this.updateDifference(position, value - defaultValue);
+        }
+        remove(position) {
+            if (this.data.has(position)) {
+                const value = this.data.get(position);
+                this.data.delete(position);
+                const index = this._keys.indexOf(position);
+                if (index !== -1) {
+                    this._keys.splice(index, 1);
+                }
+                this.totalSum -= value;
+                const defaultValue = this.table.getRowHeight(position);
+                this.updateDifference(position, defaultValue - value);
+            }
+        }
+        put(position, newValue) {
+            if (this.data.has(position)) {
+                const oldValue = this.data.get(position);
+                this.data.set(position, newValue);
+                const difference = newValue - oldValue;
+                this.totalSum += difference;
+                this.updateDifference(position, difference);
+            }
+            else {
+                this.add(position, newValue);
+            }
+        }
+        get(position) {
+            return this.data.get(position);
+        }
+        has(position) {
+            return this.data.has(position);
+        }
+        _sort() {
+            const { _keys: keys } = this;
+            if (!this._sorted) {
+                keys.sort((a, b) => {
+                    if (a < b) {
+                        return -1;
+                    }
+                    if (a > b) {
+                        return 1;
+                    }
+                    return 0;
+                });
+                this._sorted = true;
+            }
+        }
+        updateDifference(position, difference) {
+            const oldDifference = this.difference.get(position) ?? 0;
+            this.difference.set(position, oldDifference + difference);
+            this.update();
+        }
+        getSumInRange(start, end) {
+            return this.calculatePrefixSum(end) - this.calculatePrefixSum(start - 1);
+        }
+        updateCumulativeSum(position, difference) {
+            for (const [pos, sum] of this.cumulativeSum) {
+                if (pos >= position) {
+                    this.cumulativeSum.set(pos, sum + difference);
+                }
+            }
+        }
+        calculatePrefixSum(position) {
+            if (position < 0) {
+                return 0;
+            }
+            if (this.cumulativeSum.has(position)) {
+                let cache = this.cumulativeSum.get(position);
+                for (const [pos, difference] of this.difference) {
+                    if (pos <= position) {
+                        cache += difference;
+                    }
+                }
+                return cache;
+            }
+            this.dealDiffenence();
+            return this.getCumulativeSum(position);
+        }
+        getCumulativeSum(position) {
+            let sum = 0;
+            for (let i = position; i >= 0; i--) {
+                if (this.cumulativeSum.has(i)) {
+                    sum += this.cumulativeSum.get(i);
+                    break;
+                }
+                else {
+                    sum += this.data.get(i) ?? this.table.getRowHeight(i);
+                }
+            }
+            this.cumulativeSum.set(position, sum);
+            return sum;
+        }
+        update() {
+            if (this.isUpdate) {
+                return;
+            }
+            this.isUpdate = true;
+            setTimeout(() => {
+                this.dealDiffenence();
+                this.isUpdate = false;
+            }, 0);
+        }
+        dealDiffenence() {
+            for (const [sumPos, sum] of this.cumulativeSum) {
+                for (const [difPos, difference] of this.difference) {
+                    if (sumPos >= difPos) {
+                        this.cumulativeSum.set(sumPos, sum + difference);
+                    }
+                }
+            }
+            this.difference.clear();
+        }
+        insert(position, value) {
+            const lastIndex = this.getLastIndex() + 1;
+            this.adjustOrder(position, position + 1, lastIndex - position);
+            if (isValid$1(value)) {
+                this.put(position, value);
+            }
+        }
+        getLastIndex() {
+            this._sort();
+            return this._keys[this._keys.length - 1];
+        }
+        delLast() {
+            const lastIndex = this.getLastIndex();
+            this.remove(lastIndex);
+        }
+        delete(position) {
+            if (!this.has(position)) {
+                return;
+            }
+            const lastIndex = this.getLastIndex();
+            this.adjustOrder(position + 1, position, lastIndex - position);
+            this.delLast();
+        }
+        adjustOrder(sourceIndex, targetIndex, moveCount) {
+            this.clearRange();
+            this._sort();
+            const { _keys: keys } = this;
+            if (sourceIndex > targetIndex) {
+                const sourceVals = [];
+                for (let i = indexFirst(keys, sourceIndex + moveCount - 1); i >= 0; i--) {
+                    const key = keys[i];
+                    if (key >= sourceIndex) {
+                        sourceVals.push(this.get(key));
+                    }
+                    else if (targetIndex <= key && key < sourceIndex) {
+                        this.put(key + moveCount, this.get(key));
+                    }
+                    else if (key < targetIndex) {
+                        break;
+                    }
+                }
+                for (let i = 0; i < moveCount; i++) {
+                    this.put(targetIndex + i, sourceVals[moveCount - 1 - i]);
+                }
+            }
+            const { length } = keys;
+            if (sourceIndex < targetIndex) {
+                const sourceVals = [];
+                for (let i = indexFirst(keys, sourceIndex); i < length; i++) {
+                    const key = keys[i];
+                    if (key >= sourceIndex && key < sourceIndex + moveCount) {
+                        sourceVals.push(this.get(key));
+                    }
+                    else if (sourceIndex + moveCount <= key && key <= targetIndex) {
+                        this.put(key - moveCount, this.get(key));
+                    }
+                    else if (key > targetIndex) {
+                        break;
+                    }
+                }
+                for (let i = 0; i < moveCount; i++) {
+                    this.put(targetIndex + i, sourceVals[i]);
+                }
+            }
+        }
+    }
+    function indexFirst(arr, elm) {
+        let low = 0;
+        let high = arr.length - 1;
+        while (low <= high) {
+            const i = Math.floor((low + high) / 2);
+            if (arr[i] === elm) {
+                return i;
+            }
+            else if (arr[i] > elm) {
+                high = i - 1;
+            }
+            else {
+                low = i + 1;
+            }
+        }
+        return high < 0 ? 0 : high;
+    }
+
     const { toBoxArray } = style;
     const { isTouchEvent } = event;
     const rangeReg = /^\$(\d+)\$(\d+)$/;
@@ -51281,7 +51627,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "0.18.5-alpha.0";
+        version = "0.19.0";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -51352,7 +51698,7 @@
             internalProps.renderChartAsync = renderChartAsync;
             setBatchRenderChartCount(renderChartAsyncBatchCount);
             internalProps.overscrollBehavior = overscrollBehavior ?? 'auto';
-            internalProps._rowHeightsMap = new NumberMap();
+            internalProps._rowHeightsMap = new NumberRangeMap(this);
             internalProps._rowRangeHeightsMap = new Map();
             internalProps._colRangeWidthsMap = new Map();
             internalProps._widthResizedColMap = new Set();
@@ -51706,7 +52052,8 @@
             return 'grid';
         }
         getColsWidth(startCol, endCol) {
-            endCol = Math.min(endCol, this.colCount - 1);
+            startCol = Math.max(startCol, 0);
+            endCol = Math.min(endCol, (this.colCount ?? Infinity) - 1);
             const cachedColWidth = this._colRangeWidthsMap.get(`$${startCol}$${endCol}`);
             if (cachedColWidth !== null && cachedColWidth !== undefined) {
                 return cachedColWidth;
@@ -51759,26 +52106,8 @@
             }
         }
         getRowsHeight(startRow, endRow) {
-            const cachedRowHeight = this._rowRangeHeightsMap.get(`$${startRow}$${endRow}`);
-            if (cachedRowHeight !== null && cachedRowHeight !== undefined) {
-                return cachedRowHeight;
-            }
-            const cachedLowerRowHeight = this._rowRangeHeightsMap.get(`$${startRow}$${endRow - 1}`);
-            if (cachedLowerRowHeight !== null && cachedLowerRowHeight !== undefined) {
-                const height = Math.round(cachedLowerRowHeight +
-                    (this.rowHeightsMap.get(endRow) ??
-                        (this.isColumnHeader(0, endRow) || this.isCornerHeader(0, endRow)
-                            ? Array.isArray(this.defaultHeaderRowHeight) && isNumber$2(this.defaultHeaderRowHeight[endRow])
-                                ? this.defaultHeaderRowHeight[endRow]
-                                : isNumber$2(this.defaultHeaderRowHeight)
-                                    ? this.defaultHeaderRowHeight
-                                    : this.internalProps.defaultRowHeight
-                            : this.internalProps.defaultRowHeight)));
-                if (startRow >= 0 && endRow >= 0) {
-                    this._rowRangeHeightsMap.set(`$${startRow}$${endRow}`, Math.round(height));
-                }
-                return height;
-            }
+            startRow = Math.max(startRow, 0);
+            endRow = Math.min(endRow, (this.rowCount ?? Infinity) - 1);
             let h = 0;
             if (this.heightMode === 'standard' &&
                 !this.autoFillHeight &&
@@ -51792,12 +52121,7 @@
                 h += this.defaultRowHeight * (endRow - Math.max(this.columnHeaderLevelCount, startRow) + 1);
             }
             else {
-                for (let i = startRow; i <= endRow; i++) {
-                    h += this.getRowHeight(i);
-                }
-            }
-            if (startRow >= 0 && endRow >= 0 && h > 0) {
-                this._rowRangeHeightsMap.set(`$${startRow}$${endRow}`, Math.round(h));
+                h = this.rowHeightsMap.getSumInRange(startRow, endRow);
             }
             return Math.round(h);
         }
@@ -51873,22 +52197,7 @@
             }
         }
         _clearRowRangeHeightsMap(row) {
-            if (typeof row !== 'number') {
-                this._rowRangeHeightsMap.clear();
-            }
-            else {
-                const keys = this._rowRangeHeightsMap.keys();
-                for (const key of keys) {
-                    const reg = rangeReg.exec(key);
-                    if (reg) {
-                        const start = Number(reg[1]);
-                        const end = Number(reg[2]);
-                        if (row >= start && row <= end) {
-                            this._rowRangeHeightsMap.delete(key);
-                        }
-                    }
-                }
-            }
+            this.rowHeightsMap.clearRange();
         }
         _getColContentWidth(col) {
             return Number(this.colContentWidthsMap.get(col));
@@ -52425,7 +52734,7 @@
             setBatchRenderChartCount(renderChartAsyncBatchCount);
             internalProps.overscrollBehavior = overscrollBehavior ?? 'auto';
             internalProps.cellTextOverflows = {};
-            internalProps._rowHeightsMap = new NumberMap();
+            internalProps._rowHeightsMap = new NumberRangeMap(this);
             internalProps._rowRangeHeightsMap = new Map();
             internalProps._colRangeWidthsMap = new Map();
             internalProps._widthResizedColMap = new Set();
@@ -53130,6 +53439,10 @@
         }
         _canDragHeaderPosition(col, row) {
             if (this.isHeader(col, row) && this.stateManager.isSelected(col, row)) {
+                if (this.internalProps.frozenColDragHeaderMode === 'disabled' &&
+                    (this.isFrozenColumn(col) || this.isRightFrozenColumn(col))) {
+                    return false;
+                }
                 const selectRange = this.stateManager.select.ranges[0];
                 if (this.isColumnHeader(col, row)) {
                     if (selectRange.end.row !== this.rowCount - 1) {
@@ -54052,12 +54365,425 @@
         return isHasChart;
     }
 
+    class DimensionTree {
+        sharedVar;
+        sizeIncludeParent = false;
+        rowExpandLevel;
+        hierarchyType;
+        tree = {
+            id: 0,
+            dimensionKey: '',
+            value: '',
+            children: [],
+            level: -1,
+            levelSpan: 1,
+            startIndex: 0,
+            size: 0,
+            startInTotal: 0,
+            hierarchyState: undefined
+        };
+        totalLevel = 0;
+        dimensionKeys = new NumberMap();
+        cache = new Map();
+        constructor(tree, sharedVar, hierarchyType = 'grid', rowExpandLevel = undefined) {
+            this.sizeIncludeParent = rowExpandLevel !== null && rowExpandLevel !== undefined;
+            this.rowExpandLevel = rowExpandLevel;
+            this.hierarchyType = hierarchyType;
+            this.sharedVar = sharedVar;
+            this.reset(tree);
+        }
+        reset(tree, updateTreeNode = false) {
+            this.cache.clear();
+            this.dimensionKeys = new NumberMap();
+            this.tree.children = tree;
+            this.setTreeNode(this.tree, 0, this.tree);
+            this.totalLevel = this.dimensionKeys.count();
+        }
+        setTreeNode(node, startIndex, parent) {
+            node.startIndex = startIndex;
+            node.startInTotal = (parent.startInTotal ?? 0) + node.startIndex;
+            if (node.dimensionKey ?? node.indicatorKey) {
+                !this.dimensionKeys.contain(node.indicatorKey ? IndicatorDimensionKeyPlaceholder : node.dimensionKey) &&
+                    this.dimensionKeys.put(node.level, node.indicatorKey ? IndicatorDimensionKeyPlaceholder : node.dimensionKey);
+                if (!node.id) {
+                    node.id = ++this.sharedVar.seqId;
+                }
+            }
+            let size = node.dimensionKey ? (this.sizeIncludeParent ? 1 : 0) : 0;
+            const children = node.children || node.columns;
+            if (this.hierarchyType === 'grid') {
+                if (children?.length >= 1) {
+                    children.forEach((n) => {
+                        n.level = (node.level ?? 0) + 1;
+                        size += this.setTreeNode(n, size, node);
+                    });
+                }
+                else {
+                    size = 1;
+                }
+            }
+            else if (node.hierarchyState === HierarchyState.expand && children?.length >= 1) {
+                children.forEach((n) => {
+                    n.level = (node.level ?? 0) + 1;
+                    size += this.setTreeNode(n, size, node);
+                });
+            }
+            else if (node.hierarchyState === HierarchyState.collapse && children?.length >= 1) {
+                children.forEach((n) => {
+                    n.level = (node.level ?? 0) + 1;
+                    this.setTreeNode(n, size, node);
+                });
+            }
+            else if (!node.hierarchyState && node.level + 1 < this.rowExpandLevel && children?.length >= 1) {
+                node.hierarchyState = HierarchyState.expand;
+                children.forEach((n) => {
+                    n.level = (node.level ?? 0) + 1;
+                    size += this.setTreeNode(n, size, node);
+                });
+            }
+            else if (children?.length >= 1) {
+                node.hierarchyState = HierarchyState.collapse;
+                children.forEach((n) => {
+                    n.level = (node.level ?? 0) + 1;
+                    this.setTreeNode(n, size, node);
+                });
+            }
+            else {
+                node.hierarchyState = HierarchyState.none;
+                size = 1;
+            }
+            node.size = size;
+            return size;
+        }
+        getTreePath(index, maxDeep = 30) {
+            const path = [];
+            this.searchPath(index, this.tree, path, maxDeep);
+            path.shift();
+            return path;
+        }
+        getTreePathByCellIds(ids) {
+            const path = [];
+            let nodes = this.tree.children;
+            for (let i = 0; i < ids.length; i++) {
+                const id = ids[i];
+                const pathNode = this.findNodeById(nodes, id);
+                if (pathNode) {
+                    path.push(pathNode);
+                    nodes = pathNode.children;
+                }
+                else {
+                    break;
+                }
+            }
+            return path;
+        }
+        findNodeById(nodes, id) {
+            return nodes.find(node => {
+                return node.id === id;
+            });
+        }
+        searchPath(index, node, path, maxDeep) {
+            if (!node) {
+                return;
+            }
+            if (index < node.startIndex || index >= node.startIndex + node.size) {
+                return;
+            }
+            path.push(node);
+            if (!node.children || node.children.length === 0 || node.level >= maxDeep) {
+                return;
+            }
+            const cIndex = index - node.startIndex;
+            if (this.cache.has(node.level + 1)) {
+                const cacheNode = this.cache.get(node.level + 1);
+                if (cIndex >= cacheNode.startIndex && cIndex < cacheNode.startIndex + cacheNode.size) {
+                    this.searchPath(cIndex, cacheNode, path, maxDeep);
+                    return;
+                }
+            }
+            let left = 0;
+            let right = node.children.length - 1;
+            while (left <= right) {
+                const middle = Math.floor((left + right) / 2);
+                const element = node.children[middle];
+                if (cIndex >= element.startIndex && cIndex < element.startIndex + element.size) {
+                    this.cache.set(element.level, element);
+                    const deleteLevels = [];
+                    this.cache.forEach((node, key) => {
+                        if (key > element.level) {
+                            deleteLevels.push(key);
+                        }
+                    });
+                    deleteLevels.forEach(key => {
+                        this.cache.delete(key);
+                    });
+                    this.searchPath(cIndex, element, path, maxDeep);
+                    break;
+                }
+                else if (cIndex < element.startIndex) {
+                    right = middle - 1;
+                }
+                else {
+                    left = middle + 1;
+                }
+            }
+            return;
+        }
+        movePosition(level, sourceIndex, targetIndex) {
+            let parNode;
+            let sourceSubIndex;
+            let targetSubIndex;
+            const findTargetNode = (node, subIndex) => {
+                if (sourceSubIndex !== undefined && targetSubIndex !== undefined) {
+                    return;
+                }
+                if (node.level === level) {
+                    if (node.startInTotal === sourceIndex) {
+                        sourceSubIndex = subIndex;
+                    }
+                    if (node.startInTotal <= targetIndex && targetIndex <= node.startInTotal + node.size - 1) {
+                        targetSubIndex = subIndex;
+                    }
+                }
+                const children = node.children || node.columns;
+                if (children && node.level < level) {
+                    parNode = node;
+                    for (let i = 0; i < children.length; i++) {
+                        if ((sourceIndex >= children[i].startInTotal && sourceIndex <= children[i].startInTotal + children[i].size) ||
+                            (targetIndex >= children[i].startInTotal && targetIndex <= children[i].startInTotal + children[i].size)) {
+                            findTargetNode(children[i], i);
+                        }
+                    }
+                }
+            };
+            findTargetNode(this.tree, 0);
+            const children = parNode.children || parNode.columns;
+            const sourceColumns = children.splice(sourceSubIndex, 1);
+            sourceColumns.unshift(targetSubIndex, 0);
+            Array.prototype.splice.apply(children, sourceColumns);
+        }
+        getCopiedTree() {
+            const children = cloneDeep(this.tree.children);
+            clearNode(children);
+            return children;
+        }
+    }
+    function generateLayoutTree(tree, children) {
+        children?.forEach((node) => {
+            const diemnsonNode = {
+                dimensionKey: node.dimensionKey,
+                indicatorKey: node.indicatorKey,
+                value: node.value,
+                hierarchyState: node.hierarchyState,
+                children: undefined
+            };
+            tree.push(diemnsonNode);
+            if (node.children) {
+                diemnsonNode.children = [];
+                generateLayoutTree(diemnsonNode.children, node.children);
+            }
+        });
+    }
+    function countLayoutTree(children, countParentNode) {
+        let count = 0;
+        children?.forEach((node) => {
+            if (countParentNode) {
+                count++;
+            }
+            else {
+                if (!node.children || node.children.length === 0) {
+                    count++;
+                }
+            }
+            if (node.children) {
+                count += countLayoutTree(node.children, countParentNode);
+            }
+        });
+        return count;
+    }
+    function dealHeader(hd, _headerCellIds, results, roots, row, layoutMap) {
+        const id = hd.id;
+        const dimensionInfo = layoutMap.rowsDefine?.find(dimension => typeof dimension === 'string' ? false : dimension.dimensionKey === hd.dimensionKey) ??
+            layoutMap.columnsDefine?.find(dimension => typeof dimension === 'string' ? false : dimension.dimensionKey === hd.dimensionKey);
+        const indicatorInfo = layoutMap.indicatorsDefine?.find(indicator => {
+            if (typeof indicator === 'string') {
+                return false;
+            }
+            if (hd.indicatorKey) {
+                return indicator.indicatorKey === hd.indicatorKey;
+            }
+            return indicator.title === hd.value;
+        });
+        const cell = {
+            id,
+            title: hd.value ?? indicatorInfo?.title,
+            field: hd.dimensionKey,
+            style: typeof (indicatorInfo ?? dimensionInfo)?.headerStyle === 'function'
+                ? (indicatorInfo ?? dimensionInfo)?.headerStyle
+                : Object.assign({}, (indicatorInfo ?? dimensionInfo)?.headerStyle),
+            headerType: indicatorInfo?.headerType ?? dimensionInfo?.headerType ?? 'text',
+            headerIcon: indicatorInfo?.headerIcon ?? dimensionInfo?.headerIcon,
+            define: Object.assign({}, hd, indicatorInfo ?? dimensionInfo),
+            fieldFormat: indicatorInfo?.headerFormat ?? dimensionInfo?.headerFormat,
+            dropDownMenu: indicatorInfo?.dropDownMenu ?? dimensionInfo?.dropDownMenu,
+            pivotInfo: {
+                value: hd.value,
+                dimensionKey: hd.dimensionKey,
+                isPivotCorner: false
+            },
+            width: dimensionInfo?.width,
+            minWidth: dimensionInfo?.minWidth,
+            maxWidth: dimensionInfo?.maxWidth,
+            showSort: indicatorInfo?.showSort ?? dimensionInfo?.showSort,
+            description: dimensionInfo?.description
+        };
+        if (indicatorInfo) {
+            if (indicatorInfo.customRender) {
+                hd.customRender = indicatorInfo.customRender;
+            }
+            if (!isValid$1(layoutMap._indicators?.find(indicator => indicator.indicatorKey === indicatorInfo.indicatorKey))) {
+                layoutMap._indicators?.push({
+                    id: ++layoutMap.sharedVar.seqId,
+                    indicatorKey: indicatorInfo.indicatorKey,
+                    field: indicatorInfo.indicatorKey,
+                    fieldFormat: indicatorInfo?.format,
+                    cellType: indicatorInfo?.cellType ?? indicatorInfo?.columnType ?? 'text',
+                    chartModule: 'chartModule' in indicatorInfo ? indicatorInfo.chartModule : null,
+                    chartSpec: 'chartSpec' in indicatorInfo ? indicatorInfo.chartSpec : null,
+                    sparklineSpec: 'sparklineSpec' in indicatorInfo ? indicatorInfo.sparklineSpec : null,
+                    style: indicatorInfo?.style,
+                    icon: indicatorInfo?.icon,
+                    define: Object.assign({}, hd, indicatorInfo, {
+                        dragHeader: dimensionInfo?.dragHeader
+                    }),
+                    width: indicatorInfo?.width,
+                    minWidth: indicatorInfo?.minWidth,
+                    maxWidth: indicatorInfo?.maxWidth,
+                    disableColumnResize: indicatorInfo?.disableColumnResize
+                });
+            }
+        }
+        else if (hd.indicatorKey) {
+            if (!isValid$1(layoutMap._indicators?.find(indicator => indicator.indicatorKey === hd.indicatorKey))) {
+                layoutMap._indicators?.push({
+                    id: ++layoutMap.sharedVar.seqId,
+                    indicatorKey: hd.indicatorKey,
+                    field: hd.indicatorKey,
+                    cellType: 'text',
+                    define: Object.assign({}, hd)
+                });
+            }
+        }
+        results[id] = cell;
+        layoutMap._headerObjects[id] = cell;
+        _headerCellIds[row][layoutMap.colIndex] = id;
+        for (let r = row - 1; r >= 0; r--) {
+            _headerCellIds[r][layoutMap.colIndex] = roots[r];
+        }
+        if (hd.levelSpan > 1) {
+            for (let i = 1; i < hd.levelSpan; i++) {
+                if (!_headerCellIds[row + i]) {
+                    _headerCellIds[row + i] = [];
+                }
+                _headerCellIds[row + i][layoutMap.colIndex] = id;
+            }
+        }
+        if (hd.children?.length >= 1) {
+            layoutMap
+                ._addHeaders(_headerCellIds, row + (hd.levelSpan ?? 1), hd.children ?? [], [
+                ...roots,
+                ...Array(hd.levelSpan ?? 1).fill(id)
+            ])
+                .forEach(c => results.push(c));
+        }
+        else {
+            for (let r = row + 1; r < _headerCellIds.length; r++) {
+                _headerCellIds[r][layoutMap.colIndex] = id;
+            }
+            layoutMap.colIndex++;
+        }
+    }
+    function dealHeaderForTreeMode(hd, _headerCellIds, results, roots, row, totalLevel, show, dimensions, layoutMap) {
+        const id = hd.id;
+        const dimensionInfo = dimensions.find(dimension => typeof dimension === 'string' ? false : dimension.dimensionKey === hd.dimensionKey);
+        const cell = {
+            id,
+            title: hd.value,
+            field: hd.dimensionKey,
+            style: hd.level + 1 === totalLevel || typeof dimensionInfo?.headerStyle === 'function'
+                ? dimensionInfo?.headerStyle
+                : Object.assign({}, dimensionInfo?.headerStyle, { textAlign: 'left' }),
+            headerType: dimensionInfo?.headerType ?? 'text',
+            headerIcon: dimensionInfo?.headerIcon,
+            define: Object.assign(hd, {
+                linkJump: dimensionInfo?.linkJump,
+                linkDetect: dimensionInfo?.linkDetect,
+                templateLink: dimensionInfo?.templateLink,
+                keepAspectRatio: dimensionInfo?.keepAspectRatio ?? false,
+                imageAutoSizing: dimensionInfo?.imageAutoSizing,
+                headerCustomRender: dimensionInfo?.headerCustomRender,
+                headerCustomLayout: dimensionInfo?.headerCustomLayout,
+                dragHeader: dimensionInfo?.dragHeader,
+                disableHeaderHover: !!dimensionInfo?.disableHeaderHover,
+                disableHeaderSelect: !!dimensionInfo?.disableHeaderSelect
+            }),
+            fieldFormat: dimensionInfo?.headerFormat,
+            dropDownMenu: dimensionInfo?.dropDownMenu,
+            pivotInfo: {
+                value: hd.value,
+                dimensionKey: hd.dimensionKey,
+                isPivotCorner: false
+            },
+            hierarchyLevel: hd.level,
+            dimensionTotalLevel: totalLevel,
+            hierarchyState: hd.level + 1 === totalLevel ? undefined : hd.hierarchyState,
+            width: dimensionInfo?.width,
+            minWidth: dimensionInfo?.minWidth,
+            maxWidth: dimensionInfo?.maxWidth,
+            parentCellId: roots[roots.length - 1]
+        };
+        results[id] = cell;
+        layoutMap._headerObjects[id] = cell;
+        _headerCellIds[row][layoutMap.colIndex] = id;
+        for (let r = row - 1; r >= 0; r--) {
+            _headerCellIds[r][layoutMap.colIndex] = roots[r];
+        }
+        if (hd.hierarchyState === HierarchyState.expand && hd.children?.length >= 1) {
+            show && layoutMap.colIndex++;
+            layoutMap
+                ._addHeadersForTreeMode(_headerCellIds, row, hd.children ?? [], [...roots, id], totalLevel, show && hd.hierarchyState === HierarchyState.expand, dimensions)
+                .forEach(c => results.push(c));
+        }
+        else {
+            show && layoutMap.colIndex++;
+            for (let r = row + 1; r < _headerCellIds.length; r++) {
+                _headerCellIds[r][layoutMap.colIndex] = id;
+            }
+        }
+    }
+    function clearNode(children) {
+        for (let i = 0; i < children.length; i++) {
+            const node = children[i];
+            delete node.level;
+            delete node.startIndex;
+            delete node.id;
+            delete node.levelSpan;
+            delete node.size;
+            delete node.startInTotal;
+            const childrenNew = node.children || node.columns;
+            if (childrenNew) {
+                clearNode(childrenNew);
+            }
+        }
+    }
+
     class SimpleHeaderLayoutMap {
         seqId = 0;
         _headerObjects;
         _headerObjectMap;
         _headerCellIds;
         _columns;
+        columnTree;
         bodyRowSpanCount = 1;
         hierarchyIndent;
         _transpose = false;
@@ -54072,6 +54798,7 @@
             this._columns = [];
             this._headerCellIds = [];
             this.hierarchyIndent = hierarchyIndent ?? 20;
+            this.columnTree = new DimensionTree(columns, { seqId: 0 });
             this._headerObjects = this._addHeaders(0, columns, []);
             this._headerObjectMap = this._headerObjects.reduce((o, e) => {
                 o[e.id] = e;
@@ -54178,7 +54905,7 @@
             }
             else {
                 row = col;
-                if (this.frozenRowCount > 0 && row >= this.rowCount - this.bottomFrozenRowCount) {
+                if (this.bottomFrozenRowCount > 0 && row >= this.rowCount - this.bottomFrozenRowCount) {
                     return true;
                 }
             }
@@ -54715,6 +55442,11 @@
             if (source.col < 0 || source.row < 0 || target.col < 0 || target.row < 0) {
                 return false;
             }
+            if (this._table.internalProps.frozenColDragHeaderMode === 'disabled') {
+                if (this._table.isFrozenColumn(target.col) || this._table.isRightFrozenColumn(target.col)) {
+                    return false;
+                }
+            }
             const sourceCellRange = this.getCellRange(source.col, source.row);
             if (this.isColumnHeader(source.col, source.row)) {
                 const sourceTopId = this.getParentCellId(source.col, sourceCellRange.start.row);
@@ -54752,6 +55484,7 @@
                     const sourceColumns = this._columns.splice(sourceCellRange.start.col, moveSize);
                     sourceColumns.unshift(targetIndex, 0);
                     Array.prototype.splice.apply(this._columns, sourceColumns);
+                    this.columnTree.movePosition(sourceCellRange.start.row, sourceCellRange.start.col, targetIndex);
                     this._cellRangeMap = new Map();
                     return {
                         sourceIndex: sourceCellRange.start.col,
@@ -54781,6 +55514,7 @@
                     const sourceColumns = this._columns.splice(sourceCellRange.start.row, moveSize);
                     sourceColumns.unshift(targetIndex, 0);
                     Array.prototype.splice.apply(this._columns, sourceColumns);
+                    this.columnTree.movePosition(sourceCellRange.start.col, sourceCellRange.start.row, targetIndex);
                     this._cellRangeMap = new Map();
                     return {
                         sourceIndex: sourceCellRange.start.row,
@@ -55035,28 +55769,52 @@
                         return;
                     }
                 }
-                editor.bindSuccessCallback?.(() => {
-                    this.completeEdit();
-                });
                 this.editingEditor = editor;
                 this.editCell = { col, row };
                 const dataValue = this.table.getCellOriginValue(col, row);
                 const rect = this.table.getCellRangeRelativeRect(this.table.getCellRange(col, row));
-                editor.beginEditing(this.table.getElement(), { rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height } }, dataValue);
+                const referencePosition = { rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height } };
+                editor.beginEditing && (void 0);
+                editor.beginEditing?.(this.table.getElement(), referencePosition, dataValue);
+                if (editor.bindSuccessCallback) ;
+                editor.bindSuccessCallback?.(() => {
+                    this.completeEdit();
+                });
+                editor.onStart?.({
+                    value: dataValue,
+                    endEdit: () => {
+                        this.completeEdit();
+                    },
+                    referencePosition,
+                    container: this.table.getElement()
+                });
             }
         }
         completeEdit(e) {
+            if (!this.editingEditor) {
+                return;
+            }
             const target = e?.target;
-            if (this.editingEditor && (!target || (target && !this.editingEditor.targetIsOnEditor(target)))) {
-                const changedValue = this.editingEditor.getValue();
-                this.table.changeCellValue(this.editCell.col, this.editCell.row, changedValue);
-                this.editingEditor.exit();
-                this.editingEditor = null;
+            if (this.editingEditor.targetIsOnEditor) {
+                if (target && this.editingEditor.targetIsOnEditor(target)) {
+                    return;
+                }
+            }
+            else if (!this.editingEditor.isEditorElement || (target && this.editingEditor.isEditorElement?.(target))) {
+                return;
             }
+            if (!this.editingEditor.getValue) ;
+            const changedValue = this.editingEditor.getValue?.();
+            this.table.changeCellValue(this.editCell.col, this.editCell.row, changedValue);
+            this.editingEditor.exit && (void 0);
+            this.editingEditor.exit?.();
+            this.editingEditor.onEnd?.();
+            this.editingEditor = null;
         }
         cancelEdit() {
             if (this.editingEditor) {
-                this.editingEditor.exit();
+                this.editingEditor.exit?.();
+                this.editingEditor.onEnd?.();
                 this.editingEditor = null;
             }
         }
@@ -55081,6 +55839,7 @@
             }
             super(container, options);
             const internalProps = this.internalProps;
+            internalProps.frozenColDragHeaderMode = options.frozenColDragHeaderMode;
             this.pagination = options.pagination;
             internalProps.sortState = options.sortState;
             internalProps.columns = options.columns
@@ -55148,7 +55907,7 @@
             this.eventManager.updateEventBinder();
         }
         get columns() {
-            return this.internalProps.columns;
+            return this.internalProps.layoutMap.columnTree.getCopiedTree();
         }
         get header() {
             return this.internalProps.columns;
@@ -55270,6 +56029,7 @@
         updateOption(options, accelerateFirstScreen = false) {
             const internalProps = this.internalProps;
             super.updateOption(options);
+            internalProps.frozenColDragHeaderMode = options.frozenColDragHeaderMode;
             this.pagination = options.pagination;
             this.showHeader = options.showHeader ?? true;
             internalProps.columns = options.columns
@@ -56183,397 +56943,6 @@
         }
     }
 
-    class DimensionTree {
-        sharedVar;
-        sizeIncludeParent = false;
-        rowExpandLevel;
-        hierarchyType;
-        tree = {
-            id: 0,
-            dimensionKey: '',
-            value: '',
-            children: [],
-            level: -1,
-            levelSpan: 1,
-            startIndex: 0,
-            size: 0,
-            startInTotal: 0,
-            hierarchyState: undefined
-        };
-        totalLevel = 0;
-        dimensionKeys = new NumberMap();
-        cache = new Map();
-        constructor(tree, sharedVar, hierarchyType = 'grid', rowExpandLevel = undefined) {
-            this.sizeIncludeParent = rowExpandLevel !== null && rowExpandLevel !== undefined;
-            this.rowExpandLevel = rowExpandLevel;
-            this.hierarchyType = hierarchyType;
-            this.sharedVar = sharedVar;
-            this.reset(tree);
-        }
-        reset(tree, updateTreeNode = false) {
-            this.cache.clear();
-            this.dimensionKeys = new NumberMap();
-            this.tree.children = tree;
-            this.setTreeNode(this.tree, 0, this.tree);
-            this.totalLevel = this.dimensionKeys.count();
-        }
-        setTreeNode(node, startIndex, parent) {
-            node.startIndex = startIndex;
-            node.startInTotal = (parent.startInTotal ?? 0) + node.startIndex;
-            if (node.dimensionKey ?? node.indicatorKey) {
-                !this.dimensionKeys.contain(node.indicatorKey ? IndicatorDimensionKeyPlaceholder : node.dimensionKey) &&
-                    this.dimensionKeys.put(node.level, node.indicatorKey ? IndicatorDimensionKeyPlaceholder : node.dimensionKey);
-                if (!node.id) {
-                    node.id = ++this.sharedVar.seqId;
-                }
-            }
-            let size = node.dimensionKey ? (this.sizeIncludeParent ? 1 : 0) : 0;
-            if (this.hierarchyType === 'grid') {
-                if (node.children?.length >= 1) {
-                    node.children.forEach(n => {
-                        n.level = (node.level ?? 0) + 1;
-                        size += this.setTreeNode(n, size, node);
-                    });
-                }
-                else {
-                    size = 1;
-                }
-            }
-            else if (node.hierarchyState === HierarchyState.expand && node.children?.length >= 1) {
-                node.children.forEach(n => {
-                    n.level = (node.level ?? 0) + 1;
-                    size += this.setTreeNode(n, size, node);
-                });
-            }
-            else if (node.hierarchyState === HierarchyState.collapse && node.children?.length >= 1) {
-                node.children.forEach(n => {
-                    n.level = (node.level ?? 0) + 1;
-                    this.setTreeNode(n, size, node);
-                });
-            }
-            else if (!node.hierarchyState && node.level + 1 < this.rowExpandLevel && node.children?.length >= 1) {
-                node.hierarchyState = HierarchyState.expand;
-                node.children.forEach(n => {
-                    n.level = (node.level ?? 0) + 1;
-                    size += this.setTreeNode(n, size, node);
-                });
-            }
-            else if (node.children?.length >= 1) {
-                node.hierarchyState = HierarchyState.collapse;
-                node.children.forEach(n => {
-                    n.level = (node.level ?? 0) + 1;
-                    this.setTreeNode(n, size, node);
-                });
-            }
-            else {
-                node.hierarchyState = HierarchyState.none;
-                size = 1;
-            }
-            node.size = size;
-            return size;
-        }
-        getTreePath(index, maxDeep = 30) {
-            const path = [];
-            this.searchPath(index, this.tree, path, maxDeep);
-            path.shift();
-            return path;
-        }
-        getTreePathByCellIds(ids) {
-            const path = [];
-            let nodes = this.tree.children;
-            for (let i = 0; i < ids.length; i++) {
-                const id = ids[i];
-                const pathNode = this.findNodeById(nodes, id);
-                if (pathNode) {
-                    path.push(pathNode);
-                    nodes = pathNode.children;
-                }
-                else {
-                    break;
-                }
-            }
-            return path;
-        }
-        findNodeById(nodes, id) {
-            return nodes.find(node => {
-                return node.id === id;
-            });
-        }
-        searchPath(index, node, path, maxDeep) {
-            if (!node) {
-                return;
-            }
-            if (index < node.startIndex || index >= node.startIndex + node.size) {
-                return;
-            }
-            path.push(node);
-            if (!node.children || node.children.length === 0 || node.level >= maxDeep) {
-                return;
-            }
-            const cIndex = index - node.startIndex;
-            if (this.cache.has(node.level + 1)) {
-                const cacheNode = this.cache.get(node.level + 1);
-                if (cIndex >= cacheNode.startIndex && cIndex < cacheNode.startIndex + cacheNode.size) {
-                    this.searchPath(cIndex, cacheNode, path, maxDeep);
-                    return;
-                }
-            }
-            let left = 0;
-            let right = node.children.length - 1;
-            while (left <= right) {
-                const middle = Math.floor((left + right) / 2);
-                const element = node.children[middle];
-                if (cIndex >= element.startIndex && cIndex < element.startIndex + element.size) {
-                    this.cache.set(element.level, element);
-                    const deleteLevels = [];
-                    this.cache.forEach((node, key) => {
-                        if (key > element.level) {
-                            deleteLevels.push(key);
-                        }
-                    });
-                    deleteLevels.forEach(key => {
-                        this.cache.delete(key);
-                    });
-                    this.searchPath(cIndex, element, path, maxDeep);
-                    break;
-                }
-                else if (cIndex < element.startIndex) {
-                    right = middle - 1;
-                }
-                else {
-                    left = middle + 1;
-                }
-            }
-            return;
-        }
-        movePosition(level, sourceIndex, targetIndex) {
-            let parNode;
-            let sourceSubIndex;
-            let targetSubIndex;
-            const findTargetNode = (node, subIndex) => {
-                if (sourceSubIndex !== undefined && targetSubIndex !== undefined) {
-                    return;
-                }
-                if (node.level === level) {
-                    if (node.startInTotal === sourceIndex) {
-                        sourceSubIndex = subIndex;
-                    }
-                    if (node.startInTotal <= targetIndex && targetIndex <= node.startInTotal + node.size - 1) {
-                        targetSubIndex = subIndex;
-                    }
-                }
-                if (node.children && node.level < level) {
-                    parNode = node;
-                    for (let i = 0; i < node.children.length; i++) {
-                        if ((sourceIndex >= node.children[i].startInTotal &&
-                            sourceIndex <= node.children[i].startInTotal + node.children[i].size) ||
-                            (targetIndex >= node.children[i].startInTotal &&
-                                targetIndex <= node.children[i].startInTotal + node.children[i].size)) {
-                            findTargetNode(node.children[i], i);
-                        }
-                    }
-                }
-            };
-            findTargetNode(this.tree, 0);
-            const sourceColumns = parNode.children.splice(sourceSubIndex, 1);
-            sourceColumns.unshift(targetSubIndex, 0);
-            Array.prototype.splice.apply(parNode.children, sourceColumns);
-        }
-    }
-    function generateLayoutTree(tree, children) {
-        children?.forEach((node) => {
-            const diemnsonNode = {
-                dimensionKey: node.dimensionKey,
-                indicatorKey: node.indicatorKey,
-                value: node.value,
-                hierarchyState: node.hierarchyState,
-                children: undefined
-            };
-            tree.push(diemnsonNode);
-            if (node.children) {
-                diemnsonNode.children = [];
-                generateLayoutTree(diemnsonNode.children, node.children);
-            }
-        });
-    }
-    function countLayoutTree(children, countParentNode) {
-        let count = 0;
-        children?.forEach((node) => {
-            if (countParentNode) {
-                count++;
-            }
-            else {
-                if (!node.children || node.children.length === 0) {
-                    count++;
-                }
-            }
-            if (node.children) {
-                count += countLayoutTree(node.children, countParentNode);
-            }
-        });
-        return count;
-    }
-    function dealHeader(hd, _headerCellIds, results, roots, row, layoutMap) {
-        const id = hd.id;
-        const dimensionInfo = layoutMap.rowsDefine?.find(dimension => typeof dimension === 'string' ? false : dimension.dimensionKey === hd.dimensionKey) ??
-            layoutMap.columnsDefine?.find(dimension => typeof dimension === 'string' ? false : dimension.dimensionKey === hd.dimensionKey);
-        const indicatorInfo = layoutMap.indicatorsDefine?.find(indicator => {
-            if (typeof indicator === 'string') {
-                return false;
-            }
-            if (hd.indicatorKey) {
-                return indicator.indicatorKey === hd.indicatorKey;
-            }
-            return indicator.title === hd.value;
-        });
-        const cell = {
-            id,
-            title: hd.value ?? indicatorInfo?.title,
-            field: hd.dimensionKey,
-            style: typeof (indicatorInfo ?? dimensionInfo)?.headerStyle === 'function'
-                ? (indicatorInfo ?? dimensionInfo)?.headerStyle
-                : Object.assign({}, (indicatorInfo ?? dimensionInfo)?.headerStyle),
-            headerType: indicatorInfo?.headerType ?? dimensionInfo?.headerType ?? 'text',
-            headerIcon: indicatorInfo?.headerIcon ?? dimensionInfo?.headerIcon,
-            define: Object.assign({}, hd, indicatorInfo ?? dimensionInfo),
-            fieldFormat: indicatorInfo?.headerFormat ?? dimensionInfo?.headerFormat,
-            dropDownMenu: indicatorInfo?.dropDownMenu ?? dimensionInfo?.dropDownMenu,
-            pivotInfo: {
-                value: hd.value,
-                dimensionKey: hd.dimensionKey,
-                isPivotCorner: false
-            },
-            width: dimensionInfo?.width,
-            minWidth: dimensionInfo?.minWidth,
-            maxWidth: dimensionInfo?.maxWidth,
-            showSort: indicatorInfo?.showSort ?? dimensionInfo?.showSort,
-            description: dimensionInfo?.description
-        };
-        if (indicatorInfo) {
-            if (indicatorInfo.customRender) {
-                hd.customRender = indicatorInfo.customRender;
-            }
-            if (!isValid$1(layoutMap._indicators?.find(indicator => indicator.indicatorKey === indicatorInfo.indicatorKey))) {
-                layoutMap._indicators?.push({
-                    id: ++layoutMap.sharedVar.seqId,
-                    indicatorKey: indicatorInfo.indicatorKey,
-                    field: indicatorInfo.indicatorKey,
-                    fieldFormat: indicatorInfo?.format,
-                    cellType: indicatorInfo?.cellType ?? indicatorInfo?.columnType ?? 'text',
-                    chartModule: 'chartModule' in indicatorInfo ? indicatorInfo.chartModule : null,
-                    chartSpec: 'chartSpec' in indicatorInfo ? indicatorInfo.chartSpec : null,
-                    sparklineSpec: 'sparklineSpec' in indicatorInfo ? indicatorInfo.sparklineSpec : null,
-                    style: indicatorInfo?.style,
-                    icon: indicatorInfo?.icon,
-                    define: Object.assign({}, hd, indicatorInfo, {
-                        dragHeader: dimensionInfo?.dragHeader
-                    }),
-                    width: indicatorInfo?.width,
-                    minWidth: indicatorInfo?.minWidth,
-                    maxWidth: indicatorInfo?.maxWidth,
-                    disableColumnResize: indicatorInfo?.disableColumnResize
-                });
-            }
-        }
-        else if (hd.indicatorKey) {
-            if (!isValid$1(layoutMap._indicators?.find(indicator => indicator.indicatorKey === hd.indicatorKey))) {
-                layoutMap._indicators?.push({
-                    id: ++layoutMap.sharedVar.seqId,
-                    indicatorKey: hd.indicatorKey,
-                    field: hd.indicatorKey,
-                    cellType: 'text',
-                    define: Object.assign({}, hd)
-                });
-            }
-        }
-        results[id] = cell;
-        layoutMap._headerObjects[id] = cell;
-        _headerCellIds[row][layoutMap.colIndex] = id;
-        for (let r = row - 1; r >= 0; r--) {
-            _headerCellIds[r][layoutMap.colIndex] = roots[r];
-        }
-        if (hd.levelSpan > 1) {
-            for (let i = 1; i < hd.levelSpan; i++) {
-                if (!_headerCellIds[row + i]) {
-                    _headerCellIds[row + i] = [];
-                }
-                _headerCellIds[row + i][layoutMap.colIndex] = id;
-            }
-        }
-        if (hd.children?.length >= 1) {
-            layoutMap
-                ._addHeaders(_headerCellIds, row + (hd.levelSpan ?? 1), hd.children ?? [], [
-                ...roots,
-                ...Array(hd.levelSpan ?? 1).fill(id)
-            ])
-                .forEach(c => results.push(c));
-        }
-        else {
-            for (let r = row + 1; r < _headerCellIds.length; r++) {
-                _headerCellIds[r][layoutMap.colIndex] = id;
-            }
-            layoutMap.colIndex++;
-        }
-    }
-    function dealHeaderForTreeMode(hd, _headerCellIds, results, roots, row, totalLevel, show, dimensions, layoutMap) {
-        const id = hd.id;
-        const dimensionInfo = dimensions.find(dimension => typeof dimension === 'string' ? false : dimension.dimensionKey === hd.dimensionKey);
-        const cell = {
-            id,
-            title: hd.value,
-            field: hd.dimensionKey,
-            style: hd.level + 1 === totalLevel || typeof dimensionInfo?.headerStyle === 'function'
-                ? dimensionInfo?.headerStyle
-                : Object.assign({}, dimensionInfo?.headerStyle, { textAlign: 'left' }),
-            headerType: dimensionInfo?.headerType ?? 'text',
-            headerIcon: dimensionInfo?.headerIcon,
-            define: Object.assign(hd, {
-                linkJump: dimensionInfo?.linkJump,
-                linkDetect: dimensionInfo?.linkDetect,
-                templateLink: dimensionInfo?.templateLink,
-                keepAspectRatio: dimensionInfo?.keepAspectRatio ?? false,
-                imageAutoSizing: dimensionInfo?.imageAutoSizing,
-                headerCustomRender: dimensionInfo?.headerCustomRender,
-                headerCustomLayout: dimensionInfo?.headerCustomLayout,
-                dragHeader: dimensionInfo?.dragHeader,
-                disableHeaderHover: !!dimensionInfo?.disableHeaderHover,
-                disableHeaderSelect: !!dimensionInfo?.disableHeaderSelect
-            }),
-            fieldFormat: dimensionInfo?.headerFormat,
-            dropDownMenu: dimensionInfo?.dropDownMenu,
-            pivotInfo: {
-                value: hd.value,
-                dimensionKey: hd.dimensionKey,
-                isPivotCorner: false
-            },
-            hierarchyLevel: hd.level,
-            dimensionTotalLevel: totalLevel,
-            hierarchyState: hd.level + 1 === totalLevel ? undefined : hd.hierarchyState,
-            width: dimensionInfo?.width,
-            minWidth: dimensionInfo?.minWidth,
-            maxWidth: dimensionInfo?.maxWidth,
-            parentCellId: roots[roots.length - 1]
-        };
-        results[id] = cell;
-        layoutMap._headerObjects[id] = cell;
-        _headerCellIds[row][layoutMap.colIndex] = id;
-        for (let r = row - 1; r >= 0; r--) {
-            _headerCellIds[r][layoutMap.colIndex] = roots[r];
-        }
-        if (hd.hierarchyState === HierarchyState.expand && hd.children?.length >= 1) {
-            show && layoutMap.colIndex++;
-            layoutMap
-                ._addHeadersForTreeMode(_headerCellIds, row, hd.children ?? [], [...roots, id], totalLevel, show && hd.hierarchyState === HierarchyState.expand, dimensions)
-                .forEach(c => results.push(c));
-        }
-        else {
-            show && layoutMap.colIndex++;
-            for (let r = row + 1; r < _headerCellIds.length; r++) {
-                _headerCellIds[r][layoutMap.colIndex] = id;
-            }
-        }
-    }
-
     const defaultDimension = { startInTotal: 0, level: 0 };
     class PivotHeaderLayoutMap {
         sharedVar;
@@ -57563,6 +57932,44 @@
             if (this.isRightFrozenColumn(col, row) || this.isBottomFrozenRow(col, row)) {
                 return result;
             }
+            if (this._table.isPivotChart()) {
+                if (this.isLeftBottomCorner(col, row)) {
+                    return {
+                        start: {
+                            col: 0,
+                            row: this.rowCount - this.bottomFrozenRowCount
+                        },
+                        end: {
+                            col: this.frozenColCount - 1,
+                            row: this.rowCount - 1
+                        }
+                    };
+                }
+                else if (this.isRightTopCorner(col, row)) {
+                    return {
+                        start: {
+                            col: this.colCount - this.rightFrozenColCount,
+                            row: 0
+                        },
+                        end: {
+                            col: this.colCount - 1,
+                            row: this.frozenRowCount - 1
+                        }
+                    };
+                }
+                else if (this.isRightBottomCorner(col, row)) {
+                    return {
+                        start: {
+                            col: this.colCount - this.rightFrozenColCount,
+                            row: this.rowCount - this.bottomFrozenRowCount
+                        },
+                        end: {
+                            col: this.colCount - 1,
+                            row: this.rowCount - 1
+                        }
+                    };
+                }
+            }
             for (let i = 0; i < this._largeCellRangeCache.length; i++) {
                 const range = this._largeCellRangeCache[i];
                 if (col >= range.start.col && col <= range.end.col && row >= range.start.row && row <= range.end.row) {
@@ -58047,7 +58454,7 @@
                     const sourceColumns = this._columnWidths.splice(sourceCellRange.start.col, moveSize);
                     sourceColumns.unshift(targetIndex, 0);
                     Array.prototype.splice.apply(this._columnWidths, sourceColumns);
-                    this.columnDimensionTree.movePosition(source.row, sourceCellRange.start.col - this.rowHeaderLevelCount, targetIndex - this.rowHeaderLevelCount);
+                    this.columnDimensionTree.movePosition(this.getCellHeaderPathsWidthTreeNode(source.col, source.row).colHeaderPaths.length - 1, sourceCellRange.start.col - this.rowHeaderLevelCount, targetIndex - this.rowHeaderLevelCount);
                     this.columnDimensionTree.reset(this.columnDimensionTree.tree.children, true);
                     this._CellHeaderPathMap = new Map();
                     this._largeCellRangeCache.length = 0;
@@ -62580,7 +62987,7 @@
     }
 
     registerForVrender();
-    const version = "0.18.5-alpha.0";
+    const version = "0.19.0";
     function getIcons() {
         return get$1();
     }