@visactor/vtable 1.26.7 → 1.26.8

package/dist/vtable.js

@@ -42406,6 +42406,7 @@
 	class CustomAggregator extends Aggregator {
 	    type = AggregationType.CUSTOM;
 	    isRecord = true;
+	    recalculateFromChildren;
 	    aggregationFun;
 	    values = [];
 	    fieldValue;
@@ -42415,6 +42416,19 @@
 	    }
 	    push(record) {
 	        if (record) {
+	            if (this.recalculateFromChildren && record.isAggregator) {
+	                if (this.isRecord && this.records) {
+	                    this.records.push(...record.records);
+	                }
+	                if (this.children) {
+	                    this.children.push(record);
+	                }
+	                if (this.field) {
+	                    this.values.push(...record.records.map((item) => item[this.field]));
+	                }
+	                this.clearCacheValue();
+	                return;
+	            }
 	            if (this.isRecord && this.records) {
 	                if (record.isAggregator) {
 	                    this.records.push(...record.records);
@@ -42483,6 +42497,26 @@
 	        this.fieldValue = undefined;
 	    }
 	    recalculate() {
+	        if (this.recalculateFromChildren && this.children?.length && this.field) {
+	            this.values = [];
+	            this.records = [];
+	            this.children.forEach(child => {
+	                if (isValid$1(child.changedValue)) {
+	                    const value = child.value();
+	                    this.values.push(value);
+	                    this.records.push({ [this.field]: value });
+	                }
+	                else if (child instanceof CustomAggregator && child.recalculateFromChildren) {
+	                    this.values.push(...child.values);
+	                    this.records.push(...child.records);
+	                }
+	                else {
+	                    const records = child.records;
+	                    this.values.push(...records.map(record => record[this.field]));
+	                    this.records.push(...records);
+	                }
+	            });
+	        }
 	        this.fieldValue = undefined;
 	        this._formatedValue = undefined;
 	    }
@@ -44430,8 +44464,8 @@
 	function isZeroStyle(style) {
 	    return style === 0 || (isArray$5(style) && style.every(s => s === 0));
 	}
-	function setActiveCellRangeState(table) {
-	    const selectRanges = table.stateManager.select.ranges;
+	function setActiveCellRangeState(table, ranges = table.stateManager.select.ranges) {
+	    const selectRanges = ranges;
 	    const setRanges = [];
 	    for (let i = 0; i < selectRanges.length; i++) {
 	        const range = selectRanges[i];
@@ -44652,17 +44686,6 @@
 	    }
 	    return v1 === v2 ? 0 : v1 < v2 ? 1 : -1;
 	}
-	function getValueByPath(obj, paths) {
-	    let res = obj;
-	    let prop;
-	    while ((prop = paths.shift())) {
-	        res = res[prop];
-	        if (!res) {
-	            break;
-	        }
-	    }
-	    return res;
-	}
 	function isAllDigits(str) {
 	    const pattern = /^-?\d+(\.\d+)?$/;
 	    return pattern.test(str);
@@ -46939,7 +46962,7 @@
 	const DARK = new TableTheme(darkTheme, darkTheme);
 	const BRIGHT = new TableTheme(brightTheme, brightTheme);
 	const ARCO = new TableTheme(arcoTheme, arcoTheme);
-	const DEFAULT = new TableTheme(defaultTheme, defaultTheme);
+	let DEFAULT = new TableTheme(defaultTheme, defaultTheme);
 	const SIMPLIFY = new TableTheme(materialDesignTheme, materialDesignTheme);
 	const builtin$1 = {
 	    DEFAULT,
@@ -46948,6 +46971,10 @@
 	    DARK,
 	    BRIGHT
 	};
+	function setDefaultTheme(theme) {
+	    DEFAULT = theme instanceof TableTheme ? theme.extends({}) : new TableTheme(theme, theme);
+	    builtin$1.DEFAULT = DEFAULT;
+	}
 	const theme$1 = { TableTheme };
 	function of$1(value) {
 	    if (!value) {
@@ -46975,11 +47002,14 @@
 	    DARK,
 	    BRIGHT,
 	    ARCO,
-	    DEFAULT,
+	    get DEFAULT() {
+	        return DEFAULT;
+	    },
 	    SIMPLIFY,
 	    theme: theme$1,
 	    of: of$1,
-	    get: get$5
+	    get: get$5,
+	    setDefaultTheme
 	};
 
 	var themes$1 = /*#__PURE__*/Object.freeze({
@@ -46987,12 +47017,13 @@
 		ARCO: ARCO,
 		BRIGHT: BRIGHT,
 		DARK: DARK,
-		DEFAULT: DEFAULT,
+		get DEFAULT () { return DEFAULT; },
 		SIMPLIFY: SIMPLIFY,
 		TableTheme: TableTheme,
 		default: themes,
 		get: get$5,
 		of: of$1,
+		setDefaultTheme: setDefaultTheme,
 		tableThemeIsChanged: tableThemeIsChanged,
 		theme: theme$1
 	});
@@ -51967,7 +51998,11 @@
 	        const colIndex = col - table.leftRowSeriesNumberCount;
 	        return record[colIndex];
 	    }
-	    if (isObject$7(record) && fieldGet in record) {
+	    if (Array.isArray(fieldGet)) {
+	        const fieldResult = getRecordFieldValue(record, fieldGet);
+	        return getValue$2(fieldResult, promiseCallBack);
+	    }
+	    if (isRecordContainer(record) && fieldGet in record) {
 	        const fieldResult = record[fieldGet];
 	        return getValue$2(fieldResult, promiseCallBack);
 	    }
@@ -51975,10 +52010,6 @@
 	        const fieldResult = fieldGet(record, col, row, table);
 	        return getValue$2(fieldResult, promiseCallBack);
 	    }
-	    if (Array.isArray(fieldGet)) {
-	        const fieldResult = getValueByPath(record, [...fieldGet]);
-	        return getValue$2(fieldResult, promiseCallBack);
-	    }
 	    const fieldArray = `${fieldGet}`.split('.');
 	    if (fieldArray.length <= 1) {
 	        const fieldResult = record[fieldGet];
@@ -51987,6 +52018,87 @@
 	    const fieldResult = applyChainSafe(record, (val, name) => getField(val, name, col, row, table, emptyFn), ...fieldArray);
 	    return getValue$2(fieldResult, promiseCallBack);
 	}
+	function isRecordContainer(value) {
+	    return value !== null && typeof value === 'object';
+	}
+	function getRecordFieldPath(field) {
+	    if (Array.isArray(field)) {
+	        return field;
+	    }
+	    if (typeof field === 'string' && field.includes('.')) {
+	        return field.split('.');
+	    }
+	    return undefined;
+	}
+	function hasRecordField(record, field) {
+	    if (!isRecordContainer(record)) {
+	        return false;
+	    }
+	    const path = getRecordFieldPath(field);
+	    if (!Array.isArray(field) && field in record) {
+	        return true;
+	    }
+	    if (!path) {
+	        return false;
+	    }
+	    let target = record;
+	    for (const key of path) {
+	        if (!isRecordContainer(target) || !(key in target)) {
+	            return false;
+	        }
+	        target = target[key];
+	    }
+	    return true;
+	}
+	function getRecordFieldValue(record, field) {
+	    if (record === null || record === undefined) {
+	        return undefined;
+	    }
+	    const path = getRecordFieldPath(field);
+	    if (!Array.isArray(field) && isRecordContainer(record) && field in record) {
+	        return record[field];
+	    }
+	    if (!path) {
+	        return record[field];
+	    }
+	    return path.reduce((current, key) => {
+	        return current === null || current === undefined ? undefined : current[key];
+	    }, record);
+	}
+	function setRecordProperty(record, key, value) {
+	    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+	        Object.defineProperty(record, key, {
+	            configurable: true,
+	            enumerable: true,
+	            value,
+	            writable: true
+	        });
+	        return;
+	    }
+	    record[key] = value;
+	}
+	function setRecordFieldValue(record, field, value) {
+	    if (record === null || record === undefined) {
+	        return;
+	    }
+	    const path = getRecordFieldPath(field);
+	    if (!path || (!Array.isArray(field) && isRecordContainer(record) && field in record)) {
+	        setRecordProperty(record, field, value);
+	        return;
+	    }
+	    if (path.length === 0) {
+	        return;
+	    }
+	    let target = record;
+	    for (let i = 0; i < path.length - 1; i++) {
+	        const key = path[i];
+	        if (!Object.prototype.hasOwnProperty.call(target, key) || target[key] === null || typeof target[key] !== 'object') {
+	            setRecordProperty(target, key, {});
+	        }
+	        target = target[key];
+	    }
+	    setRecordProperty(target, path[path.length - 1], value);
+	}
 	function _getIndex(sortedIndexMap, index) {
 	    if (!sortedIndexMap) {
 	        return index;
@@ -52401,29 +52513,29 @@
 	            if (field === undefined || field === '') {
 	                field = col - table.leftRowSeriesNumberCount;
 	            }
-	            if (typeof field === 'string' || typeof field === 'number') {
-	                const beforeChangedValue = this.beforeChangedRecordsMap.get(dataIndex.toString())?.[field];
+	            if (typeof field === 'string' || typeof field === 'number' || Array.isArray(field)) {
+	                const beforeChangedValue = getRecordFieldValue(this.beforeChangedRecordsMap.get(dataIndex.toString()), field);
 	                const record = this.getOriginalRecord(dataIndex);
 	                let formatValue = value;
 	                if (typeof beforeChangedValue === 'number' && isAllDigits(value)) {
 	                    formatValue = parseFloat(value);
 	                }
 	                if (isPromise(record)) {
-	                    record
+	                    return record
 	                        .then(record => {
-	                        record[field] = formatValue;
+	                        setRecordFieldValue(record, field, formatValue);
+	                        return formatValue;
 	                    })
 	                        .catch((err) => {
+	                        return undefined;
 	                    });
 	                }
+	                if (record) {
+	                    setRecordFieldValue(record, field, formatValue);
+	                }
 	                else {
-	                    if (record) {
-	                        record[field] = formatValue;
-	                    }
-	                    else {
-	                        this.records[dataIndex] = this.addRecordRule === 'Array' ? [] : {};
-	                        this.records[dataIndex][field] = formatValue;
-	                    }
+	                    this.records[dataIndex] = this.addRecordRule === 'Array' ? [] : {};
+	                    setRecordFieldValue(this.records[dataIndex], field, formatValue);
 	                }
 	            }
 	        }
@@ -52447,8 +52559,8 @@
 	                : undefined;
 	            this.beforeChangedRecordsMap.set(rawKey, cloneDeep(originRecord, undefined, ['vtable_gantt_linkedFrom', 'vtable_gantt_linkedTo']) ?? {});
 	        }
-	        if (typeof field === 'string' || typeof field === 'number') {
-	            const beforeChangedValue = this.beforeChangedRecordsMap.get(rawKey)?.[field];
+	        if (typeof field === 'string' || typeof field === 'number' || Array.isArray(field)) {
+	            const beforeChangedValue = getRecordFieldValue(this.beforeChangedRecordsMap.get(rawKey), field);
 	            const rawRecords = Array.isArray(this.dataSourceObj?.records)
 	                ? this.dataSourceObj.records
 	                : null;
@@ -52462,11 +52574,11 @@
 	                formatValue = parseFloat(value);
 	            }
 	            if (record) {
-	                record[field] = formatValue;
+	                setRecordFieldValue(record, field, formatValue);
 	            }
 	            else if (rawRecords && typeof recordIndex === 'number') {
 	                rawRecords[recordIndex] = this.addRecordRule === 'Array' ? [] : {};
-	                rawRecords[recordIndex][field] = formatValue;
+	                setRecordFieldValue(rawRecords[recordIndex], field, formatValue);
 	            }
 	        }
 	    }
@@ -53155,7 +53267,7 @@
 	            return true;
 	        }
 	        const record = this.getOriginalRecord(index);
-	        return Boolean(record && field in record);
+	        return hasRecordField(record, field);
 	    }
 	    fieldPromiseCallBack(_index, _field, _value) {
 	    }
@@ -56345,7 +56457,7 @@
 	        }
 	        cells.forEach(function (cell, cellIndex) {
 	            const parsedCellData = !cell
-	                ? ' '
+	                ? ''
 	                : cell
 	                    .toString()
 	                    .replace(/&/g, '&amp;')
@@ -58632,6 +58744,70 @@
 	    }
 	}
 
+	function isCornerCustomMergeRange(range, table) {
+	    return (!!range?.isCustom &&
+	        (range.start.col !== range.end.col || range.start.row !== range.end.row) &&
+	        table.isCornerHeader(range.start.col, range.start.row) &&
+	        table.isCornerHeader(range.end.col, range.end.row));
+	}
+	function shouldRenderCornerCustomMergeContent(col, row, range, table) {
+	    return !isCornerCustomMergeRange(range, table) || (col === range.end.col && row === range.end.row);
+	}
+	function createCornerCustomMergeContainer(customElementsGroup, width, height, range, table) {
+	    if (!customElementsGroup || !isCornerCustomMergeRange(range, table)) {
+	        return customElementsGroup;
+	    }
+	    const customContainer = new Group$1({
+	        x: 0,
+	        y: 0,
+	        width,
+	        height,
+	        fill: false,
+	        stroke: false,
+	        pickable: false,
+	        clip: true
+	    });
+	    customContainer.name = CUSTOM_CONTAINER_NAME;
+	    customContainer.col = range.start.col;
+	    customContainer.row = range.start.row;
+	    customContainer.appendChild(customElementsGroup);
+	    return customContainer;
+	}
+	function queueCornerCustomMergeContentUpdate(range, table, pendingRanges) {
+	    if (!pendingRanges) {
+	        refreshCornerCustomMergeContent(range, table);
+	        return;
+	    }
+	    pendingRanges.set(getCornerCustomMergeRangeKey(range), range);
+	}
+	function flushCornerCustomMergeContentUpdates(pendingRanges, table) {
+	    pendingRanges.forEach(range => {
+	        refreshCornerCustomMergeContentForResize(range, table);
+	    });
+	    pendingRanges.clear();
+	}
+	function getCornerCustomMergeRangeKey(range) {
+	    return `${range.start.col}-${range.start.row}-${range.end.col}-${range.end.row}`;
+	}
+	function refreshCornerCustomMergeContent(range, table) {
+	    const cellGroup = table.scenegraph.getCell(range.end.col, range.end.row);
+	    const customContainer = cellGroup.getChildByName(CUSTOM_CONTAINER_NAME) || cellGroup.getChildByName(CUSTOM_MERGE_CONTAINER_NAME);
+	    if (customContainer) {
+	        table.reactCustomLayout?.removeCustomCell(range.start.col, range.start.row);
+	        customContainer.removeAllChild();
+	        cellGroup.removeChild(customContainer);
+	    }
+	    table.scenegraph.updateCellContent(range.end.col, range.end.row);
+	}
+	function refreshCornerCustomMergeContentForResize(range, table) {
+	    const cellGroup = table.scenegraph.getCell(range.end.col, range.end.row);
+	    const customContainer = cellGroup.getChildByName(CUSTOM_CONTAINER_NAME) || cellGroup.getChildByName(CUSTOM_MERGE_CONTAINER_NAME);
+	    if (customContainer) {
+	        cellGroup.removeChild(customContainer);
+	    }
+	    table.scenegraph.updateCellContent(range.end.col, range.end.row);
+	}
+
 	const PROMISE_CELL_UPDATE_TOKEN_KEY = '__vtable_promise_cell_update_token__';
 	function nextPromiseCellUpdateToken(cellGroup) {
 	    const token = (cellGroup[PROMISE_CELL_UPDATE_TOKEN_KEY] ?? 0) + 1;
@@ -58788,8 +58964,15 @@
 	function _generateCustomElementsGroup(table, define, col, row, cellWidth, cellHeight, padding, range, customResult) {
 	    let customElementsGroup;
 	    let renderDefault = true;
+	    const shouldRenderContent = shouldRenderCornerCustomMergeContent(col, row, range, table);
+	    if (!shouldRenderContent) {
+	        return {
+	            customElementsGroup,
+	            renderDefault: false
+	        };
+	    }
 	    if (customResult) {
-	        customElementsGroup = customResult.elementsGroup;
+	        customElementsGroup = createCornerCustomMergeContainer(customResult.elementsGroup, cellWidth, cellHeight, range, table);
 	        renderDefault = customResult.renderDefault;
 	    }
 	    else if (range?.isCustom && !table.isCornerHeader(col, row)) ;
@@ -58806,8 +58989,10 @@
 	            customLayout = define?.customLayout;
 	        }
 	        if (customLayout || customRender) {
-	            const customResult = dealWithCustom(customLayout, customRender, col, row, cellWidth, cellHeight, false, table.isAutoRowHeight(row), padding, range, table);
-	            customElementsGroup = customResult.elementsGroup;
+	            const customCol = range && isCornerCustomMergeRange(range, table) ? range.start.col : col;
+	            const customRow = range && isCornerCustomMergeRange(range, table) ? range.start.row : row;
+	            const customResult = dealWithCustom(customLayout, customRender, customCol, customRow, cellWidth, cellHeight, false, table.isAutoRowHeight(row), padding, range, table);
+	            customElementsGroup = createCornerCustomMergeContainer(customResult.elementsGroup, cellWidth, cellHeight, range, table);
 	            renderDefault = customResult.renderDefault;
 	        }
 	    }
@@ -58836,7 +59021,7 @@
 	            isMerge = range.start.col !== range.end.col || range.start.row !== range.end.row;
 	            value = customMergeText;
 	            customStyle = customMergeStyle;
-	            if (customLayout || customRender) {
+	            if ((customLayout || customRender) && shouldRenderCornerCustomMergeContent(col, row, customMergeRange, table)) {
 	                customResult = dealWithCustom(customLayout, customRender, customMergeRange.start.col, customMergeRange.start.row, table.getColsWidth(customMergeRange.start.col, customMergeRange.end.col), table.getRowsHeight(customMergeRange.start.row, customMergeRange.end.row), false, table.isAutoRowHeight(row), [0, 0, 0, 0], range, table);
 	            }
 	            isCustomMerge = true;
@@ -59228,21 +59413,33 @@
 	        if (customMerge) {
 	            const { range: customMergeRange, text: customMergeText, style: customMergeStyle, customLayout: customMergeLayout, customRender: customMergeRender } = customMerge;
 	            if (customMergeLayout || customMergeRender) {
+	                const rangeHeight = table.getRowHeight(row);
+	                const rangeWidth = table.getColWidth(col);
+	                const contentWidth = table.getColsWidth(customMergeRange.start.col, customMergeRange.end.col);
+	                const contentHeight = table.getRowsHeight(customMergeRange.start.row, customMergeRange.end.row);
+	                cellGroup.contentWidth = contentWidth;
+	                cellGroup.contentHeight = contentHeight;
+	                if (!shouldRenderCornerCustomMergeContent(col, row, customMergeRange, table)) {
+	                    const customContainer = cellGroup.getChildByName(CUSTOM_CONTAINER_NAME);
+	                    if (customContainer) {
+	                        cellGroup.removeChild(customContainer);
+	                    }
+	                    cellGroup.setAttribute('clip', true);
+	                    resizeCellGroup(cellGroup, rangeWidth, rangeHeight, customMergeRange, table);
+	                    return customMergeRange;
+	                }
 	                const customResult = dealWithCustom(customMergeLayout, customMergeRender, customMergeRange.start.col, customMergeRange.start.row, table.getColsWidth(customMergeRange.start.col, customMergeRange.end.col), table.getRowsHeight(customMergeRange.start.row, customMergeRange.end.row), false, table.isAutoRowHeight(row), [0, 0, 0, 0], customMergeRange, table);
-	                const customElementsGroup = customResult.elementsGroup;
+	                const customElementsGroup = createCornerCustomMergeContainer(customResult.elementsGroup, contentWidth, contentHeight, customMergeRange, table);
 	                if (cellGroup.childrenCount > 0 && customElementsGroup) {
 	                    cellGroup.insertBefore(customElementsGroup, cellGroup.firstChild);
 	                }
 	                else if (customElementsGroup) {
 	                    cellGroup.appendChild(customElementsGroup);
 	                }
-	                const rangeHeight = table.getRowHeight(row);
-	                const rangeWidth = table.getColWidth(col);
-	                const { width: contentWidth } = cellGroup.attribute;
-	                const { height: contentHeight } = cellGroup.attribute;
-	                cellGroup.contentWidth = contentWidth;
-	                cellGroup.contentHeight = contentHeight;
 	                resizeCellGroup(cellGroup, rangeWidth, rangeHeight, customMergeRange, table);
+	                if (isCornerCustomMergeRange(customMergeRange, table)) {
+	                    cellGroup.setAttribute('clip', false);
+	                }
 	                return customMergeRange;
 	            }
 	        }
@@ -59476,8 +59673,13 @@
 	                !table.options.customComputeRowHeight &&
 	                !table.options.rowHeightConfig &&
 	                checkFixedStyleAndNoWrap(table, rowStart)) {
-	                const height = computeRowHeight(table.columnHeaderLevelCount, 0, table.colCount - 1, table);
-	                fillRowsHeight(height, table.columnHeaderLevelCount, table.rowCount - 1 - table.bottomFrozenRowCount, table, update ? newHeights : undefined);
+	                const fillStartRow = table.columnHeaderLevelCount;
+	                const fillEndRow = table.rowCount - 1 - table.bottomFrozenRowCount;
+	                const rowForCompute = getFirstUnresizedRow(table, fillStartRow, fillEndRow);
+	                if (rowForCompute >= 0) {
+	                    const height = computeRowHeight(rowForCompute, 0, table.colCount - 1, table);
+	                    fillRowsHeight(height, fillStartRow, fillEndRow, table, update ? newHeights : undefined);
+	                }
 	                for (let row = table.rowCount - table.bottomFrozenRowCount; row <= rowEnd; row++) {
 	                    const height = computeRowHeight(row, 0, table.colCount - 1, table);
 	                    if (update) {
@@ -59651,6 +59853,9 @@
 	    }
 	}
 	function computeRowHeight(row, startCol, endCol, table) {
+	    if (table.internalProps._heightResizedRowMap.has(row)) {
+	        return table.getRowHeight(row);
+	    }
 	    return computeRowHeightInternal(row, startCol, endCol, table, true);
 	}
 	function computeRowHeightInternal(row, startCol, endCol, table, enableCustomCompute) {
@@ -59836,6 +60041,9 @@
 	        return;
 	    }
 	    for (let row = startRow; row <= endRow; row++) {
+	        if (table.internalProps._heightResizedRowMap.has(row)) {
+	            continue;
+	        }
 	        if (newHeights) {
 	            newHeights[row] = height;
 	        }
@@ -59845,6 +60053,14 @@
 	    }
 	    table.internalProps.useOneRowHeightFillAll = true;
 	}
+	function getFirstUnresizedRow(table, startRow, endRow) {
+	    for (let row = startRow; row <= endRow; row++) {
+	        if (!table.internalProps._heightResizedRowMap.has(row)) {
+	            return row;
+	        }
+	    }
+	    return -1;
+	}
 	function computeCustomRenderHeight(col, row, table) {
 	    const customRender = table.getCustomRender(col, row);
 	    let customLayout = table.getCustomLayout(col, row);
@@ -60088,7 +60304,9 @@
 	    };
 	}
 
-	function updateRowHeight(scene, row, detaY, skipTableHeightMap) {
+	function updateRowHeight(scene, row, detaY, skipTableHeightMap, pendingCornerCustomMergeRanges) {
+	    const shouldFlushCornerCustomMergeRanges = !pendingCornerCustomMergeRanges;
+	    pendingCornerCustomMergeRanges ??= new Map();
 	    if (!skipTableHeightMap && detaY) {
 	        scene.table._setRowHeight(row, scene.table.getRowHeight(row) + detaY, true);
 	    }
@@ -60102,7 +60320,7 @@
 	            continue;
 	        }
 	        const height = cell.attribute.height;
-	        updateCellHeightForRow(scene, cell, col, row, height + detaY, detaY, scene.table.isHeader(col, row));
+	        updateCellHeightForRow(scene, cell, col, row, height + detaY, detaY, scene.table.isHeader(col, row), pendingCornerCustomMergeRanges);
 	        scene.updateCellContentWhileResize(col, row);
 	    }
 	    let rowStart = 0;
@@ -60127,16 +60345,19 @@
 	            }
 	        }
 	    }
+	    if (shouldFlushCornerCustomMergeRanges) {
+	        flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, scene.table);
+	    }
 	}
-	function updateCellHeightForRow(scene, cell, col, row, height, detaY, isHeader) {
+	function updateCellHeightForRow(scene, cell, col, row, height, detaY, isHeader, pendingCornerCustomMergeRanges) {
 	    const cellGroup = cell;
 	    const distHeight = height;
 	    if (!cellGroup) {
 	        return;
 	    }
-	    updateCellHeight(scene, cellGroup, col, row, distHeight, detaY);
+	    updateCellHeight(scene, cellGroup, col, row, distHeight, detaY, isHeader, pendingCornerCustomMergeRanges);
 	}
-	function updateCellHeight(scene, cell, col, row, distHeight, detaY, isHeader) {
+	function updateCellHeight(scene, cell, col, row, distHeight, detaY, isHeader, pendingCornerCustomMergeRanges) {
 	    if (cell.attribute.height === distHeight && !cell.needUpdateHeight) {
 	        return;
 	    }
@@ -60162,7 +60383,7 @@
 	        cell.removeChild(oldBarCell);
 	        oldBarCell.removeAllChild();
 	        oldBarCell.release();
-	        updateMergeCellContentHeight(cell, distHeight, detaY, scene.table.isAutoRowHeight(row), true, scene.table);
+	        updateMergeCellContentHeight(cell, distHeight, detaY, scene.table.isAutoRowHeight(row), true, scene.table, true, pendingCornerCustomMergeRanges);
 	    }
 	    else if (type === 'sparkline') {
 	        cell.removeAllChild();
@@ -60182,6 +60403,15 @@
 	        const customContainer = cell.getChildByName(CUSTOM_CONTAINER_NAME) ||
 	            cell.getChildByName(CUSTOM_MERGE_CONTAINER_NAME);
 	        if (customContainer) {
+	            if (scene.table.reactCustomLayout) {
+	                const mergeRange = isMergeCellGroup(cell)
+	                    ? scene.table.getCellRange(cell.mergeStartCol, cell.mergeStartRow)
+	                    : undefined;
+	                const shouldUseMergeStart = mergeRange && isCornerCustomMergeRange(mergeRange, scene.table);
+	                const removeCol = shouldUseMergeStart ? mergeRange.start.col : col;
+	                const removeRow = shouldUseMergeStart ? mergeRange.start.row : row;
+	                scene.table.reactCustomLayout.removeCustomCell(removeCol, removeRow);
+	            }
 	            let customElementsGroup;
 	            cell.removeChild(customContainer);
 	            const customMergeRange = getCustomCellMergeCustom(col, row, cell, scene.table);
@@ -60193,8 +60423,10 @@
 	                    const mergedCell = scene.getCell(col, mergeRow);
 	                    const customContainer = mergedCell.getChildByName(CUSTOM_CONTAINER_NAME) ||
 	                        mergedCell.getChildByName(CUSTOM_MERGE_CONTAINER_NAME);
-	                    customContainer.removeAllChild();
-	                    mergedCell.removeChild(customContainer);
+	                    if (customContainer) {
+	                        customContainer.removeAllChild();
+	                        mergedCell.removeChild(customContainer);
+	                    }
 	                    getCustomCellMergeCustom(col, mergeRow, mergedCell, scene.table);
 	                }
 	            }
@@ -60225,7 +60457,14 @@
 	                        }
 	                    }
 	                }
-	                if (customLayout || customRender) {
+	                const mergeRange = isMergeCellGroup(cell)
+	                    ? scene.table.getCellRange(cell.mergeStartCol, cell.mergeStartRow)
+	                    : undefined;
+	                const shouldRenderContent = shouldRenderCornerCustomMergeContent(col, row, mergeRange, scene.table);
+	                if (!shouldRenderContent) {
+	                    renderDefault = false;
+	                }
+	                else if (customLayout || customRender) {
 	                    const style = scene.table._getCellStyle(col, row);
 	                    const padding = getQuadProps(getProp('padding', style, col, row, scene.table));
 	                    let width = cell.attribute.width;
@@ -60234,13 +60473,14 @@
 	                        width = scene.table.getColsWidth(cell.mergeStartCol, cell.mergeEndCol);
 	                        height = scene.table.getRowsHeight(cell.mergeStartRow, cell.mergeEndRow);
 	                    }
-	                    const customResult = dealWithCustom(customLayout, customRender, col, row, width, height, false, scene.table.isAutoRowHeight(row), padding, isMergeCellGroup(cell)
-	                        ? {
-	                            start: { col: cell.mergeStartCol, row: cell.mergeStartRow },
-	                            end: { col: cell.mergeEndCol, row: cell.mergeEndRow }
-	                        }
-	                        : undefined, scene.table);
-	                    customElementsGroup = customResult.elementsGroup;
+	                    let customCol = col;
+	                    let customRow = row;
+	                    if (mergeRange && isCornerCustomMergeRange(mergeRange, scene.table)) {
+	                        customCol = mergeRange.start.col;
+	                        customRow = mergeRange.start.row;
+	                    }
+	                    const customResult = dealWithCustom(customLayout, customRender, customCol, customRow, width, height, false, scene.table.isAutoRowHeight(row), padding, mergeRange, scene.table);
+	                    customElementsGroup = createCornerCustomMergeContainer(customResult.elementsGroup, width, height, mergeRange, scene.table);
 	                    renderDefault = customResult.renderDefault;
 	                }
 	                if (cell.childrenCount > 0 && customElementsGroup) {
@@ -60249,12 +60489,18 @@
 	                else if (customElementsGroup) {
 	                    cell.appendChild(customElementsGroup);
 	                }
+	                if (isMergeCellGroup(cell)) {
+	                    const mergeRange = scene.table.getCellRange(cell.mergeStartCol, cell.mergeStartRow);
+	                    if (isCornerCustomMergeRange(mergeRange, scene.table)) {
+	                        cell.setAttribute('clip', !shouldRenderCornerCustomMergeContent(col, row, mergeRange, scene.table));
+	                    }
+	                }
 	            }
 	        }
-	        updateMergeCellContentHeight(cell, distHeight, detaY, scene.table.isAutoRowHeight(row), renderDefault, scene.table);
+	        updateMergeCellContentHeight(cell, distHeight, detaY, scene.table.isAutoRowHeight(row), renderDefault, scene.table, !customContainer, pendingCornerCustomMergeRanges);
 	    }
 	}
-	function updateMergeCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, renderDefault, table) {
+	function updateMergeCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, renderDefault, table, refreshCornerCustomMergeContent = true, pendingCornerCustomMergeRanges) {
 	    if (isMergeCellGroup(cellGroup)) {
 	        distHeight = 0;
 	        for (let row = cellGroup.mergeStartRow; row <= cellGroup.mergeEndRow; row++) {
@@ -60296,6 +60542,10 @@
 	                }
 	            }
 	        }
+	        const mergeRange = table.getCellRange(cellGroup.mergeStartCol, cellGroup.mergeStartRow);
+	        if (refreshCornerCustomMergeContent && isCornerCustomMergeRange(mergeRange, table)) {
+	            queueCornerCustomMergeContentUpdate(mergeRange, table, pendingCornerCustomMergeRanges);
+	        }
 	    }
 	    else {
 	        const style = table._getCellStyle(cellGroup.col, cellGroup.row);
@@ -60304,33 +60554,35 @@
 	    }
 	}
 
-	function updateColWidth(scene, col, detaX, skipTableWidthMap) {
+	function updateColWidth(scene, col, detaX, skipTableWidthMap, pendingCornerCustomMergeRanges) {
+	    const shouldFlushCornerCustomMergeRanges = !pendingCornerCustomMergeRanges;
+	    pendingCornerCustomMergeRanges ??= new Map();
 	    if (!skipTableWidthMap) {
 	        scene.table._setColWidth(col, scene.table.getColWidth(col) + detaX, true);
 	    }
 	    const colOrCornerHeaderColumn = scene.getColGroup(col, true);
 	    const rightTopColumn = scene.getColGroupInRightTopCorner(col);
 	    if (colOrCornerHeaderColumn && !rightTopColumn) {
-	        updateColunmWidth(colOrCornerHeaderColumn, detaX, 'col-corner', scene);
+	        updateColunmWidth(colOrCornerHeaderColumn, detaX, 'col-corner', scene, pendingCornerCustomMergeRanges);
 	    }
 	    if (rightTopColumn) {
-	        updateColunmWidth(rightTopColumn, detaX, 'right-top', scene);
+	        updateColunmWidth(rightTopColumn, detaX, 'right-top', scene, pendingCornerCustomMergeRanges);
 	    }
 	    const rowHeaderOrBodyColumn = scene.getColGroup(col);
 	    if (rowHeaderOrBodyColumn) {
-	        updateColunmWidth(rowHeaderOrBodyColumn, detaX, 'row-body', scene);
+	        updateColunmWidth(rowHeaderOrBodyColumn, detaX, 'row-body', scene, pendingCornerCustomMergeRanges);
 	    }
 	    const leftBottomColumn = scene.getColGroupInLeftBottomCorner(col);
 	    if (leftBottomColumn) {
-	        updateColunmWidth(leftBottomColumn, detaX, 'left-bottom', scene);
+	        updateColunmWidth(leftBottomColumn, detaX, 'left-bottom', scene, pendingCornerCustomMergeRanges);
 	    }
 	    const bottomColumn = scene.getColGroupInBottom(col);
 	    if (bottomColumn) {
-	        updateColunmWidth(bottomColumn, detaX, 'bottom', scene);
+	        updateColunmWidth(bottomColumn, detaX, 'bottom', scene, pendingCornerCustomMergeRanges);
 	    }
 	    const rightBottomColumn = scene.getColGroupInRightBottomCorner(col);
 	    if (rightBottomColumn) {
-	        updateColunmWidth(rightBottomColumn, detaX, 'right-bottom', scene);
+	        updateColunmWidth(rightBottomColumn, detaX, 'right-bottom', scene, pendingCornerCustomMergeRanges);
 	    }
 	    if (col < scene.frozenColCount) {
 	        scene.cornerHeaderGroup.forEachChildrenSkipChild((column, index) => {
@@ -60377,13 +60629,16 @@
 	            }
 	        });
 	    }
+	    if (shouldFlushCornerCustomMergeRanges) {
+	        flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, scene.table);
+	    }
 	}
-	function updateColunmWidth(columnGroup, detaX, mode, scene) {
+	function updateColunmWidth(columnGroup, detaX, mode, scene, pendingCornerCustomMergeRanges) {
 	    let needRerangeRow = false;
 	    const oldColumnWidth = columnGroup?.attribute.width ?? 0;
 	    columnGroup?.setAttribute('width', oldColumnWidth + detaX);
 	    columnGroup?.forEachChildren((cell, index) => {
-	        const isHeightChange = updateCellWidth(scene, cell, cell.col, cell.row, oldColumnWidth, oldColumnWidth + detaX, detaX, mode === 'row-body' ? cell.col < scene.table.rowHeaderLevelCount : true, scene.table.internalProps.autoWrapText);
+	        const isHeightChange = updateCellWidth(scene, cell, cell.col, cell.row, oldColumnWidth, oldColumnWidth + detaX, detaX, mode === 'row-body' ? cell.col < scene.table.rowHeaderLevelCount : true, scene.table.internalProps.autoWrapText, pendingCornerCustomMergeRanges);
 	        if (isHeightChange) {
 	            const mergeInfo = getCellMergeInfo(scene.table, cell.col, cell.row);
 	            if (mergeInfo && mergeInfo.end.row - mergeInfo.start.row) {
@@ -60470,7 +60725,7 @@
 	        }
 	    }
 	}
-	function updateCellWidth(scene, cell, col, row, oldWidth, distWidth, detaX, isHeader, autoWrapText) {
+	function updateCellWidth(scene, cell, col, row, oldWidth, distWidth, detaX, isHeader, autoWrapText, pendingCornerCustomMergeRanges) {
 	    if (cell.attribute.width === distWidth && !cell.needUpdateWidth) {
 	        return false;
 	    }
@@ -60502,7 +60757,7 @@
 	        cellGroup.removeChild(oldBarCell);
 	        oldBarCell.removeAllChild();
 	        oldBarCell.release();
-	        const cellChange = updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, true, scene.table);
+	        const cellChange = updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, true, scene.table, true, pendingCornerCustomMergeRanges);
 	        isHeightChange = isHeightChange || cellChange;
 	    }
 	    else if (type === 'sparkline') {
@@ -60535,6 +60790,15 @@
 	        const customContainer = cell.getChildByName(CUSTOM_CONTAINER_NAME) ||
 	            cell.getChildByName(CUSTOM_MERGE_CONTAINER_NAME);
 	        if (customContainer) {
+	            if (scene.table.reactCustomLayout) {
+	                const mergeRange = isMergeCellGroup(cellGroup)
+	                    ? scene.table.getCellRange(cellGroup.mergeStartCol, cellGroup.mergeStartRow)
+	                    : undefined;
+	                const shouldUseMergeStart = mergeRange && isCornerCustomMergeRange(mergeRange, scene.table);
+	                const removeCol = shouldUseMergeStart ? mergeRange.start.col : col;
+	                const removeRow = shouldUseMergeStart ? mergeRange.start.row : row;
+	                scene.table.reactCustomLayout.removeCustomCell(removeCol, removeRow);
+	            }
 	            let customElementsGroup;
 	            cell.removeChild(customContainer);
 	            const customMergeRange = getCustomCellMergeCustom(col, row, cell, scene.table);
@@ -60546,8 +60810,10 @@
 	                    const mergedCell = scene.getCell(mergeCol, row);
 	                    const customContainer = mergedCell.getChildByName(CUSTOM_CONTAINER_NAME) ||
 	                        mergedCell.getChildByName(CUSTOM_MERGE_CONTAINER_NAME);
-	                    customContainer.removeAllChild();
-	                    mergedCell.removeChild(customContainer);
+	                    if (customContainer) {
+	                        customContainer.removeAllChild();
+	                        mergedCell.removeChild(customContainer);
+	                    }
 	                    getCustomCellMergeCustom(mergeCol, row, mergedCell, scene.table);
 	                }
 	            }
@@ -60578,7 +60844,14 @@
 	                        }
 	                    }
 	                }
-	                if (customLayout || customRender) {
+	                const mergeRange = isMergeCellGroup(cellGroup)
+	                    ? scene.table.getCellRange(cellGroup.mergeStartCol, cellGroup.mergeStartRow)
+	                    : undefined;
+	                const shouldRenderContent = shouldRenderCornerCustomMergeContent(col, row, mergeRange, scene.table);
+	                if (!shouldRenderContent) {
+	                    renderDefault = false;
+	                }
+	                else if (customLayout || customRender) {
 	                    const style = scene.table._getCellStyle(col, row);
 	                    const padding = getQuadProps(getProp('padding', style, col, row, scene.table));
 	                    let width = cellGroup.attribute.width;
@@ -60587,13 +60860,14 @@
 	                        width = scene.table.getColsWidth(cellGroup.mergeStartCol, cellGroup.mergeEndCol);
 	                        height = scene.table.getRowsHeight(cellGroup.mergeStartRow, cellGroup.mergeEndRow);
 	                    }
-	                    const customResult = dealWithCustom(customLayout, customRender, col, row, width, height, false, scene.table.isAutoRowHeight(row), padding, isMergeCellGroup(cellGroup)
-	                        ? {
-	                            start: { col: cellGroup.mergeStartCol, row: cellGroup.mergeStartRow },
-	                            end: { col: cellGroup.mergeEndCol, row: cellGroup.mergeEndRow }
-	                        }
-	                        : undefined, scene.table);
-	                    customElementsGroup = customResult.elementsGroup;
+	                    let customCol = col;
+	                    let customRow = row;
+	                    if (mergeRange && isCornerCustomMergeRange(mergeRange, scene.table)) {
+	                        customCol = mergeRange.start.col;
+	                        customRow = mergeRange.start.row;
+	                    }
+	                    const customResult = dealWithCustom(customLayout, customRender, customCol, customRow, width, height, false, scene.table.isAutoRowHeight(row), padding, mergeRange, scene.table);
+	                    customElementsGroup = createCornerCustomMergeContainer(customResult.elementsGroup, width, height, mergeRange, scene.table);
 	                    renderDefault = customResult.renderDefault;
 	                    isHeightChange = true;
 	                }
@@ -60603,9 +60877,15 @@
 	                else if (customElementsGroup) {
 	                    cell.appendChild(customElementsGroup);
 	                }
+	                if (isMergeCellGroup(cellGroup)) {
+	                    const mergeRange = scene.table.getCellRange(cellGroup.mergeStartCol, cellGroup.mergeStartRow);
+	                    if (isCornerCustomMergeRange(mergeRange, scene.table)) {
+	                        cell.setAttribute('clip', !shouldRenderCornerCustomMergeContent(col, row, mergeRange, scene.table));
+	                    }
+	                }
 	            }
 	        }
-	        const cellChange = updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, renderDefault, scene.table);
+	        const cellChange = updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, renderDefault, scene.table, !customContainer, pendingCornerCustomMergeRanges);
 	        isHeightChange = isHeightChange || cellChange;
 	    }
 	    if (!autoWrapText) {
@@ -60614,7 +60894,7 @@
 	    }
 	    return autoRowHeight && autoWrapText ? isHeightChange : false;
 	}
-	function updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, renderDefault, table) {
+	function updateMergeCellContentWidth(cellGroup, distWidth, detaX, autoRowHeight, renderDefault, table, refreshCornerCustomMergeContent = true, pendingCornerCustomMergeRanges) {
 	    if (isMergeCellGroup(cellGroup)) {
 	        distWidth = 0;
 	        let isHeightChange = false;
@@ -60676,6 +60956,10 @@
 	                isHeightChange = isHeightChange || changed;
 	            }
 	        }
+	        const mergeRange = table.getCellRange(cellGroup.mergeStartCol, cellGroup.mergeStartRow);
+	        if (refreshCornerCustomMergeContent && isCornerCustomMergeRange(mergeRange, table)) {
+	            queueCornerCustomMergeContentUpdate(mergeRange, table, pendingCornerCustomMergeRanges);
+	        }
 	        return isHeightChange;
 	    }
 	    const style = table._getCellStyle(cellGroup.col, cellGroup.row);
@@ -62734,9 +63018,7 @@
 	    return undefined;
 	}
 	function shouldSkipCustomRenderCellValueForComputation(col, row, table) {
-	    return (table.isListTable() &&
-	        !table.isHeader(col, row) &&
-	        !table.internalProps.dataSource?.dataSourceObj?.records);
+	    return (table.isListTable() && !table.isHeader(col, row) && !table.internalProps.dataSource?.dataSourceObj?.records);
 	}
 	function computeTextWidth(col, row, cellType, table) {
 	    let maxWidth = 0;
@@ -62896,6 +63178,10 @@
 	    const minWidthColumnMap = new Map();
 	    for (let col = startCol; col < endColPlus1; col++) {
 	        const width = update ? newWidths[col] ?? table.getColWidth(col) : table.getColWidth(col);
+	        if (table.widthMode === 'adaptive' && table.internalProps._widthResizedColMap.has(col)) {
+	            totalDrawWidth -= width;
+	            continue;
+	        }
 	        const maxWidth = table.getMaxColWidth(col);
 	        const minWidth = table.getMinColWidth(col);
 	        actualWidth += width;
@@ -63351,7 +63637,9 @@
 	    let targetRow = distRow;
 	    while (targetRow < bodyBottomRow && table.getRowsHeight(table.frozenRowCount, targetRow) < visibleBodyHeight) {
 	        const nextRow = targetRow + 1;
-	        computeRowsHeight(table, nextRow, nextRow, false);
+	        if (!table.internalProps._heightResizedRowMap.has(nextRow)) {
+	            computeRowsHeight(table, nextRow, nextRow, false);
+	        }
 	        targetRow = nextRow;
 	    }
 	    return targetRow;
@@ -63389,18 +63677,34 @@
 	        distRow = Math.min(proxy.firstScreenRowLimit - 1, table.rowCount - 1);
 	    }
 	    let bodyDistRow = Math.min(proxy.bodyBottomRow, distRow - table.bottomFrozenRowCount);
-	    if (table.internalProps._widthResizedColMap.size === 0) {
-	        computeColsWidth(table, 0, distColForCompute ?? distCol);
+	    const colEndForCompute = distColForCompute ?? distCol;
+	    let hasUnresizedColumns = false;
+	    for (let col = 0; col <= colEndForCompute; col++) {
+	        if (!table.internalProps._widthResizedColMap.has(col)) {
+	            hasUnresizedColumns = true;
+	            break;
+	        }
+	    }
+	    if (hasUnresizedColumns) {
+	        computeColsWidth(table, 0, colEndForCompute);
 	    }
-	    if (table.internalProps._heightResizedRowMap.size === 0) {
-	        computeRowsHeight(table, 0, table.options.canvasHeight === 'auto' || table.options.customConfig?.forceComputeAllRowHeight
-	            ? table.rowCount - 1
-	            : distRowForCompute ?? distRow);
-	        if (table.heightMode === 'autoHeight') {
-	            bodyDistRow = fillVisibleBodyRows$1(proxy, bodyDistRow);
-	            syncVisibleBodyRows(proxy, bodyDistRow);
+	    const rowEndForCompute = table.options.canvasHeight === 'auto' || table.options.customConfig?.forceComputeAllRowHeight
+	        ? table.rowCount - 1
+	        : distRowForCompute ?? distRow;
+	    let hasUnresizedRows = false;
+	    for (let row = 0; row <= rowEndForCompute; row++) {
+	        if (!table.internalProps._heightResizedRowMap.has(row)) {
+	            hasUnresizedRows = true;
+	            break;
 	        }
 	    }
+	    if (hasUnresizedRows) {
+	        computeRowsHeight(table, 0, rowEndForCompute);
+	    }
+	    if (table.heightMode === 'autoHeight') {
+	        bodyDistRow = fillVisibleBodyRows$1(proxy, bodyDistRow);
+	        syncVisibleBodyRows(proxy, bodyDistRow);
+	    }
 	    if (distCol < table.colCount - table.rightFrozenColCount) {
 	        if (table.colCount - table.rightFrozenColCount <= table.colCount - 1) {
 	            computeColsWidth(table, table.colCount - table.rightFrozenColCount, table.colCount - 1);
@@ -68337,6 +68641,8 @@
 	        this.table.reactCustomLayout?.clearCache();
 	    }
 	    releaseStage() {
+	        this.clear = true;
+	        this._needUpdateContainer = false;
 	        const releaseAppRef = this.releaseVRenderAppRef;
 	        this.releaseVRenderAppRef = undefined;
 	        try {
@@ -68651,8 +68957,8 @@
 	            moveSelectingRangeComponentsToSelectedRangeComponents(this);
 	        });
 	    }
-	    updateColWidth(col, detaX, skipUpdateContainer, skipTableWidthMap) {
-	        updateColWidth(this, col, Math.round(detaX), skipTableWidthMap);
+	    updateColWidth(col, detaX, skipUpdateContainer, skipTableWidthMap, pendingCornerCustomMergeRanges) {
+	        updateColWidth(this, col, Math.round(detaX), skipTableWidthMap, pendingCornerCustomMergeRanges);
 	        if (!skipUpdateContainer) {
 	            this.updateContainer({ async: true });
 	        }
@@ -69042,9 +69348,9 @@
 	            }
 	        }
 	    }
-	    updateRowHeight(row, detaY, skipTableHeightMap) {
+	    updateRowHeight(row, detaY, skipTableHeightMap, pendingCornerCustomMergeRanges) {
 	        detaY = Math.round(detaY);
-	        updateRowHeight(this, row, detaY, skipTableHeightMap);
+	        updateRowHeight(this, row, detaY, skipTableHeightMap, pendingCornerCustomMergeRanges);
 	        this.updateContainerHeight(row, detaY);
 	    }
 	    updateRowsHeight(rows, detaYs, skipTableHeightMap) {
@@ -69539,6 +69845,10 @@
 	            if (!this._needUpdateContainer) {
 	                this._needUpdateContainer = true;
 	                setTimeout(() => {
+	                    if (!this._needUpdateContainer || this.clear) {
+	                        this._needUpdateContainer = false;
+	                        return;
+	                    }
 	                    this.updateContainerSync(updateConfig.needUpdateCellY ?? false);
 	                }, 0);
 	            }
@@ -71418,19 +71728,22 @@
 	    state.table.scenegraph.updateNextFrame();
 	}
 	function updateResizeColForColumn(detaX, state) {
+	    const pendingCornerCustomMergeRanges = new Map();
 	    if (state.table.widthMode === 'adaptive' && state.columnResize.col < state.table.colCount - 1) {
-	        state.table.scenegraph.updateColWidth(state.columnResize.col, detaX);
-	        state.table.scenegraph.updateColWidth(state.columnResize.col + 1, -detaX);
+	        state.table.scenegraph.updateColWidth(state.columnResize.col, detaX, undefined, undefined, pendingCornerCustomMergeRanges);
+	        state.table.scenegraph.updateColWidth(state.columnResize.col + 1, -detaX, undefined, undefined, pendingCornerCustomMergeRanges);
 	        state.table.internalProps._widthResizedColMap.add(state.columnResize.col);
 	        state.table.internalProps._widthResizedColMap.add(state.columnResize.col + 1);
 	    }
 	    else {
-	        state.table.scenegraph.updateColWidth(state.columnResize.col, detaX);
+	        state.table.scenegraph.updateColWidth(state.columnResize.col, detaX, undefined, undefined, pendingCornerCustomMergeRanges);
 	        state.table.internalProps._widthResizedColMap.add(state.columnResize.col);
 	    }
+	    flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, state.table);
 	}
 	function updateResizeColForAll$1(detaX, state) {
 	    const layout = state.table.internalProps.layoutMap;
+	    const pendingCornerCustomMergeRanges = new Map();
 	    for (let col = state.table.frozenColCount; col < state.table.colCount - state.table.rightFrozenColCount; col++) {
 	        if (!(state.table.internalProps.transpose || (state.table.isPivotTable() && !layout.indicatorsAsCol))) {
 	            const cellDefine = layout.getBody(col, state.table.columnHeaderLevelCount);
@@ -71438,9 +71751,10 @@
 	                continue;
 	            }
 	        }
-	        state.table.scenegraph.updateColWidth(col, detaX);
+	        state.table.scenegraph.updateColWidth(col, detaX, undefined, undefined, pendingCornerCustomMergeRanges);
 	        state.table.internalProps._widthResizedColMap.add(col);
 	    }
+	    flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, state.table);
 	}
 	function updateResizeColForIndicator$1(detaX, state) {
 	    const layout = state.table.internalProps.layoutMap;
@@ -71456,21 +71770,23 @@
 	        resizeDimensionKey = headerPath.dimensionKey;
 	        resizeDimensionValue = headerPath.value;
 	    }
+	    const pendingCornerCustomMergeRanges = new Map();
 	    for (let col = state.table.rowHeaderLevelCount; col < state.table.colCount - state.table.rightFrozenColCount; col++) {
 	        const indicatorKey = layout.getIndicatorKey(col, state.table.columnHeaderLevelCount);
 	        if (layout.indicatorsAsCol && indicatorKey === resizeIndicatorKey) {
-	            state.table.scenegraph.updateColWidth(col, detaX);
+	            state.table.scenegraph.updateColWidth(col, detaX, undefined, undefined, pendingCornerCustomMergeRanges);
 	            state.table.internalProps._widthResizedColMap.add(col);
 	        }
 	        else if (!layout.indicatorsAsCol) {
 	            const headerPaths = layout.getCellHeaderPaths(col, state.table.columnHeaderLevelCount - 1);
 	            const headerPath = headerPaths?.colHeaderPaths[headerPaths.colHeaderPaths.length - 1];
 	            if (headerPath && resizeDimensionKey === headerPath.dimensionKey && resizeDimensionValue === headerPath.value) {
-	                state.table.scenegraph.updateColWidth(col, detaX);
+	                state.table.scenegraph.updateColWidth(col, detaX, undefined, undefined, pendingCornerCustomMergeRanges);
 	                state.table.internalProps._widthResizedColMap.add(col);
 	            }
 	        }
 	    }
+	    flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, state.table);
 	}
 	function updateResizeColForIndicatorGroup$1(detaX, state) {
 	    const layout = state.table.internalProps.layoutMap;
@@ -71480,6 +71796,7 @@
 	    const endCol = node.startInTotal + state.table.frozenColCount + node.size - 1;
 	    const totalColWidth = state.table.getColsWidth(startCol, endCol);
 	    const moveX = detaX;
+	    const pendingCornerCustomMergeRanges = new Map();
 	    for (let col = startCol; col <= endCol; col++) {
 	        if (!(state.table.internalProps.transpose || (state.table.isPivotTable() && !layout.indicatorsAsCol))) {
 	            const cellDefine = layout.getBody(col, state.table.columnHeaderLevelCount);
@@ -71495,9 +71812,10 @@
 	        else if (deltaWidth < 0 && deltaWidth >= -0.5) {
 	            deltaWidth = -0.5;
 	        }
-	        state.table.scenegraph.updateColWidth(col, deltaWidth);
+	        state.table.scenegraph.updateColWidth(col, deltaWidth, undefined, undefined, pendingCornerCustomMergeRanges);
 	        state.table.internalProps._widthResizedColMap.add(col);
 	    }
+	    flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, state.table);
 	}
 
 	function setRadioState(col, row, field, type, indexInCell, state) {
@@ -72339,22 +72657,26 @@
 	    state.table.scenegraph.updateNextFrame();
 	}
 	function updateResizeColForRow(detaY, state) {
+	    const pendingCornerCustomMergeRanges = new Map();
 	    if (state.table.heightMode === 'adaptive' && state.rowResize.row < state.table.rowCount - 1) {
-	        state.table.scenegraph.updateRowHeight(state.rowResize.row, detaY);
-	        state.table.scenegraph.updateRowHeight(state.rowResize.row + 1, -detaY);
+	        state.table.scenegraph.updateRowHeight(state.rowResize.row, detaY, undefined, pendingCornerCustomMergeRanges);
+	        state.table.scenegraph.updateRowHeight(state.rowResize.row + 1, -detaY, undefined, pendingCornerCustomMergeRanges);
 	        state.table.internalProps._heightResizedRowMap.add(state.rowResize.row);
 	        state.table.internalProps._heightResizedRowMap.add(state.rowResize.row + 1);
 	    }
 	    else {
-	        state.table.scenegraph.updateRowHeight(state.rowResize.row, detaY);
+	        state.table.scenegraph.updateRowHeight(state.rowResize.row, detaY, undefined, pendingCornerCustomMergeRanges);
 	        state.table.internalProps._heightResizedRowMap.add(state.rowResize.row);
 	    }
+	    flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, state.table);
 	}
 	function updateResizeColForAll(detaY, state) {
+	    const pendingCornerCustomMergeRanges = new Map();
 	    for (let row = state.table.frozenRowCount; row < state.table.rowCount - state.table.bottomFrozenRowCount; row++) {
-	        state.table.scenegraph.updateRowHeight(row, detaY);
+	        state.table.scenegraph.updateRowHeight(row, detaY, undefined, pendingCornerCustomMergeRanges);
 	        state.table.internalProps._heightResizedRowMap.add(row);
 	    }
+	    flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, state.table);
 	}
 	function updateResizeColForIndicator(detaY, state) {
 	    const layout = state.table.internalProps.layoutMap;
@@ -72370,21 +72692,23 @@
 	        resizeDimensionKey = headerPath?.dimensionKey;
 	        resizeDimensionValue = headerPath?.value;
 	    }
+	    const pendingCornerCustomMergeRanges = new Map();
 	    for (let row = state.table.columnHeaderLevelCount; row < state.table.rowCount - state.table.bottomFrozenRowCount; row++) {
 	        const indicatorKey = layout.getIndicatorKey(state.table.rowHeaderLevelCount, row);
 	        if (!layout.indicatorsAsCol && indicatorKey === resizeIndicatorKey) {
-	            state.table.scenegraph.updateRowHeight(row, detaY);
+	            state.table.scenegraph.updateRowHeight(row, detaY, undefined, pendingCornerCustomMergeRanges);
 	            state.table.internalProps._heightResizedRowMap.add(row);
 	        }
 	        else if (layout.indicatorsAsCol) {
 	            const headerPaths = layout.getCellHeaderPaths(state.table.rowHeaderLevelCount - 1, row);
 	            const headerPath = headerPaths?.rowHeaderPaths?.[headerPaths.rowHeaderPaths.length - 1];
 	            if (headerPath && resizeDimensionKey === headerPath.dimensionKey && resizeDimensionValue === headerPath.value) {
-	                state.table.scenegraph.updateRowHeight(row, detaY);
+	                state.table.scenegraph.updateRowHeight(row, detaY, undefined, pendingCornerCustomMergeRanges);
 	                state.table.internalProps._heightResizedRowMap.add(row);
 	            }
 	        }
 	    }
+	    flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, state.table);
 	}
 	function updateResizeColForIndicatorGroup(detaY, state) {
 	    const layout = state.table.internalProps.layoutMap;
@@ -72394,6 +72718,7 @@
 	    const endRow = node.startInTotal + state.table.frozenRowCount + node.size - 1;
 	    const totalRowHeight = state.table.getRowsHeight(startRow, endRow);
 	    const moveY = detaY;
+	    const pendingCornerCustomMergeRanges = new Map();
 	    for (let row = startRow; row <= endRow; row++) {
 	        const prevHeight = state.table.getRowHeight(row);
 	        let deltaHeight = (prevHeight / totalRowHeight) * moveY;
@@ -72403,9 +72728,10 @@
 	        else if (deltaHeight < 0 && deltaHeight >= -0.5) {
 	            deltaHeight = -0.51;
 	        }
-	        state.table.scenegraph.updateRowHeight(row, deltaHeight);
+	        state.table.scenegraph.updateRowHeight(row, deltaHeight, undefined, pendingCornerCustomMergeRanges);
 	        state.table.internalProps._heightResizedRowMap.add(row);
 	    }
+	    flushCornerCustomMergeContentUpdates(pendingCornerCustomMergeRanges, state.table);
 	}
 
 	function updateCustomSelectBorder(scene, selectRange, style) {
@@ -74190,6 +74516,9 @@
 	                if (clickToPreview === false) {
 	                    return;
 	                }
+	                if (!cellValue) {
+	                    return;
+	                }
 	                const previewManager = getMediaPreviewManager(table);
 	                const overlay = document.createElement('div');
 	                overlay.style.width = '100%';
@@ -74227,6 +74556,9 @@
 	                if (clickToPreview === false) {
 	                    return;
 	                }
+	                if (!cellValue) {
+	                    return;
+	                }
 	                const previewManager = getMediaPreviewManager(table);
 	                const overlay = document.createElement('div');
 	                overlay.style.width = '100%';
@@ -74261,6 +74593,9 @@
 	                if (clickToPreview === false) {
 	                    return;
 	                }
+	                if (!cellValue) {
+	                    return;
+	                }
 	                const previewManager = getMediaPreviewManager(table);
 	                const overlay = document.createElement('div');
 	                overlay.style.width = '100%';
@@ -77066,7 +77401,17 @@
 	    _enableTableScroll = true;
 	    cutWaitPaste = false;
 	    clipboardCheckTimer = null;
-	    cutOperationTime = 0;
+	    cutOperationId = 0;
+	    clipboardOperationId = 0;
+	    pasteOperationId = 0;
+	    pasteWriteInProgress = false;
+	    pasteWritePromise = Promise.resolve();
+	    clipboardWritePromise = Promise.resolve();
+	    lastCopiedClipboardData = null;
+	    internalFormulaHtmlMarkerId = 0;
+	    fieldKeyIds = new WeakMap();
+	    fieldKeyId = 0;
+	    activeCutState = null;
 	    lastClipboardContent = '';
 	    cutCellRange = null;
 	    cutRanges = null;
@@ -77446,6 +77791,9 @@
 	        return false;
 	    }
 	    release() {
+	        this.clipboardOperationId++;
+	        this.pasteOperationId++;
+	        this.resetCutState();
 	        this.gesture?.release();
 	        this.globalEventListeners.forEach(item => {
 	            if (item.env === 'document') {
@@ -77471,27 +77819,68 @@
 	    }
 	    async handleCopy(e, isCut = false) {
 	        const table = this.table;
-	        !isCut && (this.cutWaitPaste = false);
-	        this.copySourceRange = null;
-	        const sourceRanges = table.stateManager.select.ranges;
-	        if (sourceRanges && sourceRanges.length === 1) {
-	            const sourceRange = sourceRanges[0];
-	            this.copySourceRange = {
-	                startCol: Math.min(sourceRange.start.col, sourceRange.end.col),
-	                startRow: Math.min(sourceRange.start.row, sourceRange.end.row)
-	            };
+	        const operationId = ++this.clipboardOperationId;
+	        this.pasteOperationId++;
+	        if (!isCut) {
+	            this.resetCutState();
 	        }
-	        else if (!sourceRanges?.length) {
+	        const copySnapshot = this.getCopySnapshot(isCut);
+	        this.copySourceRange = null;
+	        this.lastCopiedClipboardData = null;
+	        if (!copySnapshot) {
 	            this.copySourceRange = null;
-	            return;
+	            return null;
 	        }
 	        const data = this.table.getCopyValue(table.options.keyboardOptions?.getCopyCellValue?.value);
 	        if (isValid$1(data)) {
 	            e.preventDefault();
+	            let copySucceeded = false;
+	            let copiedClipboardData = null;
+	            const canUseAsyncClipboard = window.isSecureContext && !!navigator.clipboard?.writeText;
+	            const canWriteRichClipboard = window.isSecureContext && !!navigator.clipboard?.write && !!window.ClipboardItem;
+	            const hasEventClipboard = !!e.clipboardData;
+	            const dataHTML = !canUseAsyncClipboard || canWriteRichClipboard || hasEventClipboard ? this.getCopyDataHTML(data) : null;
+	            const formulaClipboardData = this.getCopyFormulaPlainData(data, isCut);
+	            if (formulaClipboardData === null) {
+	                return null;
+	            }
+	            const plainClipboardData = data;
+	            const internalFormulaText = formulaClipboardData !== plainClipboardData ? formulaClipboardData : undefined;
+	            const internalFormulaHtmlMarker = internalFormulaText ? this.createInternalFormulaHtmlMarker() : undefined;
+	            const clipboardHTML = dataHTML && internalFormulaHtmlMarker
+	                ? this.attachInternalFormulaHtmlMarker(dataHTML, internalFormulaHtmlMarker)
+	                : dataHTML;
+	            const eventClipboardWriteData = hasEventClipboard
+	                ? this.setCopyDataToEventClipboard(plainClipboardData, clipboardHTML, e, internalFormulaText, internalFormulaHtmlMarker)
+	                : null;
+	            if (eventClipboardWriteData) {
+	                copiedClipboardData = eventClipboardWriteData;
+	                this.lastCopiedClipboardData = copiedClipboardData;
+	                if (isCut) {
+	                    this.lastClipboardContent = this.getClipboardSignature(copiedClipboardData);
+	                    copySnapshot.clipboardData = copiedClipboardData;
+	                    copySnapshot.clipboardSignature = this.lastClipboardContent;
+	                }
+	                this.copySourceRange = copySnapshot.copySourceRange;
+	                this.afterCopyData(data, isCut, copySnapshot, !isCut);
+	                if (isCut && table.keyboardOptions?.showCopyCellBorder) {
+	                    window.setTimeout(() => {
+	                        if (!this.isClipboardOperationCurrent(operationId)) {
+	                            return;
+	                        }
+	                        setActiveCellRangeState(table, copySnapshot.ranges);
+	                        table.clearSelected();
+	                    }, 0);
+	                }
+	                return copySnapshot;
+	            }
 	            const element = table.getElement();
 	            if (element && element !== document.activeElement) {
 	                element.focus();
 	                await new Promise(resolve => setTimeout(resolve, 10));
+	                if (!this.isClipboardOperationCurrent(operationId)) {
+	                    return null;
+	                }
 	            }
 	            try {
 	                if (navigator.clipboard && navigator.clipboard.writeText) {
@@ -77502,6 +77891,9 @@
 	                                name: 'clipboard-write'
 	                            });
 	                            hasPermission = permissionState.state === 'granted';
+	                            if (!this.isClipboardOperationCurrent(operationId)) {
+	                                return null;
+	                            }
 	                        }
 	                        catch (permissionError) {
 	                            hasPermission = true;
@@ -77509,56 +77901,395 @@
 	                    }
 	                    if (hasPermission) {
 	                        try {
-	                            if (window.ClipboardItem) {
-	                                let htmlValues = data;
-	                                if (table.stateManager.select.ranges.length === 1 &&
-	                                    table.options.keyboardOptions?.getCopyCellValue?.html) {
-	                                    htmlValues = this.table.getCopyValue(table.options.keyboardOptions?.getCopyCellValue.html);
-	                                }
-	                                const dataHTML = setDataToHTML(htmlValues);
-	                                await navigator.clipboard.write([
-	                                    new ClipboardItem({
-	                                        'text/html': new Blob([dataHTML], { type: 'text/html' }),
-	                                        'text/plain': new Blob([data], { type: 'text/plain' })
-	                                    })
-	                                ]);
+	                            if (!this.isClipboardOperationCurrent(operationId)) {
+	                                return null;
 	                            }
-	                            else {
-	                                await navigator.clipboard.writeText(data);
+	                            copiedClipboardData = await this.queueClipboardWrite(async () => {
+	                                if (!this.isClipboardOperationCurrent(operationId)) {
+	                                    return null;
+	                                }
+	                                if (canWriteRichClipboard && clipboardHTML) {
+	                                    await navigator.clipboard.write([
+	                                        new ClipboardItem({
+	                                            'text/html': new Blob([clipboardHTML], { type: 'text/html' }),
+	                                            'text/plain': new Blob([plainClipboardData], { type: 'text/plain' })
+	                                        })
+	                                    ]);
+	                                    return {
+	                                        html: clipboardHTML,
+	                                        text: plainClipboardData,
+	                                        hasHtml: true,
+	                                        hasText: true,
+	                                        internalFormulaText,
+	                                        internalFormulaHtmlMarker
+	                                    };
+	                                }
+	                                await navigator.clipboard.writeText(plainClipboardData);
+	                                return { html: '', text: plainClipboardData, hasText: true, internalFormulaText };
+	                            });
+	                            if (copiedClipboardData) {
+	                                copySucceeded = true;
 	                            }
 	                        }
 	                        catch (clipboardError) {
-	                            this.fallbackCopyToClipboard(data, e);
+	                            if (!this.isClipboardOperationCurrent(operationId)) {
+	                                return null;
+	                            }
+	                            copySucceeded = this.fallbackCopyToClipboard(plainClipboardData);
+	                            if (!this.isClipboardOperationCurrent(operationId)) {
+	                                return null;
+	                            }
+	                            if (copySucceeded) {
+	                                copiedClipboardData = { html: '', text: plainClipboardData, hasText: true, internalFormulaText };
+	                            }
 	                        }
 	                    }
 	                    else {
-	                        this.fallbackCopyToClipboard(data, e);
+	                        copySucceeded = this.fallbackCopyToClipboard(plainClipboardData);
+	                        if (copySucceeded) {
+	                            copiedClipboardData = { html: '', text: plainClipboardData, hasText: true, internalFormulaText };
+	                        }
 	                    }
 	                }
 	                else {
-	                    this.fallbackCopyToClipboard(data, e);
+	                    copySucceeded = this.fallbackCopyToClipboard(plainClipboardData);
+	                    if (copySucceeded) {
+	                        copiedClipboardData = { html: '', text: plainClipboardData, hasText: true, internalFormulaText };
+	                    }
 	                }
-	                table.fireListeners(TABLE_EVENT_TYPE.COPY_DATA, {
-	                    cellRange: table.stateManager.select.ranges,
-	                    copyData: data,
-	                    isCut
-	                });
+	                if (!copySucceeded) {
+	                    return null;
+	                }
+	                if (!this.isClipboardOperationCurrent(operationId)) {
+	                    return null;
+	                }
+	                this.lastCopiedClipboardData = copiedClipboardData;
+	                if (isCut) {
+	                    this.lastClipboardContent = this.getClipboardSignature(copiedClipboardData);
+	                    copySnapshot.clipboardData = copiedClipboardData;
+	                    copySnapshot.clipboardSignature = this.lastClipboardContent;
+	                }
+	                this.copySourceRange = copySnapshot.copySourceRange;
+	                this.afterCopyData(data, isCut, copySnapshot, false);
 	            }
 	            catch (error) {
-	                this.fallbackCopyToClipboard(data, e);
+	                if (!this.isClipboardOperationCurrent(operationId)) {
+	                    return null;
+	                }
+	                if (!this.fallbackCopyToClipboard(plainClipboardData)) {
+	                    return null;
+	                }
+	                if (!this.isClipboardOperationCurrent(operationId)) {
+	                    return null;
+	                }
+	                this.lastCopiedClipboardData = { html: '', text: plainClipboardData, hasText: true, internalFormulaText };
+	                if (isCut) {
+	                    this.lastClipboardContent = this.getClipboardSignature(this.lastCopiedClipboardData);
+	                    copySnapshot.clipboardData = this.lastCopiedClipboardData;
+	                    copySnapshot.clipboardSignature = this.lastClipboardContent;
+	                }
+	                this.copySourceRange = copySnapshot.copySourceRange;
+	                this.afterCopyData(data, isCut, copySnapshot, false);
 	            }
 	        }
+	        else {
+	            return null;
+	        }
 	        if (table.keyboardOptions?.showCopyCellBorder) {
-	            setActiveCellRangeState(table);
+	            setActiveCellRangeState(table, copySnapshot.ranges);
 	            table.clearSelected();
 	        }
+	        return copySnapshot;
 	    }
-	    fallbackCopyToClipboard(data, e) {
+	    afterCopyData(data, isCut, copySnapshot, updateCopyCellBorder = true) {
+	        const table = this.table;
 	        try {
-	            if (e.clipboardData) {
-	                e.clipboardData.setData('text/plain', data);
-	                return;
+	            table.fireListeners(TABLE_EVENT_TYPE.COPY_DATA, {
+	                cellRange: this.cloneRanges(copySnapshot.ranges),
+	                copyData: data,
+	                isCut
+	            });
+	        }
+	        catch (error) {
+	        }
+	        if (updateCopyCellBorder && table.keyboardOptions?.showCopyCellBorder) {
+	            setActiveCellRangeState(table, copySnapshot.ranges);
+	            table.clearSelected();
+	        }
+	    }
+	    getCopySnapshot(includeCellInfos) {
+	        const ranges = this.table.stateManager.select.ranges;
+	        if (!ranges?.length) {
+	            return null;
+	        }
+	        const clonedRanges = ranges.map(range => ({
+	            start: { col: range.start.col, row: range.start.row },
+	            end: { col: range.end.col, row: range.end.row }
+	        }));
+	        const sourceRange = ranges.length === 1 ? ranges[0] : null;
+	        const sourceCellMatrix = this.getSourceCellMatrix(clonedRanges);
+	        const sourceCells = this.getSourceCells(sourceCellMatrix);
+	        const sourceSize = this.getSourceSize(clonedRanges, sourceCellMatrix);
+	        return {
+	            ranges: clonedRanges,
+	            copySourceRange: sourceRange
+	                ? {
+	                    startCol: Math.min(sourceRange.start.col, sourceRange.end.col),
+	                    startRow: Math.min(sourceRange.start.row, sourceRange.end.row)
+	                }
+	                : null,
+	            cellInfos: includeCellInfos ? this.table.getSelectedCellInfos() : null,
+	            sourceCells,
+	            sourceCellMatrix,
+	            sourceColCount: sourceSize.colCount,
+	            sourceRowCount: sourceSize.rowCount,
+	            clipboardData: null,
+	            clipboardSignature: ''
+	        };
+	    }
+	    cloneRanges(ranges) {
+	        return ranges.map(range => ({
+	            start: { col: range.start.col, row: range.start.row },
+	            end: { col: range.end.col, row: range.end.row }
+	        }));
+	    }
+	    getSourceCellMatrix(ranges) {
+	        const table = this.table;
+	        const createSourceCell = (col, row) => {
+	            const recordShowIndex = table.getRecordShowIndexByCell?.(col, row);
+	            const recordIndex = recordShowIndex >= 0 ? table.dataSource?.getIndexKey?.(recordShowIndex) : undefined;
+	            const field = table.internalProps?.layoutMap?.getBody?.(col, row)?.field;
+	            return { col, row, recordIndex, field, value: table.getCellOriginValue?.(col, row) };
+	        };
+	        if (ranges.length === 1) {
+	            const range = ranges[0];
+	            const startCol = Math.min(range.start.col, range.end.col);
+	            const endCol = Math.max(range.start.col, range.end.col);
+	            const startRow = Math.min(range.start.row, range.end.row);
+	            const endRow = Math.max(range.start.row, range.end.row);
+	            const sourceCellMatrix = [];
+	            for (let row = startRow; row <= endRow; row++) {
+	                const rowCells = [];
+	                for (let col = startCol; col <= endCol; col++) {
+	                    rowCells.push(createSourceCell(col, row));
+	                }
+	                sourceCellMatrix.push(rowCells);
+	            }
+	            return sourceCellMatrix;
+	        }
+	        let minCol = Math.min(ranges[0].start.col, ranges[0].end.col);
+	        let maxCol = Math.max(ranges[0].start.col, ranges[0].end.col);
+	        let minRow = Math.min(ranges[0].start.row, ranges[0].end.row);
+	        let maxRow = Math.max(ranges[0].start.row, ranges[0].end.row);
+	        ranges.forEach(range => {
+	            minCol = Math.min(minCol, range.start.col, range.end.col);
+	            maxCol = Math.max(maxCol, range.start.col, range.end.col);
+	            minRow = Math.min(minRow, range.start.row, range.end.row);
+	            maxRow = Math.max(maxRow, range.start.row, range.end.row);
+	        });
+	        const isExistDataInRow = (row) => ranges.some(range => {
+	            const startRow = Math.min(range.start.row, range.end.row);
+	            const endRow = Math.max(range.start.row, range.end.row);
+	            return startRow <= row && endRow >= row;
+	        });
+	        const isExistDataInCol = (col) => ranges.some(range => {
+	            const startCol = Math.min(range.start.col, range.end.col);
+	            const endCol = Math.max(range.start.col, range.end.col);
+	            return startCol <= col && endCol >= col;
+	        });
+	        const getRangeExistDataInCell = (col, row) => ranges.some(range => {
+	            const startRow = Math.min(range.start.row, range.end.row);
+	            const endRow = Math.max(range.start.row, range.end.row);
+	            const startCol = Math.min(range.start.col, range.end.col);
+	            const endCol = Math.max(range.start.col, range.end.col);
+	            return startCol <= col && endCol >= col && startRow <= row && endRow >= row;
+	        });
+	        const sourceCellMatrix = [];
+	        for (let row = minRow; row <= maxRow; row++) {
+	            if (!isExistDataInRow(row)) {
+	                continue;
+	            }
+	            const rowCells = [];
+	            for (let col = minCol; col <= maxCol; col++) {
+	                if (!isExistDataInCol(col)) {
+	                    continue;
+	                }
+	                rowCells.push(getRangeExistDataInCell(col, row) ? createSourceCell(col, row) : null);
+	            }
+	            sourceCellMatrix.push(rowCells);
+	        }
+	        return sourceCellMatrix;
+	    }
+	    getSourceCells(sourceCellMatrix) {
+	        const sourceCells = [];
+	        for (let row = 0; row < sourceCellMatrix.length; row++) {
+	            for (let col = 0; col < sourceCellMatrix[row].length; col++) {
+	                const sourceCell = sourceCellMatrix[row][col];
+	                if (sourceCell) {
+	                    sourceCells.push(sourceCell);
+	                }
+	            }
+	        }
+	        return sourceCells;
+	    }
+	    getSourceSize(ranges, sourceCellMatrix) {
+	        if (sourceCellMatrix.length) {
+	            return {
+	                colCount: sourceCellMatrix[0]?.length ?? 0,
+	                rowCount: sourceCellMatrix.length
+	            };
+	        }
+	        if (ranges.length === 1) {
+	            const range = ranges[0];
+	            return {
+	                colCount: Math.abs(range.end.col - range.start.col) + 1,
+	                rowCount: Math.abs(range.end.row - range.start.row) + 1
+	            };
+	        }
+	        return { colCount: 0, rowCount: 0 };
+	    }
+	    getClipboardSignature(data) {
+	        return data
+	            ? JSON.stringify({
+	                html: data.hasHtml ? data.html : null,
+	                text: data.hasText ? data.text : null
+	            })
+	            : '';
+	    }
+	    isClipboardOperationCurrent(operationId) {
+	        return operationId === this.clipboardOperationId && !this.table.isReleased;
+	    }
+	    isPasteOperationCurrent(operationId) {
+	        return (operationId === undefined || operationId === this.pasteOperationId) && !this.table.isReleased;
+	    }
+	    async queueClipboardWrite(write) {
+	        const previousWrite = this.clipboardWritePromise;
+	        let settleCurrentWrite = () => {
+	            return;
+	        };
+	        this.clipboardWritePromise = previousWrite
+	            .catch(() => {
+	        })
+	            .then(() => new Promise(resolve => {
+	            settleCurrentWrite = resolve;
+	        }));
+	        await previousWrite.catch(() => {
+	        });
+	        try {
+	            return await write();
+	        }
+	        finally {
+	            settleCurrentWrite();
+	        }
+	    }
+	    isClipboardDataChanged(clipboardData, cutState) {
+	        if (!clipboardData || clipboardData.readFailed) {
+	            return null;
+	        }
+	        const sourceData = cutState.clipboardData;
+	        if (!sourceData) {
+	            return this.getClipboardSignature(clipboardData) !== cutState.clipboardSignature;
+	        }
+	        if (sourceData.hasHtml && !clipboardData.hasHtml) {
+	            return null;
+	        }
+	        if (sourceData.hasText && !clipboardData.hasText) {
+	            return null;
+	        }
+	        let hasComparableType = false;
+	        if (clipboardData.hasHtml && sourceData.hasHtml) {
+	            hasComparableType = true;
+	            if (clipboardData.html !== sourceData.html) {
+	                return true;
+	            }
+	        }
+	        if (clipboardData.hasText && sourceData.hasText) {
+	            hasComparableType = true;
+	            if (clipboardData.text !== sourceData.text) {
+	                return true;
 	            }
+	        }
+	        if (hasComparableType) {
+	            return false;
+	        }
+	        return null;
+	    }
+	    isClipboardDataSameAsLastCopy(clipboardData) {
+	        const sourceData = this.lastCopiedClipboardData;
+	        if (!clipboardData || clipboardData.readFailed || !sourceData) {
+	            return false;
+	        }
+	        return this.isClipboardDataSameBySignature(clipboardData, sourceData);
+	    }
+	    isClipboardDataSameBySignature(clipboardData, sourceData) {
+	        return (sourceData.hasHtml === clipboardData.hasHtml &&
+	            sourceData.hasText === clipboardData.hasText &&
+	            (!sourceData.hasHtml || sourceData.html === clipboardData.html) &&
+	            (!sourceData.hasText || sourceData.text === clipboardData.text));
+	    }
+	    getCopyFormulaPlainData(data, isCut) {
+	        const table = this.table;
+	        if (table.stateManager.select.ranges.length !== 1 || !table.options.keyboardOptions?.getCopyCellValue?.html) {
+	            return data;
+	        }
+	        try {
+	            return this.table.getCopyValue(table.options.keyboardOptions.getCopyCellValue.html);
+	        }
+	        catch (error) {
+	            return isCut ? null : data;
+	        }
+	    }
+	    getCopyDataHTML(data) {
+	        const table = this.table;
+	        let htmlValues = data;
+	        try {
+	            if (table.stateManager.select.ranges.length === 1 &&
+	                table.options.keyboardOptions?.getCopyCellValue?.html) {
+	                htmlValues = this.table.getCopyValue(table.options.keyboardOptions?.getCopyCellValue.html);
+	            }
+	            return setDataToHTML(htmlValues);
+	        }
+	        catch (error) {
+	            try {
+	                return setDataToHTML(data);
+	            }
+	            catch (fallbackError) {
+	                return null;
+	            }
+	        }
+	    }
+	    createInternalFormulaHtmlMarker() {
+	        return `vtable-formula-${Date.now()}-${++this.internalFormulaHtmlMarkerId}`;
+	    }
+	    attachInternalFormulaHtmlMarker(html, marker) {
+	        return `${html}<!--${marker}-->`;
+	    }
+	    setCopyDataToEventClipboard(data, dataHTML, e, internalFormulaText, internalFormulaHtmlMarker) {
+	        const clipboardData = e.clipboardData;
+	        if (!clipboardData) {
+	            return null;
+	        }
+	        try {
+	            clipboardData.setData('text/plain', data);
+	            const copiedClipboardData = { html: '', text: data, hasText: true, internalFormulaText };
+	            if (dataHTML) {
+	                try {
+	                    clipboardData.setData('text/html', dataHTML);
+	                    copiedClipboardData.html = dataHTML;
+	                    copiedClipboardData.hasHtml = true;
+	                    copiedClipboardData.internalFormulaHtmlMarker = internalFormulaHtmlMarker;
+	                }
+	                catch (error) {
+	                }
+	            }
+	            return copiedClipboardData;
+	        }
+	        catch (error) {
+	            return null;
+	        }
+	    }
+	    fallbackCopyToClipboard(data) {
+	        try {
 	            if (document.activeElement && document.activeElement !== document.body) {
 	                document.activeElement.blur();
 	            }
@@ -77578,6 +78309,7 @@
 	                const successful = document.execCommand('copy');
 	                if (!successful) {
 	                }
+	                return successful;
 	            }
 	            catch (execError) {
 	            }
@@ -77587,321 +78319,648 @@
 	        }
 	        catch (error) {
 	        }
+	        return false;
 	    }
 	    async handleCut(e) {
-	        this.handleCopy(e, true);
+	        const copySnapshot = await this.handleCopy(e, true);
+	        if (!copySnapshot) {
+	            return;
+	        }
+	        const cutState = {
+	            id: ++this.cutOperationId,
+	            ranges: this.cloneRanges(copySnapshot.ranges),
+	            cellInfos: copySnapshot.cellInfos,
+	            sourceCells: copySnapshot.sourceCells,
+	            sourceCellMatrix: copySnapshot.sourceCellMatrix,
+	            sourceColCount: copySnapshot.sourceColCount,
+	            sourceRowCount: copySnapshot.sourceRowCount,
+	            clipboardData: copySnapshot.clipboardData,
+	            clipboardSignature: copySnapshot.clipboardSignature,
+	            copySourceRange: copySnapshot.copySourceRange,
+	            isSingleRange: copySnapshot.ranges.length === 1
+	        };
 	        this.cutWaitPaste = true;
-	        this.cutCellRange = this.table.getSelectedCellInfos();
-	        this.cutRanges = this.table.stateManager.select.ranges?.map(r => ({
-	            start: { col: r.start.col, row: r.start.row },
-	            end: { col: r.end.col, row: r.end.row }
-	        }));
+	        this.activeCutState = cutState;
+	        this.cutCellRange = cutState.cellInfos;
+	        this.cutRanges = cutState.ranges;
 	        if (this.clipboardCheckTimer) {
 	            clearTimeout(this.clipboardCheckTimer);
 	        }
 	        this.clipboardCheckTimer = window.setTimeout(() => {
 	            if (this.cutWaitPaste) {
-	                this.cutWaitPaste = false;
-	                this.cutCellRange = null;
-	                this.cutRanges = null;
-	                this.clipboardCheckTimer = null;
+	                this.resetCutState();
 	            }
 	        }, 30000);
-	        this.saveClipboardContent();
+	        this.lastClipboardContent = cutState.clipboardSignature;
 	    }
 	    handlePaste(e) {
+	        const pasteOperationId = ++this.pasteOperationId;
+	        const pasteRange = this.getPasteRange();
+	        if (!pasteRange) {
+	            return;
+	        }
+	        const eventClipboardData = this.getEventClipboardData(e);
+	        const pasteCopySourceRange = this.copySourceRange;
 	        if (!this.cutWaitPaste) {
-	            this.executePaste(e);
+	            this.readClipboardDataForPaste(eventClipboardData)
+	                .then(clipboardData => {
+	                if (!this.isPasteOperationCurrent(pasteOperationId)) {
+	                    return;
+	                }
+	                const copySourceRange = this.isClipboardDataSameAsLastCopy(clipboardData) ? pasteCopySourceRange : null;
+	                this.executePaste(clipboardData, {
+	                    pasteRange,
+	                    copySourceRange,
+	                    pasteOperationId
+	                });
+	            })
+	                .catch(error => {
+	            });
+	            return;
+	        }
+	        const cutState = this.activeCutState;
+	        if (!cutState) {
+	            this.executePaste(eventClipboardData, {
+	                pasteRange,
+	                copySourceRange: this.isClipboardDataSameAsLastCopy(eventClipboardData) ? pasteCopySourceRange : null,
+	                pasteOperationId
+	            });
 	            return;
 	        }
-	        this.checkClipboardChanged()
-	            .then(changed => {
-	            this.executePaste(e);
-	            if (!changed) {
-	                this.clearCutArea(this.table);
+	        this.readClipboardDataForPaste(eventClipboardData)
+	            .then(async (clipboardData) => {
+	            if (!this.isPasteOperationCurrent(pasteOperationId) || this.activeCutState?.id !== cutState.id) {
+	                return;
 	            }
-	            if (this.cutWaitPaste) {
-	                this.cutWaitPaste = false;
-	                this.cutCellRange = null;
-	                this.cutRanges = null;
-	                if (this.clipboardCheckTimer) {
-	                    clearTimeout(this.clipboardCheckTimer);
-	                    this.clipboardCheckTimer = null;
+	            const changed = this.isClipboardDataChanged(clipboardData, cutState);
+	            if (changed === null) {
+	                await this.executePaste(clipboardData, {
+	                    pasteRange,
+	                    copySourceRange: this.isClipboardDataSameAsLastCopy(clipboardData) ? pasteCopySourceRange : null,
+	                    pasteOperationId
+	                });
+	                return;
+	            }
+	            const pasteResult = await this.executePaste(clipboardData, {
+	                pasteRange,
+	                copySourceRange: changed ? null : cutState.copySourceRange,
+	                cutState: changed ? null : cutState,
+	                pasteOperationId
+	            });
+	            if (!this.isPasteOperationCurrent(pasteOperationId) || this.activeCutState?.id !== cutState.id) {
+	                return;
+	            }
+	            if (!changed && pasteResult.pasted && this.activeCutState?.id === cutState.id) {
+	                if (pasteResult.migratedSourceCells.length === cutState.sourceCells.length) {
+	                    const cleared = await this.clearCutArea(pasteResult.migratedSourceCells, pasteResult.changedCells);
+	                    if (!cleared) {
+	                        this.resetCutState();
+	                        return;
+	                    }
+	                    if (this.activeCutState?.id === cutState.id) {
+	                        this.resetCutState();
+	                    }
 	                }
+	                return;
+	            }
+	            if (changed && this.activeCutState?.id === cutState.id) {
+	                this.resetCutState();
 	            }
 	        })
-	            .catch(() => {
-	            this.executePaste(e);
-	            if (this.cutWaitPaste) {
-	                this.cutWaitPaste = false;
-	                this.cutCellRange = null;
-	                if (this.clipboardCheckTimer) {
-	                    clearTimeout(this.clipboardCheckTimer);
-	                    this.clipboardCheckTimer = null;
-	                }
+	            .catch(async () => {
+	            if (!this.isPasteOperationCurrent(pasteOperationId)) {
+	                return;
 	            }
+	            await this.executePaste(eventClipboardData, {
+	                pasteRange,
+	                copySourceRange: this.isClipboardDataSameAsLastCopy(eventClipboardData) ? pasteCopySourceRange : null,
+	                pasteOperationId
+	            });
 	        });
 	    }
-	    async executePaste(e) {
+	    async executePaste(clipboardData, pasteContext) {
 	        const table = this.table;
-	        if (table.editorManager?.editingEditor) {
-	            return;
+	        const emptyResult = this.getEmptyPasteResult();
+	        const pasteClipboardData = this.getPasteClipboardData(clipboardData, pasteContext);
+	        if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId) ||
+	            table.editorManager?.editingEditor) {
+	            return emptyResult;
+	        }
+	        if (this.pasteWriteInProgress) {
+	            await this.pasteWritePromise.catch(() => {
+	            });
+	            if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId) ||
+	                table.editorManager?.editingEditor) {
+	                return emptyResult;
+	            }
 	        }
-	        if (table.changeCellValues && table.stateManager.select.ranges?.length > 0) {
-	            try {
-	                if (navigator.clipboard && navigator.clipboard.read) {
-	                    try {
-	                        const clipboardItems = await navigator.clipboard.read();
-	                        let handled = false;
-	                        for (const item of clipboardItems) {
-	                            if (item.types.includes('text/html')) {
-	                                await this.pasteHtmlToTable(item);
-	                                handled = true;
-	                                break;
-	                            }
-	                            else if (item.types.includes('text/plain')) {
-	                                await this.pasteTextToTable(item);
-	                                handled = true;
-	                                break;
+	        let pasteResult = emptyResult;
+	        let settlePasteWrite = () => {
+	            return;
+	        };
+	        this.pasteWritePromise = new Promise(resolve => {
+	            settlePasteWrite = resolve;
+	        });
+	        this.pasteWriteInProgress = true;
+	        try {
+	            if (table.changeCellValues) {
+	                try {
+	                    if (pasteClipboardData?.html) {
+	                        try {
+	                            const htmlResult = await this.processPastedHTML(pasteClipboardData.html, pasteContext);
+	                            if (htmlResult.pasted) {
+	                                pasteResult = htmlResult;
+	                                return pasteResult;
 	                            }
 	                        }
-	                        if (!handled) {
-	                            await this.fallbackPasteFromClipboard(e);
+	                        catch (error) {
+	                            if (/<table\b/i.test(pasteClipboardData.html)) {
+	                                return emptyResult;
+	                            }
 	                        }
 	                    }
-	                    catch (clipboardError) {
-	                        await this.fallbackPasteFromClipboard(e);
+	                    if (pasteClipboardData?.hasText || pasteClipboardData?.text) {
+	                        pasteResult = await this.processPastedText(pasteClipboardData.internalFormulaText ?? pasteClipboardData.text, pasteContext);
+	                        return pasteResult;
 	                    }
 	                }
-	                else {
-	                    await this.fallbackPasteFromClipboard(e);
+	                catch (error) {
+	                    if (pasteContext.cutState) {
+	                        this.resetCutState();
+	                    }
 	                }
 	            }
-	            catch (error) {
-	                await this.fallbackPasteFromClipboard(e);
-	            }
+	            return pasteResult;
 	        }
-	        if (table.keyboardOptions?.showCopyCellBorder) {
-	            clearActiveCellRangeState(table);
-	        }
-	    }
-	    async fallbackPasteFromClipboard(e) {
-	        const table = this.table;
-	        const ranges = table.stateManager.select.ranges;
-	        const col = Math.min(ranges[0].start.col, ranges[0].end.col);
-	        const row = Math.min(ranges[0].start.row, ranges[0].end.row);
-	        try {
-	            const element = table.getElement();
-	            if (element && element !== document.activeElement) {
-	                element.focus();
-	                await new Promise(resolve => setTimeout(resolve, 10));
-	            }
-	            const clipboardData = e.clipboardData || window.clipboardData || window.Clipboard;
-	            if (clipboardData) {
-	                const pastedData = clipboardData.getData('text') || clipboardData.getData('Text');
-	                if (pastedData) {
-	                    await this.processPastedText(pastedData, col, row);
-	                    return;
-	                }
+	        finally {
+	            this.pasteWriteInProgress = false;
+	            settlePasteWrite();
+	            if (!pasteContext.cutState && table.keyboardOptions?.showCopyCellBorder) {
+	                clearActiveCellRangeState(table);
 	            }
 	        }
-	        catch (error) {
-	        }
 	    }
-	    async processPastedText(pastedData, col, row) {
-	        const table = this.table;
-	        const rows = pastedData.split('\n');
-	        const values = [];
-	        rows.forEach(function (rowCells) {
-	            const cells = rowCells.split('\t');
-	            const rowValues = [];
-	            values.push(rowValues);
-	            cells.forEach(function (cell, cellIndex) {
-	                if (cellIndex === cells.length - 1) {
-	                    cell = cell.trim();
-	                }
-	                rowValues.push(cell);
-	            });
-	        });
-	        let processedValues;
-	        if (table.options.keyboardOptions?.processFormulaBeforePaste && this.copySourceRange) {
-	            processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, this.copySourceRange.startCol, this.copySourceRange.startRow, col, row);
+	    getPasteClipboardData(clipboardData, pasteContext) {
+	        if (!clipboardData || !pasteContext.copySourceRange) {
+	            return clipboardData;
 	        }
-	        const changedCellResults = await table.changeCellValues(col, row, processedValues ? processedValues : values, true);
-	        if (table.hasListeners(TABLE_EVENT_TYPE.PASTED_DATA)) {
-	            table.fireListeners(TABLE_EVENT_TYPE.PASTED_DATA, {
-	                col,
-	                row,
-	                pasteData: processedValues ? processedValues : values,
-	                changedCellResults
-	            });
+	        const sourceData = pasteContext.cutState?.clipboardData ?? this.lastCopiedClipboardData;
+	        if (!sourceData?.internalFormulaText ||
+	            !sourceData.internalFormulaHtmlMarker ||
+	            !sourceData.hasHtml ||
+	            !clipboardData.hasHtml ||
+	            !this.isClipboardDataSameBySignature(clipboardData, sourceData) ||
+	            !clipboardData.html.includes(sourceData.internalFormulaHtmlMarker)) {
+	            return clipboardData;
 	        }
+	        return {
+	            ...clipboardData,
+	            internalFormulaText: sourceData.internalFormulaText
+	        };
 	    }
-	    clearCutArea(table) {
-	        try {
-	            const ranges = this.cutRanges;
-	            if (!ranges || ranges.length === 0) {
-	                return;
-	            }
-	            table.changeCellValuesByRanges(ranges, '');
-	        }
-	        catch (error) {
+	    getPasteRange() {
+	        const ranges = this.table.stateManager.select.ranges;
+	        if (!ranges?.length) {
+	            return null;
 	        }
+	        const selectRangeLength = ranges.length;
+	        const range = ranges[selectRangeLength - 1];
+	        return {
+	            col: Math.min(range.start.col, range.end.col),
+	            row: Math.min(range.start.row, range.end.row),
+	            maxCol: Math.max(range.start.col, range.end.col),
+	            maxRow: Math.max(range.start.row, range.end.row)
+	        };
 	    }
-	    async checkClipboardChanged() {
-	        if (!navigator.clipboard || !navigator.clipboard.readText) {
-	            return false;
+	    getEventClipboardData(e) {
+	        const clipboardData = e.clipboardData || window.clipboardData;
+	        if (!clipboardData) {
+	            return null;
 	        }
 	        try {
-	            const currentContent = await navigator.clipboard.readText();
-	            return currentContent !== this.lastClipboardContent;
+	            const types = Array.from(clipboardData.types ?? []);
+	            const html = clipboardData.getData('text/html') || '';
+	            const text = clipboardData.getData('text/plain') || clipboardData.getData('text') || clipboardData.getData('Text') || '';
+	            const hasHtml = types.includes('text/html') || !!html;
+	            const hasText = types.includes('text/plain') || types.includes('text') || types.includes('Text') || !!text;
+	            return {
+	                html,
+	                text,
+	                hasHtml,
+	                hasText
+	            };
 	        }
-	        catch (err) {
-	            return false;
+	        catch (error) {
+	            return { html: '', text: '', readFailed: true };
 	        }
 	    }
-	    saveClipboardContent() {
-	        if (navigator.clipboard && navigator.clipboard.readText) {
-	            setTimeout(() => {
-	                navigator.clipboard
-	                    .readText()
-	                    .then(text => {
-	                    this.lastClipboardContent = text;
-	                })
-	                    .catch(err => {
-	                });
-	            }, 50);
+	    async readClipboardDataForPaste(eventClipboardData) {
+	        if (eventClipboardData?.readFailed || eventClipboardData?.hasHtml || eventClipboardData?.hasText) {
+	            return eventClipboardData;
 	        }
-	    }
-	    pasteHtmlToTable(item) {
-	        const regex = /<tr[^>]*>([\s\S]*?)<\/tr>/g;
-	        const cellRegex = /<td[^>]*>([\s\S]*?)<\/td>/g;
-	        const table = this.table;
-	        const ranges = table.stateManager.select.ranges;
-	        const selectRangeLength = ranges.length;
-	        const col = Math.min(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col);
-	        const row = Math.min(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row);
-	        const maxCol = Math.max(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col);
-	        const maxRow = Math.max(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row);
-	        let pasteValuesColCount = 0;
-	        let pasteValuesRowCount = 0;
-	        let values = [];
-	        item.getType('text/html').then((blob) => {
-	            blob.text().then(async (pastedData) => {
-	                if (pastedData && /(<table)|(<TABLE)/g.test(pastedData)) {
-	                    const matches = Array.from(pastedData.matchAll(regex));
-	                    for (const match of matches) {
-	                        const rowContent = match[1];
-	                        const cellMatches = Array.from(rowContent.matchAll(cellRegex));
-	                        const rowValues = cellMatches.map(cellMatch => {
-	                            return (cellMatch[1]
-	                                .replace(/(<(?!br)([^>]+)>)/gi, '')
-	                                .replace(/<br(\s*|\/)>[\r\n]?/gim, '\n')
-	                                .replace(/&amp;/g, '&')
-	                                .replace(/&lt;/g, '<')
-	                                .replace(/&gt;/g, '>')
-	                                .replace(/&#9;/gi, '\t')
-	                                .replace(/&nbsp;/g, ' '));
-	                        });
-	                        values.push(rowValues);
-	                        pasteValuesColCount = Math.max(pasteValuesColCount, rowValues?.length ?? 0);
-	                    }
-	                    pasteValuesRowCount = values.length ?? 0;
-	                    values = this.handlePasteValues(values, pasteValuesRowCount, pasteValuesColCount, maxRow - row + 1, maxCol - col + 1);
-	                    let processedValues;
-	                    if (table.options.keyboardOptions?.processFormulaBeforePaste && this.copySourceRange) {
-	                        processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, this.copySourceRange.startCol, this.copySourceRange.startRow, col, row);
-	                    }
-	                    const changedCellResults = await table.changeCellValues(col, row, processedValues ? processedValues : values, true);
-	                    if (table.hasListeners(TABLE_EVENT_TYPE.PASTED_DATA)) {
-	                        table.fireListeners(TABLE_EVENT_TYPE.PASTED_DATA, {
-	                            col,
-	                            row,
-	                            pasteData: processedValues ? processedValues : values,
-	                            changedCellResults
-	                        });
+	        if (navigator.clipboard?.read) {
+	            try {
+	                const clipboardItems = await navigator.clipboard.read();
+	                const clipboardData = { html: '', text: '' };
+	                for (const item of clipboardItems) {
+	                    if (!clipboardData.html && item.types.includes('text/html')) {
+	                        try {
+	                            clipboardData.html = await (await item.getType('text/html')).text();
+	                            clipboardData.hasHtml = true;
+	                        }
+	                        catch (error) {
+	                        }
 	                    }
-	                }
-	                else {
-	                    navigator.clipboard.read().then(clipboardItems => {
-	                        for (const item of clipboardItems) {
-	                            if (item.types.includes('text/plain')) {
-	                                item.getType('text/plain').then((blob) => {
-	                                    blob.text().then(data => this._pasteValue(data));
-	                                });
-	                            }
+	                    if (!clipboardData.text && item.types.includes('text/plain')) {
+	                        try {
+	                            clipboardData.text = await (await item.getType('text/plain')).text();
+	                            clipboardData.hasText = true;
 	                        }
-	                    });
+	                        catch (error) {
+	                        }
+	                    }
 	                }
-	            });
-	        });
+	                if (clipboardData.hasHtml || clipboardData.hasText) {
+	                    return clipboardData;
+	                }
+	            }
+	            catch (error) {
+	            }
+	        }
+	        if (navigator.clipboard?.readText) {
+	            try {
+	                return { html: '', text: await navigator.clipboard.readText(), hasText: true };
+	            }
+	            catch (error) {
+	            }
+	        }
+	        return eventClipboardData ?? { html: '', text: '', readFailed: true };
+	    }
+	    decodeHTMLCellValue(cellHTML) {
+	        const template = document.createElement('template');
+	        template.innerHTML = cellHTML.replace(/<br\b[^>]*>(?:\r\n|\r|\n)?/gim, '\n').replace(/&nbsp;/gi, ' ');
+	        return template.content.textContent ?? '';
 	    }
-	    async _pasteValue(pastedData) {
+	    async processPastedHTML(pastedData, pasteContext) {
+	        const regex = /<tr[^>]*>([\s\S]*?)<\/tr>/gi;
+	        const cellRegex = /<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi;
 	        const table = this.table;
-	        const ranges = table.stateManager.select.ranges;
-	        const selectRangeLength = ranges.length;
-	        const col = Math.min(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col);
-	        const row = Math.min(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row);
-	        const maxCol = Math.max(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col);
-	        const maxRow = Math.max(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row);
+	        const pasteRange = pasteContext.pasteRange;
+	        const { col, row, maxCol, maxRow } = pasteRange;
 	        let pasteValuesColCount = 0;
 	        let pasteValuesRowCount = 0;
 	        let values = [];
-	        const rows = pastedData.split('\n');
-	        rows.forEach(function (rowCells, rowIndex) {
-	            const cells = rowCells.split('\t');
-	            const rowValues = [];
-	            values.push(rowValues);
-	            cells.forEach(function (cell, cellIndex) {
-	                if (cellIndex === cells.length - 1) {
-	                    cell = cell.trim();
-	                }
-	                rowValues.push(cell);
+	        if (!pastedData || !/<table\b/i.test(pastedData)) {
+	            return this.getEmptyPasteResult();
+	        }
+	        const matches = Array.from(pastedData.matchAll(regex));
+	        for (const match of matches) {
+	            const rowContent = match[1];
+	            const cellMatches = Array.from(rowContent.matchAll(cellRegex));
+	            if (!cellMatches.length) {
+	                continue;
+	            }
+	            const rowValues = cellMatches.map(cellMatch => {
+	                return this.decodeHTMLCellValue(cellMatch[1]);
 	            });
+	            values.push(rowValues);
 	            pasteValuesColCount = Math.max(pasteValuesColCount, rowValues?.length ?? 0);
-	        });
+	        }
 	        pasteValuesRowCount = values.length ?? 0;
+	        if (!pasteValuesRowCount || !pasteValuesColCount) {
+	            return this.getEmptyPasteResult();
+	        }
 	        values = this.handlePasteValues(values, pasteValuesRowCount, pasteValuesColCount, maxRow - row + 1, maxCol - col + 1);
 	        let processedValues;
-	        if (table.options.keyboardOptions?.processFormulaBeforePaste && this.copySourceRange) {
-	            processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, this.copySourceRange.startCol, this.copySourceRange.startRow, col, row);
+	        if (table.options.keyboardOptions?.processFormulaBeforePaste && pasteContext.copySourceRange) {
+	            processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, pasteContext.copySourceRange.startCol, pasteContext.copySourceRange.startRow, col, row);
+	        }
+	        const valuesToPaste = processedValues ? processedValues : values;
+	        const targetCells = this.getPasteTargetCells(pasteRange, valuesToPaste);
+	        if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) {
+	            return this.getEmptyPasteResult();
+	        }
+	        if (pasteContext.cutState) {
+	            const validatedCellResults = await this.validatePasteTargetCells(pasteRange, valuesToPaste);
+	            if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) {
+	                return this.getEmptyPasteResult();
+	            }
+	            if (!this.isFullPasteAllowed(valuesToPaste, validatedCellResults)) {
+	                return this.getEmptyPasteResult(validatedCellResults);
+	            }
+	        }
+	        const rawChangedCellResults = await table.changeCellValues(col, row, valuesToPaste, !pasteContext.cutState, true, undefined, () => !this.isPasteOperationCurrent(pasteContext.pasteOperationId));
+	        if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) {
+	            return this.getEmptyPasteResult();
+	        }
+	        const changedCellResults = this.normalizeChangedCellResults(rawChangedCellResults, pasteRange, valuesToPaste);
+	        const changedCells = this.getChangedCells(targetCells, changedCellResults);
+	        const migratedSourceCells = this.getMigratedSourceCells(pasteContext.cutState, changedCellResults);
+	        if (!changedCells.length) {
+	            return this.getEmptyPasteResult(changedCellResults);
 	        }
-	        const changedCellResults = await table.changeCellValues(col, row, processedValues ? processedValues : values, true);
-	        if (table.hasListeners(TABLE_EVENT_TYPE.PASTED_DATA)) {
+	        this.firePastedDataEvent(col, row, valuesToPaste, changedCellResults);
+	        return { pasted: true, changedCellResults, changedCells, migratedSourceCells };
+	    }
+	    async processPastedText(pastedData, pasteContext) {
+	        const table = this.table;
+	        const pasteRange = pasteContext.pasteRange;
+	        const { col, row, maxCol, maxRow } = pasteRange;
+	        let values = this.parsePlainTextPastedData(pastedData);
+	        const pasteValuesRowCount = values.length;
+	        const pasteValuesColCount = Math.max(...values.map(rowValues => rowValues.length));
+	        if (!pasteValuesRowCount || !pasteValuesColCount) {
+	            return this.getEmptyPasteResult();
+	        }
+	        values = this.handlePasteValues(values, pasteValuesRowCount, pasteValuesColCount, maxRow - row + 1, maxCol - col + 1);
+	        let processedValues;
+	        if (table.options.keyboardOptions?.processFormulaBeforePaste && pasteContext.copySourceRange) {
+	            processedValues = table.options.keyboardOptions.processFormulaBeforePaste(values, pasteContext.copySourceRange.startCol, pasteContext.copySourceRange.startRow, col, row);
+	        }
+	        const valuesToPaste = processedValues ? processedValues : values;
+	        const targetCells = this.getPasteTargetCells(pasteRange, valuesToPaste);
+	        if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) {
+	            return this.getEmptyPasteResult();
+	        }
+	        if (pasteContext.cutState) {
+	            const validatedCellResults = await this.validatePasteTargetCells(pasteRange, valuesToPaste);
+	            if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) {
+	                return this.getEmptyPasteResult();
+	            }
+	            if (!this.isFullPasteAllowed(valuesToPaste, validatedCellResults)) {
+	                return this.getEmptyPasteResult(validatedCellResults);
+	            }
+	        }
+	        const rawChangedCellResults = await table.changeCellValues(col, row, valuesToPaste, !pasteContext.cutState, true, undefined, () => !this.isPasteOperationCurrent(pasteContext.pasteOperationId));
+	        if (!this.isPasteOperationCurrent(pasteContext.pasteOperationId)) {
+	            return this.getEmptyPasteResult();
+	        }
+	        const changedCellResults = this.normalizeChangedCellResults(rawChangedCellResults, pasteRange, valuesToPaste);
+	        const changedCells = this.getChangedCells(targetCells, changedCellResults);
+	        const migratedSourceCells = this.getMigratedSourceCells(pasteContext.cutState, changedCellResults);
+	        if (!changedCells.length) {
+	            return this.getEmptyPasteResult(changedCellResults);
+	        }
+	        this.firePastedDataEvent(col, row, valuesToPaste, changedCellResults);
+	        return { pasted: true, changedCellResults, changedCells, migratedSourceCells };
+	    }
+	    firePastedDataEvent(col, row, pasteData, changedCellResults) {
+	        const table = this.table;
+	        if (!table.hasListeners(TABLE_EVENT_TYPE.PASTED_DATA)) {
+	            return;
+	        }
+	        try {
 	            table.fireListeners(TABLE_EVENT_TYPE.PASTED_DATA, {
 	                col,
 	                row,
-	                pasteData: processedValues ? processedValues : values,
+	                pasteData,
 	                changedCellResults
 	            });
 	        }
+	        catch (error) {
+	        }
 	    }
-	    async pasteTextToTable(item) {
+	    getEmptyPasteResult(changedCellResults = []) {
+	        return {
+	            pasted: false,
+	            changedCellResults,
+	            changedCells: [],
+	            migratedSourceCells: []
+	        };
+	    }
+	    getPasteTargetCells(pasteRange, values) {
+	        const targetCells = [];
+	        for (let rowIndex = 0; rowIndex < values.length; rowIndex++) {
+	            targetCells[rowIndex] = [];
+	            for (let colIndex = 0; colIndex < values[rowIndex].length; colIndex++) {
+	                targetCells[rowIndex][colIndex] = this.getCellIdentity(pasteRange.col + colIndex, pasteRange.row + rowIndex);
+	            }
+	        }
+	        return targetCells;
+	    }
+	    getChangedCells(targetCells, changedCellResults) {
+	        const changedCells = [];
+	        for (let rowIndex = 0; rowIndex < changedCellResults.length; rowIndex++) {
+	            for (let colIndex = 0; colIndex < (changedCellResults[rowIndex]?.length ?? 0); colIndex++) {
+	                if (changedCellResults[rowIndex][colIndex] && targetCells[rowIndex]?.[colIndex]) {
+	                    changedCells.push(targetCells[rowIndex][colIndex]);
+	                }
+	            }
+	        }
+	        return changedCells;
+	    }
+	    normalizeChangedCellResults(changedCellResults, pasteRange, values) {
+	        if (Array.isArray(changedCellResults)) {
+	            return changedCellResults;
+	        }
 	        const table = this.table;
-	        const ranges = table.stateManager.select.ranges;
-	        const selectRangeLength = ranges.length;
-	        const col = Math.min(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col);
-	        const row = Math.min(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row);
-	        const maxCol = Math.max(ranges[selectRangeLength - 1].start.col, ranges[selectRangeLength - 1].end.col);
-	        const maxRow = Math.max(ranges[selectRangeLength - 1].start.row, ranges[selectRangeLength - 1].end.row);
+	        return values.map((rowValues, rowIndex) => rowValues.map((_value, colIndex) => {
+	            const targetCol = pasteRange.col + colIndex;
+	            const targetRow = pasteRange.row + rowIndex;
+	            return (targetCol < table.colCount &&
+	                targetRow < table.rowCount &&
+	                (!table.isHasEditorDefine || table.isHasEditorDefine(targetCol, targetRow)));
+	        }));
+	    }
+	    async validatePasteTargetCells(pasteRange, values) {
+	        const table = this.table;
+	        const changedCellResults = [];
+	        for (let rowIndex = 0; rowIndex < values.length; rowIndex++) {
+	            changedCellResults[rowIndex] = [];
+	            for (let colIndex = 0; colIndex < values[rowIndex].length; colIndex++) {
+	                const targetCol = pasteRange.col + colIndex;
+	                const targetRow = pasteRange.row + rowIndex;
+	                const tableAny = table;
+	                let canChange = targetCol < tableAny.colCount &&
+	                    targetRow < tableAny.rowCount &&
+	                    (!tableAny.isHasEditorDefine || tableAny.isHasEditorDefine(targetCol, targetRow));
+	                if (canChange) {
+	                    const editor = tableAny.getEditor?.(targetCol, targetRow);
+	                    const oldValue = table.getCellOriginValue?.(targetCol, targetRow);
+	                    const validateResult = editor?.validateValue?.(values[rowIndex][colIndex], oldValue, { col: targetCol, row: targetRow }, table) ??
+	                        true;
+	                    const resolvedValidateResult = validateResult && typeof validateResult.then === 'function'
+	                        ? await validateResult
+	                        : validateResult;
+	                    canChange =
+	                        resolvedValidateResult === true ||
+	                            resolvedValidateResult === 'validate-exit' ||
+	                            resolvedValidateResult === 'validate-not-exit';
+	                }
+	                changedCellResults[rowIndex][colIndex] = canChange;
+	            }
+	        }
+	        return changedCellResults;
+	    }
+	    isFullPasteAllowed(values, changedCellResults) {
+	        return values.every((rowValues, rowIndex) => rowValues.every((_value, colIndex) => changedCellResults[rowIndex]?.[colIndex] === true));
+	    }
+	    getMigratedSourceCells(cutState, changedCellResults) {
+	        if (!cutState?.sourceCells.length || !cutState.sourceColCount || !cutState.sourceRowCount) {
+	            return [];
+	        }
+	        const migratedSourceCells = [];
+	        const migratedKeys = new Set();
+	        if (!cutState.isSingleRange) {
+	            for (let rowIndex = 0; rowIndex < changedCellResults.length; rowIndex++) {
+	                for (let colIndex = 0; colIndex < (changedCellResults[rowIndex]?.length ?? 0); colIndex++) {
+	                    if (!changedCellResults[rowIndex][colIndex]) {
+	                        continue;
+	                    }
+	                    const sourceRow = rowIndex % cutState.sourceRowCount;
+	                    const sourceCol = colIndex % cutState.sourceColCount;
+	                    const sourceCell = cutState.sourceCellMatrix[sourceRow]?.[sourceCol];
+	                    if (!sourceCell) {
+	                        continue;
+	                    }
+	                    const sourceKey = this.getCellKey(sourceCell);
+	                    if (!migratedKeys.has(sourceKey)) {
+	                        migratedKeys.add(sourceKey);
+	                        migratedSourceCells.push(sourceCell);
+	                    }
+	                }
+	            }
+	            return migratedSourceCells.length === cutState.sourceCells.length ? migratedSourceCells : [];
+	        }
+	        for (let rowIndex = 0; rowIndex < changedCellResults.length; rowIndex++) {
+	            for (let colIndex = 0; colIndex < (changedCellResults[rowIndex]?.length ?? 0); colIndex++) {
+	                if (!changedCellResults[rowIndex][colIndex]) {
+	                    continue;
+	                }
+	                const sourceRow = rowIndex % cutState.sourceRowCount;
+	                const sourceCol = colIndex % cutState.sourceColCount;
+	                const sourceIndex = sourceRow * cutState.sourceColCount + sourceCol;
+	                const sourceCell = cutState.sourceCells[sourceIndex];
+	                if (!sourceCell) {
+	                    continue;
+	                }
+	                const sourceKey = this.getCellKey(sourceCell);
+	                if (migratedKeys.has(sourceKey)) {
+	                    continue;
+	                }
+	                migratedKeys.add(sourceKey);
+	                migratedSourceCells.push(sourceCell);
+	            }
+	        }
+	        return migratedSourceCells;
+	    }
+	    getCellIdentity(col, row) {
+	        const table = this.table;
+	        const recordShowIndex = table.getRecordShowIndexByCell?.(col, row);
+	        const recordIndex = recordShowIndex >= 0 ? table.dataSource?.getIndexKey?.(recordShowIndex) : undefined;
+	        const field = table.internalProps?.layoutMap?.getBody?.(col, row)?.field;
+	        return { col, row, recordIndex, field };
+	    }
+	    async clearCutArea(migratedSourceCells, changedTargetCells) {
 	        try {
-	            const blob = await item.getType('text/plain');
-	            const pastedData = await blob.text();
-	            const values = this.parsePastedData(pastedData);
-	            const pasteValuesRowCount = values.length;
-	            const pasteValuesColCount = Math.max(...values.map(row => row.length), 0);
-	            const processedValues = this.handlePasteValues(values, pasteValuesRowCount, pasteValuesColCount, maxRow - row + 1, maxCol - col + 1);
-	            const changedCellResults = await table.changeCellValues(col, row, processedValues, true);
-	            if (table.hasListeners(TABLE_EVENT_TYPE.PASTED_DATA)) {
-	                table.fireListeners(TABLE_EVENT_TYPE.PASTED_DATA, {
-	                    col,
-	                    row,
-	                    pasteData: processedValues,
-	                    changedCellResults
+	            const table = this.table;
+	            const changedTargetKeys = new Set();
+	            changedTargetCells.forEach(cell => {
+	                changedTargetKeys.add(this.getCellKey(cell));
+	                changedTargetKeys.add(this.getCoordKey(cell));
+	            });
+	            const clearedKeys = new Set();
+	            const sourceChanges = [];
+	            const coordChanges = [];
+	            for (let i = 0; i < migratedSourceCells.length; i++) {
+	                const sourceCell = migratedSourceCells[i];
+	                const sourceKey = this.getCellKey(sourceCell);
+	                if (clearedKeys.has(sourceKey) ||
+	                    changedTargetKeys.has(sourceKey) ||
+	                    changedTargetKeys.has(this.getCoordKey(sourceCell))) {
+	                    continue;
+	                }
+	                const currentAddress = this.getCurrentCellAddress(sourceCell);
+	                if (!currentAddress) {
+	                    continue;
+	                }
+	                if (!this.isSourceCellUnchanged(sourceCell, currentAddress)) {
+	                    continue;
+	                }
+	                if (sourceCell.recordIndex !== undefined &&
+	                    sourceCell.field !== undefined &&
+	                    table.changeCellValuesByRecords) {
+	                    sourceChanges.push({ recordIndex: sourceCell.recordIndex, field: sourceCell.field, value: '' });
+	                }
+	                else {
+	                    coordChanges.push(currentAddress);
+	                }
+	                clearedKeys.add(sourceKey);
+	            }
+	            if (sourceChanges.length) {
+	                table.changeCellValuesByRecords(sourceChanges, {
+	                    triggerEvent: true,
+	                    autoRefresh: false
 	                });
 	            }
+	            for (let i = 0; i < coordChanges.length; i++) {
+	                await table.changeCellValues(coordChanges[i].col, coordChanges[i].row, [['']], false);
+	            }
+	            if (sourceChanges.length) {
+	                table.refreshAfterSourceChange?.();
+	            }
+	            return true;
 	        }
 	        catch (error) {
+	            return false;
+	        }
+	    }
+	    isSourceCellUnchanged(sourceCell, currentAddress) {
+	        const table = this.table;
+	        return Object.is(table.getCellOriginValue?.(currentAddress.col, currentAddress.row), sourceCell.value);
+	    }
+	    getCurrentCellAddress(sourceCell) {
+	        const table = this.table;
+	        if (sourceCell.recordIndex !== undefined && sourceCell.field !== undefined && table.getCellAddrByFieldRecord) {
+	            const address = table.getCellAddrByFieldRecord(sourceCell.field, sourceCell.recordIndex);
+	            if (address && address.col >= 0 && address.row >= 0) {
+	                return address;
+	            }
+	            return null;
+	        }
+	        return { col: sourceCell.col, row: sourceCell.row };
+	    }
+	    getCellKey(cell) {
+	        if (cell.recordIndex !== undefined && cell.field !== undefined) {
+	            return `record:${this.getStableKeyPart(cell.recordIndex)}:${this.getStableKeyPart(cell.field)}`;
+	        }
+	        return this.getCoordKey(cell);
+	    }
+	    getCoordKey(cell) {
+	        return `coord:${cell.col}:${cell.row}`;
+	    }
+	    getStableKeyPart(value) {
+	        if (value === null) {
+	            return 'null';
+	        }
+	        const valueType = typeof value;
+	        if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
+	            return `${valueType}:${JSON.stringify(value)}`;
+	        }
+	        if (Array.isArray(value)) {
+	            return `array:[${value.map(item => this.getStableKeyPart(item)).join(',')}]`;
+	        }
+	        if (valueType === 'object' || valueType === 'function') {
+	            let id = this.fieldKeyIds.get(value);
+	            if (id === undefined) {
+	                id = ++this.fieldKeyId;
+	                this.fieldKeyIds.set(value, id);
+	            }
+	            return `${valueType}:#${id}`;
+	        }
+	        return `${valueType}:${String(value)}`;
+	    }
+	    resetCutState() {
+	        this.cutWaitPaste = false;
+	        this.activeCutState = null;
+	        this.cutCellRange = null;
+	        this.cutRanges = null;
+	        if (this.table.keyboardOptions?.showCopyCellBorder) {
+	            clearActiveCellRangeState(this.table);
+	        }
+	        if (this.clipboardCheckTimer) {
+	            clearTimeout(this.clipboardCheckTimer);
+	            this.clipboardCheckTimer = null;
 	        }
 	    }
 	    parsePastedData(pastedData) {
@@ -77917,6 +78976,13 @@
 	        });
 	        return values;
 	    }
+	    parsePlainTextPastedData(pastedData) {
+	        const rows = pastedData.replace(/\r\n|\r/g, '\n').split('\n');
+	        if (rows.length > 1 && rows[rows.length - 1] === '') {
+	            rows.pop();
+	        }
+	        return rows.map(rowCells => rowCells.split('\t'));
+	    }
 	    processCellValue(cell) {
 	        if (cell.includes('\n')) {
 	            cell = cell
@@ -81924,7 +82990,7 @@
 	        return TABLE_EVENT_TYPE;
 	    }
 	    options;
-	    version = "1.26.7";
+	    version = "1.26.8";
 	    pagination;
 	    id = `VTable${Date.now()}`;
 	    headerStyleCache;
@@ -83658,7 +84724,7 @@
 	        this.editorManager?.cancelEdit();
 	        this.options = options;
 	        this._hasAutoImageColumn = undefined;
-	        const { frozenColCount = 0, unfreezeAllOnExceedsMaxWidth, defaultRowHeight = 40, defaultHeaderRowHeight, defaultColWidth = 80, defaultHeaderColWidth = 80, keyboardOptions, eventOptions, rowSeriesNumber, enableCheckboxCascade, enableHeaderCheckboxCascade, columnResizeMode, rowResizeMode = 'none', resize, dragHeaderMode, dragOrder, showFrozenIcon, allowFrozenColCount, padding, hover, menu, select: click, pixelRatio, widthMode, heightMode, autoFillWidth, autoFillHeight, containerFit, widthAdaptiveMode, heightAdaptiveMode, customRender, renderChartAsync, renderChartAsyncBatchCount, canvasWidth, canvasHeight, contentOffsetX: translateX = 0, contentOffsetY: translateY = 0, overscrollBehavior, limitMinWidth, limitMinHeight } = options;
+	        const { frozenColCount = 0, unfreezeAllOnExceedsMaxWidth, defaultRowHeight = 40, defaultHeaderRowHeight, defaultColWidth = 80, defaultHeaderColWidth, keyboardOptions, eventOptions, rowSeriesNumber, enableCheckboxCascade, enableHeaderCheckboxCascade, columnResizeMode, rowResizeMode = 'none', resize, dragHeaderMode, dragOrder, showFrozenIcon, allowFrozenColCount, padding, hover, menu, select: click, pixelRatio, widthMode, heightMode, autoFillWidth, autoFillHeight, containerFit, widthAdaptiveMode, heightAdaptiveMode, customRender, renderChartAsync, renderChartAsyncBatchCount, canvasWidth, canvasHeight, contentOffsetX: translateX = 0, contentOffsetY: translateY = 0, overscrollBehavior, limitMinWidth, limitMinHeight } = options;
 	        const { groupConfig, groupBy, groupTitleFieldFormat, groupTitleCustomLayout, enableTreeStickCell } = options;
 	        if (pixelRatio && pixelRatio !== this.internalProps.pixelRatio) {
 	            this.internalProps.pixelRatio = pixelRatio;
@@ -88314,6 +89380,37 @@
 	        }
 	    }
 	}
+	function isSameRecordIndex(sourceRecordIndex, currentRecordIndex) {
+	    if (Array.isArray(sourceRecordIndex) || Array.isArray(currentRecordIndex)) {
+	        return (Array.isArray(sourceRecordIndex) &&
+	            Array.isArray(currentRecordIndex) &&
+	            sourceRecordIndex.length === currentRecordIndex.length &&
+	            sourceRecordIndex.every((value, index) => value === currentRecordIndex[index]));
+	    }
+	    return sourceRecordIndex === currentRecordIndex;
+	}
+	function isTargetCellSnapshotCurrent(table, snapshot) {
+	    if (table.isHeader(snapshot.col, snapshot.row) !== snapshot.isHeader) {
+	        return false;
+	    }
+	    if (snapshot.isHeader) {
+	        return true;
+	    }
+	    const recordShowIndex = table.getRecordShowIndexByCell(snapshot.col, snapshot.row);
+	    const recordIndex = recordShowIndex >= 0 ? table.dataSource.getIndexKey(recordShowIndex) : undefined;
+	    const { field } = table.internalProps.layoutMap.getBody(snapshot.col, snapshot.row);
+	    return isSameRecordIndex(snapshot.recordIndex, recordIndex) && snapshot.field === field;
+	}
+	function areTargetCellSnapshotsCurrent(table, snapshots) {
+	    for (let i = 0; i < snapshots.length; i++) {
+	        for (let j = 0; j < snapshots[i].length; j++) {
+	            if (!isTargetCellSnapshotCurrent(table, snapshots[i][j])) {
+	                return false;
+	            }
+	        }
+	    }
+	    return true;
+	}
 	function listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, table, noTriggerChangeCellValuesEvent) {
 	    if ((workOnEditableCell && table.isHasEditorDefine(col, row)) || workOnEditableCell === false) {
 	        const recordShowIndex = table.getRecordShowIndexByCell(col, row);
@@ -88405,12 +89502,13 @@
 	        table.scenegraph.updateNextFrame();
 	    }
 	}
-	async function listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, table, noTriggerChangeCellValuesEvent) {
+	async function listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, table, noTriggerChangeCellValuesEvent, shouldCancel) {
 	    const changedCellResults = [];
 	    let pasteColEnd = startCol;
 	    let pasteRowEnd = startRow;
 	    const beforeChangeValues = [];
 	    const oldValues = [];
+	    const targetSnapshots = [];
 	    let cellUpdateType;
 	    for (let i = 0; i < values.length; i++) {
 	        if (startRow + i > table.rowCount - 1) {
@@ -88419,20 +89517,64 @@
 	        const rowValues = values[i];
 	        const rawRowValues = [];
 	        const oldRowValues = [];
+	        const rowTargetSnapshots = [];
 	        beforeChangeValues.push(rawRowValues);
 	        oldValues.push(oldRowValues);
+	        targetSnapshots.push(rowTargetSnapshots);
 	        for (let j = 0; j < rowValues.length; j++) {
 	            if (startCol + j > table.colCount - 1) {
 	                break;
 	            }
+	            const col = startCol + j;
+	            const row = startRow + i;
 	            cellUpdateType = getCellUpdateType(startCol + j, startRow + i, table, cellUpdateType);
-	            const beforeChangeValue = table.getCellRawValue(startCol + j, startRow + i);
+	            const beforeChangeValue = table.getCellRawValue(col, row);
 	            rawRowValues.push(beforeChangeValue);
-	            const oldValue = table.getCellOriginValue(startCol + j, startRow + i);
+	            const oldValue = table.getCellOriginValue(col, row);
 	            oldRowValues.push(oldValue);
+	            const isHeader = table.isHeader(col, row);
+	            const recordShowIndex = table.getRecordShowIndexByCell(col, row);
+	            const recordIndex = recordShowIndex >= 0 ? table.dataSource.getIndexKey(recordShowIndex) : undefined;
+	            const { field } = table.internalProps.layoutMap.getBody(col, row);
+	            rowTargetSnapshots.push({ col, row, isHeader, recordIndex, field });
 	        }
 	    }
 	    const resultChangeValues = [];
+	    const preValidatedCellResults = shouldCancel && workOnEditableCell ? [] : null;
+	    if (preValidatedCellResults) {
+	        for (let i = 0; i < values.length; i++) {
+	            if (shouldCancel?.()) {
+	                return changedCellResults;
+	            }
+	            if (startRow + i > table.rowCount - 1) {
+	                break;
+	            }
+	            preValidatedCellResults[i] = [];
+	            const rowValues = values[i];
+	            for (let j = 0; j < rowValues.length; j++) {
+	                if (startCol + j > table.colCount - 1) {
+	                    break;
+	                }
+	                let isCanChange = false;
+	                if (table.isHasEditorDefine(startCol + j, startRow + i)) {
+	                    const editor = table.getEditor(startCol + j, startRow + i);
+	                    const oldValue = oldValues[i][j];
+	                    const value = rowValues[j];
+	                    const maybePromiseOrValue = editor?.validateValue?.(value, oldValue, { col: startCol + j, row: startRow + i }, table) ?? true;
+	                    const validateResult = isPromise(maybePromiseOrValue) ? await maybePromiseOrValue : maybePromiseOrValue;
+	                    if (shouldCancel?.()) {
+	                        return changedCellResults;
+	                    }
+	                    isCanChange =
+	                        validateResult === true || validateResult === 'validate-exit' || validateResult === 'validate-not-exit';
+	                }
+	                preValidatedCellResults[i][j] = isCanChange;
+	            }
+	        }
+	    }
+	    if (shouldCancel?.() || !areTargetCellSnapshotsCurrent(table, targetSnapshots)) {
+	        return changedCellResults;
+	    }
 	    for (let i = 0; i < values.length; i++) {
 	        if (startRow + i > table.rowCount - 1) {
 	            break;
@@ -88447,7 +89589,10 @@
 	            }
 	            thisRowPasteColEnd = startCol + j;
 	            let isCanChange = false;
-	            if (workOnEditableCell === false) {
+	            if (preValidatedCellResults) {
+	                isCanChange = preValidatedCellResults[i]?.[j] === true;
+	            }
+	            else if (workOnEditableCell === false) {
 	                isCanChange = true;
 	            }
 	            else {
@@ -88458,6 +89603,9 @@
 	                    const maybePromiseOrValue = editor?.validateValue?.(value, oldValue, { col: startCol + j, row: startRow + i }, table) ?? true;
 	                    if (isPromise(maybePromiseOrValue)) {
 	                        const validateResult = await maybePromiseOrValue;
+	                        if (shouldCancel?.()) {
+	                            return changedCellResults;
+	                        }
 	                        isCanChange =
 	                            validateResult === true || validateResult === 'validate-exit' || validateResult === 'validate-not-exit';
 	                    }
@@ -88481,7 +89629,10 @@
 	                    table.internalProps.layoutMap.updateColumnTitle(startCol + j, startRow + i, value);
 	                }
 	                else {
-	                    table.dataSource.changeFieldValue(value, recordShowIndex, field, startCol + j, startRow + i, table);
+	                    const changeResult = table.dataSource.changeFieldValue(value, recordShowIndex, field, startCol + j, startRow + i, table);
+	                    if (isPromise(changeResult)) {
+	                        await changeResult;
+	                    }
 	                }
 	                const changedValue = table.getCellOriginValue(startCol + j, startRow + i);
 	                if (oldValue !== changedValue && triggerEvent) {
@@ -89539,6 +90690,9 @@
 	        clearLayoutColumnState(column.children ?? column.columns);
 	    });
 	}
+	function isSameField(left, right) {
+	    return left === right || (Array.isArray(left) && Array.isArray(right) && arrayEqual(left, right));
+	}
 	class ListTable extends BaseTable {
 	    showHeader = true;
 	    listTreeStickCellPlugin;
@@ -90022,7 +91176,7 @@
 	        return this.dataSource.getTableIndex(recordIndex) + this.columnHeaderLevelCount;
 	    }
 	    getTableIndexByField(field) {
-	        const colObj = this.internalProps.layoutMap.columnObjects.find((col) => col.field === field);
+	        const colObj = this.internalProps.layoutMap.columnObjects.find((col) => isSameField(col.field, field));
 	        if (!colObj) {
 	            return -1;
 	        }
@@ -90336,7 +91490,7 @@
 	    }
 	    getCellRangeByField(field, index) {
 	        const { layoutMap } = this.internalProps;
-	        const colObj = layoutMap.columnObjects.find((col) => col.field === field);
+	        const colObj = layoutMap.columnObjects.find((col) => isSameField(col.field, field));
 	        if (colObj) {
 	            const layoutRange = layoutMap.getBodyLayoutRangeById(colObj.id);
 	            let startRow;
@@ -90500,7 +91654,7 @@
 	        if (field && columns && columns.length > 0) {
 	            for (let i = 0; i < columns.length; i++) {
 	                const header = columns[i];
-	                if (((fieldKey && fieldKey === header.fieldKey) || (!fieldKey && header.field === field)) &&
+	                if (((fieldKey && fieldKey === header.fieldKey) || (!fieldKey && isSameField(header.field, field))) &&
 	                    header.sort &&
 	                    typeof header.sort === 'function') {
 	                    return header.sort;
@@ -90529,7 +91683,7 @@
 	                if (this.internalProps.layoutMap.headerObjects.some(item => item.define.sort !== false)) {
 	                    this.dataSource.sort(normalizedSortState.map((item) => {
 	                        const sortFunc = this._getSortFuncFromHeaderOption(this.internalProps.columns, item.field);
-	                        this.internalProps.layoutMap.headerObjects.find((col) => col && col.field === item.field);
+	                        this.internalProps.layoutMap.headerObjects.find((col) => col && isSameField(col.field, item.field));
 	                        return {
 	                            field: item.field,
 	                            order: item.order,
@@ -90686,7 +91840,7 @@
 	                    if (this.internalProps.layoutMap.headerObjectsIncludeHided.some(item => item.define.sort !== false)) {
 	                        this.dataSource.sort(sortState.map((item) => {
 	                            const sortFunc = this._getSortFuncFromHeaderOption(undefined, item.field);
-	                            this.internalProps.layoutMap.headerObjectsIncludeHided.find((col) => col && col.field === item.field);
+	                            this.internalProps.layoutMap.headerObjectsIncludeHided.find((col) => col && isSameField(col.field, item.field));
 	                            return {
 	                                field: item.field,
 	                                order: item.order || 'asc',
@@ -90818,8 +91972,8 @@
 	    changeCellValue(col, row, value, workOnEditableCell = false, triggerEvent = true, noTriggerChangeCellValuesEvent) {
 	        return listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, this, noTriggerChangeCellValuesEvent);
 	    }
-	    changeCellValues(startCol, startRow, values, workOnEditableCell = false, triggerEvent = true, noTriggerChangeCellValuesEvent) {
-	        return listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, this, noTriggerChangeCellValuesEvent);
+	    changeCellValues(startCol, startRow, values, workOnEditableCell = false, triggerEvent = true, noTriggerChangeCellValuesEvent, shouldCancel) {
+	        return listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, this, noTriggerChangeCellValuesEvent, shouldCancel);
 	    }
 	    changeCellValuesByRanges(ranges, value, workOnEditableCell = false, triggerEvent = true, noTriggerChangeCellValuesEvent) {
 	        return listTableChangeCellValuesByRanges(ranges, value, workOnEditableCell, triggerEvent, this, noTriggerChangeCellValuesEvent);
@@ -90855,15 +92009,20 @@
 	        const records = this.dataSource.dataSourceObj?.records;
 	        let record;
 	        let oldValue;
-	        if (Array.isArray(records) && (typeof field === 'string' || typeof field === 'number')) {
+	        if (Array.isArray(records) && (typeof field === 'string' || typeof field === 'number' || Array.isArray(field))) {
 	            record = Array.isArray(recordIndex) ? getValueFromDeepArray(records, recordIndex) : records[recordIndex];
-	            oldValue = record?.[field];
+	            oldValue = getRecordFieldValue(record, field);
 	        }
 	        this.dataSource.changeFieldValueByRecordIndex(value, recordIndex, field, this);
+	        if (Array.isArray(records)) {
+	            record = Array.isArray(recordIndex) ? getValueFromDeepArray(records, recordIndex) : records[recordIndex];
+	        }
 	        if (!triggerEvent) {
 	            return;
 	        }
-	        const changedValue = record && (typeof field === 'string' || typeof field === 'number') ? record?.[field] : value;
+	        const changedValue = record && (typeof field === 'string' || typeof field === 'number' || Array.isArray(field))
+	            ? getRecordFieldValue(record, field)
+	            : value;
 	        if (oldValue !== changedValue) {
 	            const cellAddr = this.getCellAddrByFieldRecord(field, recordIndex);
 	            const changeValue = {
@@ -90901,13 +92060,18 @@
 	            const records = this.dataSource.dataSourceObj?.records;
 	            let record;
 	            let oldValue;
-	            if (Array.isArray(records) && (typeof field === 'string' || typeof field === 'number')) {
+	            if (Array.isArray(records) && (typeof field === 'string' || typeof field === 'number' || Array.isArray(field))) {
 	                record = Array.isArray(recordIndex) ? getValueFromDeepArray(records, recordIndex) : records[recordIndex];
-	                oldValue = record?.[field];
+	                oldValue = getRecordFieldValue(record, field);
 	            }
 	            this.dataSource.changeFieldValueByRecordIndex(value, recordIndex, field, this);
+	            if (Array.isArray(records)) {
+	                record = Array.isArray(recordIndex) ? getValueFromDeepArray(records, recordIndex) : records[recordIndex];
+	            }
 	            if (triggerEvent) {
-	                const changedValue = record && (typeof field === 'string' || typeof field === 'number') ? record?.[field] : value;
+	                const changedValue = record && (typeof field === 'string' || typeof field === 'number' || Array.isArray(field))
+	                    ? getRecordFieldValue(record, field)
+	                    : value;
 	                if (oldValue !== changedValue) {
 	                    const changeValue = {
 	                        col: (this.getCellAddrByFieldRecord(field, recordIndex)?.col ?? -1),
@@ -96570,6 +97734,7 @@
 	}
 
 	function createCellGroup(table, value, columnGroup, xOrigin, yOrigin, col, row, colWidth, cellWidth, cellHeight, padding, textAlign, textBaseline, mayHaveIcon, customElementsGroup, renderDefault, cellTheme, range, isAsync) {
+	    const isCornerCustomMergeContentCell = isCornerCustomMergeRange(range, table) && col === range.end.col && row === range.end.row;
 	    const headerStyle = table._getCellStyle(col, row);
 	    const functionalPadding = getFunctionalProp('padding', headerStyle, col, row, table);
 	    if (isValid$1(functionalPadding)) {
@@ -96603,7 +97768,7 @@
 	                cursor: cellTheme?.group?.cursor ?? undefined,
 	                lineDash: cellTheme?.group?.lineDash ?? undefined,
 	                lineCap: 'butt',
-	                clip: true,
+	                clip: !isCornerCustomMergeContentCell,
 	                cornerRadius: cellTheme.group.cornerRadius
 	            });
 	        }
@@ -96622,7 +97787,7 @@
 	            cursor: cellTheme?.group?.cursor ?? undefined,
 	            lineDash: cellTheme?.group?.lineDash ?? undefined,
 	            lineCap: 'butt',
-	            clip: true,
+	            clip: !isCornerCustomMergeContentCell,
 	            cornerRadius: cellTheme.group.cornerRadius
 	        });
 	        cellGroup.role = 'cell';
@@ -96633,6 +97798,12 @@
 	    if (customElementsGroup) {
 	        cellGroup.appendChild(customElementsGroup);
 	    }
+	    if (isCornerCustomMergeContentCell) {
+	        cellGroup.setAttributes({
+	            width: Math.max(cellGroup.attribute.width, customElementsGroup?.attribute.width ?? 0),
+	            height: Math.max(cellGroup.attribute.height, customElementsGroup?.attribute.height ?? 0)
+	        });
+	    }
 	    if (renderDefault) {
 	        const textStr = value;
 	        let icons;
@@ -99417,6 +100588,7 @@
 	                    (colHeader.indicatorKey
 	                        ? this.getIndicatorInfoByIndicatorKey(colHeader.indicatorKey)?.title ?? ''
 	                        : colHeader.value);
+	            colHeaderPath.dataValue = colHeader.dataValue;
 	            colHeaderPath.virtual = colHeader.virtual;
 	            colHeaderPath.role = colHeader.role;
 	            headerPaths.colHeaderPaths.push(colHeaderPath);
@@ -99431,6 +100603,7 @@
 	                        (rowHeader.indicatorKey
 	                            ? this.getIndicatorInfoByIndicatorKey(rowHeader.indicatorKey)?.title ?? ''
 	                            : rowHeader.value);
+	                rowHeaderPath.dataValue = rowHeader.dataValue;
 	                rowHeaderPath.virtual = rowHeader.virtual;
 	                rowHeaderPath.role = rowHeader.role;
 	                headerPaths.rowHeaderPaths.push(rowHeaderPath);
@@ -100078,10 +101251,14 @@
 	            const dimension = treeNodes[j];
 	            const isMatch = (!isValid$1(currentPath.indicatorKey) &&
 	                dimension.dimensionKey === currentPath.dimensionKey &&
-	                dimension.value === currentPath.value) ||
+	                (isValid$1(currentPath.dataValue)
+	                    ? (dimension.dataValue ?? dimension.value) === currentPath.dataValue
+	                    : dimension.value === currentPath.value)) ||
 	                (isValid$1(currentPath.indicatorKey) &&
 	                    dimension.indicatorKey === currentPath.indicatorKey &&
-	                    ((isValid$1(dimension.value) && isValid$1(currentPath.value) && currentPath.value === dimension.value) ||
+	                    ((isValid$1(currentPath.dataValue) &&
+	                        (dimension.dataValue ?? dimension.value) === currentPath.dataValue) ||
+	                        (isValid$1(dimension.value) && isValid$1(currentPath.value) && currentPath.value === dimension.value) ||
 	                        !isValid$1(dimension.value) ||
 	                        !isValid$1(currentPath.value)));
 	            if (isMatch) {
@@ -100232,7 +101409,9 @@
 	                const cellIDs = this.headerObjects
 	                    .filter((hd) => {
 	                    return ((hd?.field === rowDimension.dimensionKey || hd?.field === rowDimension.indicatorKey) &&
-	                        hd?.title === rowDimension.value);
+	                        (isValid$1(rowDimension.dataValue)
+	                            ? (hd.dataValue ?? hd.define?.dataValue ?? hd.title) === rowDimension.dataValue
+	                            : hd?.title === rowDimension.value));
 	                })
 	                    .map((hd) => {
 	                    return hd.id;
@@ -100242,15 +101421,19 @@
 	                });
 	                const findedCellIdPath = findedCellIdPaths.find(pathIds => {
 	                    const fullCellIds = this.findFullCellIds(pathIds);
+	                    const matchHeaderPath = (curHd, rowDimensionPath) => rowDimensionPath.dimensionKey === curHd.field &&
+	                        (isValid$1(rowDimensionPath.dataValue)
+	                            ? (curHd.dataValue ?? curHd.define?.dataValue ?? curHd.title) ===
+	                                rowDimensionPath.dataValue
+	                            : rowDimensionPath.value === curHd.title);
 	                    return (fullCellIds.length === rowHeaderPaths.length &&
-	                        fullCellIds.every(id => {
-	                            const curHd = this._headerObjectMap[id];
-	                            return rowHeaderPaths.find(rowDimensionPath => {
-	                                return rowDimensionPath.dimensionKey === curHd.field && rowDimensionPath.value === curHd.title;
-	                            });
-	                        }));
+	                        (rowHeaderPaths.some(rowDimensionPath => isValid$1(rowDimensionPath.dataValue))
+	                            ? fullCellIds.every((id, index) => matchHeaderPath(this._headerObjectMap[id], rowHeaderPaths[index]))
+	                            : fullCellIds.every(id => rowHeaderPaths.some(rowDimensionPath => matchHeaderPath(this._headerObjectMap[id], rowDimensionPath)))));
 	                });
-	                row = this._rowHeaderCellIds.indexOf(findedCellIdPath) + this.columnHeaderLevelCount;
+	                if (findedCellIdPath) {
+	                    row = this._rowHeaderCellIds.indexOf(findedCellIdPath) + this.columnHeaderLevelCount;
+	                }
 	            }
 	            else {
 	                rowDimensionFinded = this.matchDimensionPath(rowHeaderPaths, this.rowTree, needLowestLevel_rowPaths, true);
@@ -100261,7 +101444,7 @@
 	                return undefined;
 	            }
 	        }
-	        if (rowDimensionFinded || forceBody) {
+	        if (rowDimensionFinded || (forceBody && !isValid$1(row))) {
 	            row = this.columnHeaderLevelCount;
 	            const { startInTotal, afterSpanLevel } = rowDimensionFinded ?? defaultDimension;
 	            row += startInTotal ?? 0;
@@ -100770,7 +101953,7 @@
 	                collectedValues =
 	                    this.dataset.collectedValues[key]?.[path
 	                        .map(pathObj => {
-	                        return pathObj.value;
+	                        return pathObj.dataValue ?? pathObj.value;
 	                    })
 	                        .join(this.dataset.stringJoinChar)];
 	                break;
@@ -100795,7 +101978,7 @@
 	                collectedValues =
 	                    this.dataset.collectedValues[key]?.[path
 	                        .map(pathObj => {
-	                        return pathObj.value;
+	                        return pathObj.dataValue ?? pathObj.value;
 	                    })
 	                        .join(this.dataset.stringJoinChar)];
 	                break;
@@ -100854,7 +102037,7 @@
 	        if (path.colHeaderPaths.length) {
 	            path.colHeaderPaths.forEach(path => {
 	                if (path.dimensionKey) {
-	                    colKey.push(path.value);
+	                    colKey.push(path.dataValue ?? path.value);
 	                }
 	            });
 	        }
@@ -100866,7 +102049,7 @@
 	        if (path.rowHeaderPaths.length) {
 	            path.rowHeaderPaths.forEach(path => {
 	                if (path.dimensionKey) {
-	                    rowKey.push(path.value);
+	                    rowKey.push(path.dataValue ?? path.value);
 	                }
 	            });
 	        }
@@ -101543,6 +102726,8 @@
 	    totals;
 	    indicatorStatistics = [];
 	    stringJoinChar = String.fromCharCode(0);
+	    groupedGrandTotalKey = String.fromCharCode(1) + 'vtable_grouped_grand_total';
+	    groupedGrandTotalSubtotalKey = String.fromCharCode(1) + 'vtable_grouped_grand_total_subtotal';
 	    rowsIsTotal = [];
 	    colsIsTotal = [];
 	    colGrandTotalLabel;
@@ -101678,12 +102863,12 @@
 	                        return this.rowsHasValue[index];
 	                    }), this.indicatorsAsCol ? undefined : this.indicators, this.totals?.row?.showGrandTotals ||
 	                        (!this.indicatorsAsCol && this.columns.length === 0) ||
-	                        (this.indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.totals?.row?.showGrandTotalsOnTop ?? false);
+	                        (this.indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.totals?.row?.showGrandTotalsOnTop ?? false, this.totals?.row?.grandTotalDimensions, this.rowSubTotalLabel, this.totals?.row?.showSubTotalsOnTop ?? false, this.rows);
 	                }
 	                else {
 	                    this.rowHeaderTree = this.ArrToTree(this.rowKeys, this.rows.filter((key, index) => {
 	                        return this.rowsHasValue[index];
-	                    }), this.indicatorsAsCol ? undefined : this.indicators, this.rowsIsTotal, this.totals?.row?.showGrandTotals || (this.indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.rowSubTotalLabel, this.totals?.row?.showGrandTotalsOnTop ?? false, this.totals?.row?.showSubTotalsOnTop ?? false);
+	                    }), this.indicatorsAsCol ? undefined : this.indicators, this.rowsIsTotal, this.totals?.row?.showGrandTotals || (this.indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.rowSubTotalLabel, this.totals?.row?.showGrandTotalsOnTop ?? false, this.totals?.row?.showSubTotalsOnTop ?? false, this.totals?.row?.grandTotalDimensions, true, this.rows);
 	                }
 	            }
 	            if (this.customColTree) {
@@ -101692,7 +102877,7 @@
 	            else {
 	                this.colHeaderTree = this.ArrToTree(this.colKeys, this.columns.filter((key, index) => {
 	                    return this.columnsHasValue[index];
-	                }), this.indicatorsAsCol ? this.indicators : undefined, this.colsIsTotal, this.totals?.column?.showGrandTotals || (!this.indicatorsAsCol && this.columns.length === 0), this.colGrandTotalLabel, this.colSubTotalLabel, this.totals?.column?.showGrandTotalsOnLeft ?? false, this.totals?.column?.showSubTotalsOnLeft ?? false);
+	                }), this.indicatorsAsCol ? this.indicators : undefined, this.colsIsTotal, this.totals?.column?.showGrandTotals || (!this.indicatorsAsCol && this.columns.length === 0), this.colGrandTotalLabel, this.colSubTotalLabel, this.totals?.column?.showGrandTotalsOnLeft ?? false, this.totals?.column?.showSubTotalsOnLeft ?? false, this.totals?.column?.grandTotalDimensions, false, this.columns);
 	            }
 	            typeof window !== 'undefined' ? window.performance.now() : 0;
 	            if (this.dataConfig?.isPivotChart) {
@@ -101799,6 +102984,9 @@
 	        if ((this.filterRules?.length ?? 0) >= 1) {
 	            isNeedFilter = true;
 	        }
+	        const records = (Array.isArray(this.records) ? this.records : Object.values(this.records).flat()).filter(record => !isNeedFilter || this.filterRecord(record));
+	        this.rowsHasValue = this.rows.map(row => records.some(record => record && row in record));
+	        this.columnsHasValue = this.columns.map(column => records.some(record => record && column in record));
 	        if (Array.isArray(this.records)) {
 	            if (!this.filteredRecords) {
 	                this.filteredRecords = [];
@@ -101851,77 +103039,94 @@
 	        }
 	        return isReserved;
 	    }
-	    processRecord(record, assignedIndicatorKey) {
-	        this.derivedFieldRules?.forEach((derivedFieldRule, i) => {
-	            if (derivedFieldRule.fieldName && derivedFieldRule.derivedFunc) {
-	                record[derivedFieldRule.fieldName] = derivedFieldRule.derivedFunc(record);
+	    collectValue(field, collectKeys, record) {
+	        if (!this.collectedValues[field]) {
+	            this.collectedValues[field] = {};
+	        }
+	        if (!this.collectedValues[field][collectKeys]) {
+	            if (this.collectValuesBy[field].sumBy) {
+	                this.collectedValues[field][collectKeys] = {};
 	            }
-	        });
-	        for (const field in this.collectValuesBy) {
-	            if (isValid$1(record[field])) {
-	                if (!this.collectedValues[field]) {
-	                    this.collectedValues[field] = {};
-	                }
-	                const collectKeys = this.collectValuesBy[field].by.map(byField => record[byField]).join(this.stringJoinChar);
-	                if (!this.collectedValues[field][collectKeys]) {
-	                    if (this.collectValuesBy[field].sumBy) {
-	                        this.collectedValues[field][collectKeys] = {};
-	                    }
-	                    else if (this.collectValuesBy[field].range) {
-	                        this.collectedValues[field][collectKeys] = {
-	                            min: Number.MAX_SAFE_INTEGER,
-	                            max: Number.MIN_SAFE_INTEGER
-	                        };
-	                    }
-	                    else {
-	                        this.collectedValues[field][collectKeys] = [];
-	                    }
-	                }
-	                if (this.collectValuesBy[field].sumBy) {
-	                    const sumByKeys = this.collectValuesBy[field].sumBy
-	                        ?.map(byField => record[byField])
-	                        .join(this.stringJoinChar);
-	                    if (!this.collectedValues[field][collectKeys][sumByKeys]) {
-	                        this.collectedValues[field][collectKeys][sumByKeys] = new registeredAggregators[AggregationType.SUM]({
-	                            key: field,
-	                            field: field,
-	                            isRecord: undefined,
-	                            needSplitPositiveAndNegative: this.needSplitPositiveAndNegative
-	                        });
-	                    }
-	                    this.collectedValues[field][collectKeys][sumByKeys].push(record);
-	                }
-	                else if (this.collectValuesBy[field].range) {
-	                    const fieldRange = this.collectedValues[field][collectKeys];
-	                    let max = Math.max(record[field], fieldRange.max);
-	                    let min = Math.min(record[field], fieldRange.min);
-	                    if (this.collectValuesBy[field].considerFields) {
-	                        for (const considerField of this.collectValuesBy[field].considerFields) {
-	                            if (record[considerField]) {
-	                                if (typeof record[considerField] === 'number') {
-	                                    max = Math.max(record[considerField], max);
-	                                    min = Math.min(record[considerField], min);
-	                                }
-	                                else if (Array.isArray(record[considerField])) {
-	                                    max = Math.max(...record[considerField], max);
-	                                    min = Math.min(...record[considerField], min);
-	                                }
-	                            }
+	            else if (this.collectValuesBy[field].range) {
+	                this.collectedValues[field][collectKeys] = {
+	                    min: Number.MAX_SAFE_INTEGER,
+	                    max: Number.MIN_SAFE_INTEGER
+	                };
+	            }
+	            else {
+	                this.collectedValues[field][collectKeys] = [];
+	            }
+	        }
+	        if (this.collectValuesBy[field].sumBy) {
+	            const sumByKeys = this.collectValuesBy[field].sumBy
+	                ?.map(byField => record[byField])
+	                .join(this.stringJoinChar);
+	            if (!this.collectedValues[field][collectKeys][sumByKeys]) {
+	                this.collectedValues[field][collectKeys][sumByKeys] = new registeredAggregators[AggregationType.SUM]({
+	                    key: field,
+	                    field,
+	                    isRecord: undefined,
+	                    needSplitPositiveAndNegative: this.needSplitPositiveAndNegative
+	                });
+	            }
+	            this.collectedValues[field][collectKeys][sumByKeys].push(record);
+	        }
+	        else if (this.collectValuesBy[field].range) {
+	            const fieldRange = this.collectedValues[field][collectKeys];
+	            let max = Math.max(record[field], fieldRange.max);
+	            let min = Math.min(record[field], fieldRange.min);
+	            if (this.collectValuesBy[field].considerFields) {
+	                for (const considerField of this.collectValuesBy[field].considerFields) {
+	                    if (record[considerField]) {
+	                        if (typeof record[considerField] === 'number') {
+	                            max = Math.max(record[considerField], max);
+	                            min = Math.min(record[considerField], min);
+	                        }
+	                        else if (Array.isArray(record[considerField])) {
+	                            max = Math.max(...record[considerField], max);
+	                            min = Math.min(...record[considerField], min);
 	                        }
-	                    }
-	                    if (!isNaN(max)) {
-	                        fieldRange.max = max;
-	                        fieldRange.min = min;
-	                    }
-	                }
-	                else {
-	                    const fieldRange = this.collectedValues[field][collectKeys];
-	                    if (fieldRange.indexOf(record[field]) === -1) {
-	                        fieldRange.push(record[field]);
 	                    }
 	                }
 	            }
+	            if (!isNaN(max)) {
+	                fieldRange.max = max;
+	                fieldRange.min = min;
+	            }
+	        }
+	        else {
+	            const fieldValues = this.collectedValues[field][collectKeys];
+	            if (fieldValues.indexOf(record[field]) === -1) {
+	                fieldValues.push(record[field]);
+	            }
 	        }
+	    }
+	    getGroupedCollectedValueKeys(by, record) {
+	        if (!this.dataConfig?.isPivotChart) {
+	            return [];
+	        }
+	        const keys = new Set();
+	        [
+	            { dimensions: this.rows, totals: this.totals?.row },
+	            { dimensions: this.columns, totals: this.totals?.column }
+	        ].forEach(({ dimensions, totals }) => {
+	            if (!totals?.showGrandTotals) {
+	                return;
+	            }
+	            const dimensionIndexes = this.getGrandTotalDimensionIndexes(dimensions, totals.grandTotalDimensions);
+	            if (dimensionIndexes.length && dimensionIndexes.every(index => by.indexOf(dimensions[index]) !== -1)) {
+	                keys.add(join([this.groupedGrandTotalKey, ...dimensionIndexes.map(index => record[dimensions[index]])], this.stringJoinChar));
+	                keys.add(join([this.groupedGrandTotalKey, this.groupedGrandTotalSubtotalKey], this.stringJoinChar));
+	            }
+	        });
+	        return Array.from(keys);
+	    }
+	    processRecord(record, assignedIndicatorKey) {
+	        this.derivedFieldRules?.forEach((derivedFieldRule, i) => {
+	            if (derivedFieldRule.fieldName && derivedFieldRule.derivedFunc) {
+	                record[derivedFieldRule.fieldName] = derivedFieldRule.derivedFunc(record);
+	            }
+	        });
 	        let isToTalRecord = false;
 	        const colKeys = [];
 	        const rowKeys = [];
@@ -101951,29 +103156,43 @@
 	        else {
 	            const rowKey = [];
 	            rowKeys.push({ rowKey, indicatorKey: assignedIndicatorKey });
-	            for (let l = 0, len1 = this.rows.length; l < len1; l++) {
-	                const rowAttr = this.rows[l];
-	                if (rowAttr in record) {
-	                    this.rowsHasValue[l] = true;
-	                    rowKey.push(record[rowAttr]);
-	                }
-	                else if (rowAttr !== IndicatorDimensionKeyPlaceholder) {
-	                    if (this.dataConfig?.totals?.row?.showGrandTotals &&
-	                        l === 0 &&
-	                        !this.rows.find((rk) => {
-	                            return rk in record;
-	                        })) {
-	                        rowKey.push(this.rowGrandTotalLabel);
-	                        isToTalRecord = true;
-	                        break;
-	                    }
-	                    else if (this.dataConfig?.totals?.row?.subTotalsDimensions &&
-	                        this.dataConfig?.totals?.row?.subTotalsDimensions.indexOf(this.rows[l - 1]) >= 0) {
-	                        if (this.rowHierarchyType !== 'tree') {
-	                            rowKey.push(this.rowSubTotalLabel);
+	            const customGroupedGrandTotalKey = this.dataConfig?.totals?.row?.showGrandTotals && this.rowsHasValue[0]
+	                ? this.getCustomGroupedGrandTotalKey(record, this.rows, this.dataConfig?.totals?.row?.grandTotalDimensions)
+	                : undefined;
+	            if (customGroupedGrandTotalKey) {
+	                rowKey.push(...customGroupedGrandTotalKey);
+	                isToTalRecord = true;
+	            }
+	            else {
+	                for (let l = 0, len1 = this.rows.length; l < len1; l++) {
+	                    const rowAttr = this.rows[l];
+	                    if (rowAttr in record) {
+	                        this.rowsHasValue[l] = true;
+	                        rowKey.push(record[rowAttr]);
+	                    }
+	                    else if (rowAttr !== IndicatorDimensionKeyPlaceholder) {
+	                        if (this.dataConfig?.totals?.row?.showGrandTotals &&
+	                            l === 0 &&
+	                            !this.rows.find((rk) => {
+	                                return rk in record;
+	                            })) {
+	                            if (this.getGrandTotalDimensionIndexes(this.rows, this.dataConfig.totals.row.grandTotalDimensions).length) {
+	                                rowKey.push(this.groupedGrandTotalKey, this.groupedGrandTotalSubtotalKey);
+	                            }
+	                            else {
+	                                rowKey.push(this.rowGrandTotalLabel);
+	                            }
+	                            isToTalRecord = true;
+	                            break;
+	                        }
+	                        else if (this.dataConfig?.totals?.row?.subTotalsDimensions &&
+	                            this.dataConfig?.totals?.row?.subTotalsDimensions.indexOf(this.rows[l - 1]) >= 0) {
+	                            if (this.rowHierarchyType !== 'tree') {
+	                                rowKey.push(this.rowSubTotalLabel);
+	                            }
+	                            isToTalRecord = true;
+	                            break;
 	                        }
-	                        isToTalRecord = true;
-	                        break;
 	                    }
 	                }
 	            }
@@ -102004,31 +103223,57 @@
 	        else {
 	            const colKey = [];
 	            colKeys.push({ colKey, indicatorKey: assignedIndicatorKey });
-	            for (let n = 0, len2 = this.columns.length; n < len2; n++) {
-	                const colAttr = this.columns[n];
-	                if (colAttr in record) {
-	                    this.columnsHasValue[n] = true;
-	                    colKey.push(record[colAttr]);
-	                }
-	                else if (colAttr !== IndicatorDimensionKeyPlaceholder) {
-	                    if (this.dataConfig?.totals?.column?.showGrandTotals &&
-	                        n === 0 &&
-	                        !this.columns.find((ck) => {
-	                            return ck in record;
-	                        })) {
-	                        colKey.push(this.colGrandTotalLabel);
-	                        isToTalRecord = true;
-	                        break;
-	                    }
-	                    else if (this.dataConfig?.totals?.column?.subTotalsDimensions &&
-	                        this.dataConfig?.totals?.column?.subTotalsDimensions.indexOf(this.columns[n - 1]) >= 0) {
-	                        colKey.push(this.colSubTotalLabel);
-	                        isToTalRecord = true;
-	                        break;
+	            const customGroupedGrandTotalKey = this.dataConfig?.totals?.column?.showGrandTotals && this.columnsHasValue[0]
+	                ? this.getCustomGroupedGrandTotalKey(record, this.columns, this.dataConfig?.totals?.column?.grandTotalDimensions)
+	                : undefined;
+	            if (customGroupedGrandTotalKey) {
+	                colKey.push(...customGroupedGrandTotalKey);
+	                isToTalRecord = true;
+	            }
+	            else {
+	                for (let n = 0, len2 = this.columns.length; n < len2; n++) {
+	                    const colAttr = this.columns[n];
+	                    if (colAttr in record) {
+	                        this.columnsHasValue[n] = true;
+	                        colKey.push(record[colAttr]);
+	                    }
+	                    else if (colAttr !== IndicatorDimensionKeyPlaceholder) {
+	                        if (this.dataConfig?.totals?.column?.showGrandTotals &&
+	                            n === 0 &&
+	                            !this.columns.find((ck) => {
+	                                return ck in record;
+	                            })) {
+	                            if (this.getGrandTotalDimensionIndexes(this.columns, this.dataConfig.totals.column.grandTotalDimensions)
+	                                .length) {
+	                                colKey.push(this.groupedGrandTotalKey, this.groupedGrandTotalSubtotalKey);
+	                            }
+	                            else {
+	                                colKey.push(this.colGrandTotalLabel);
+	                            }
+	                            isToTalRecord = true;
+	                            break;
+	                        }
+	                        else if (this.dataConfig?.totals?.column?.subTotalsDimensions &&
+	                            this.dataConfig?.totals?.column?.subTotalsDimensions.indexOf(this.columns[n - 1]) >= 0) {
+	                            colKey.push(this.colSubTotalLabel);
+	                            isToTalRecord = true;
+	                            break;
+	                        }
 	                    }
 	                }
 	            }
 	        }
+	        if (!isToTalRecord) {
+	            for (const field in this.collectValuesBy) {
+	                if (isValid$1(record[field])) {
+	                    const collectKeys = this.collectValuesBy[field].by.map(byField => record[byField]).join(this.stringJoinChar);
+	                    this.collectValue(field, collectKeys, record);
+	                    this.getGroupedCollectedValueKeys(this.collectValuesBy[field].by, record).forEach(groupedCollectKeys => {
+	                        this.collectValue(field, groupedCollectKeys, record);
+	                    });
+	                }
+	            }
+	        }
 	        for (let row_i = 0; row_i < rowKeys.length; row_i++) {
 	            const rowKey = rowKeys[row_i].rowKey;
 	            let assignedIndicatorKey_value;
@@ -102223,18 +103468,18 @@
 	                    return this.rowsHasValue[index];
 	                }), this.indicatorsAsCol ? undefined : this.indicators, this.totals?.row?.showGrandTotals ||
 	                    (!this.indicatorsAsCol && this.columns.length === 0) ||
-	                    (this.indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.totals?.row?.showGrandTotalsOnTop ?? false);
+	                    (this.indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.totals?.row?.showGrandTotalsOnTop ?? false, this.totals?.row?.grandTotalDimensions, this.rowSubTotalLabel, this.totals?.row?.showSubTotalsOnTop ?? false, this.rows);
 	            }
 	            else {
 	                this.rowHeaderTree = this.ArrToTree(this.rowKeys, this.rows.filter((key, index) => {
 	                    return this.rowsHasValue[index];
-	                }), this.indicatorsAsCol ? undefined : this.indicators, this.rowsIsTotal, this.totals?.row?.showGrandTotals || (this.indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.rowSubTotalLabel, this.totals?.row?.showGrandTotalsOnTop ?? false, this.totals?.row?.showSubTotalsOnTop ?? false);
+	                }), this.indicatorsAsCol ? undefined : this.indicators, this.rowsIsTotal, this.totals?.row?.showGrandTotals || (this.indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.rowSubTotalLabel, this.totals?.row?.showGrandTotalsOnTop ?? false, this.totals?.row?.showSubTotalsOnTop ?? false, this.totals?.row?.grandTotalDimensions, true, this.rows);
 	            }
 	        }
 	        if (!this.customColTree) {
 	            this.colHeaderTree = this.ArrToTree(this.colKeys, this.columns.filter((key, index) => {
 	                return this.columnsHasValue[index];
-	            }), this.indicatorsAsCol ? this.indicators : undefined, this.colsIsTotal, this.totals?.column?.showGrandTotals || (!this.indicatorsAsCol && this.columns.length === 0), this.colGrandTotalLabel, this.colSubTotalLabel, this.totals?.column?.showGrandTotalsOnLeft ?? false, this.totals?.column?.showSubTotalsOnLeft ?? false);
+	            }), this.indicatorsAsCol ? this.indicators : undefined, this.colsIsTotal, this.totals?.column?.showGrandTotals || (!this.indicatorsAsCol && this.columns.length === 0), this.colGrandTotalLabel, this.colSubTotalLabel, this.totals?.column?.showGrandTotalsOnLeft ?? false, this.totals?.column?.showSubTotalsOnLeft ?? false, this.totals?.column?.grandTotalDimensions, false, this.columns);
 	        }
 	    }
 	    updateFilterRules(filterRules, isResetTree = false) {
@@ -102296,7 +103541,7 @@
 	                });
 	            }
 	            if (rowKey.length < this.rows.length && this.rowHierarchyType === 'grid-tree') {
-	                if (rowKey[0] === this.rowGrandTotalLabel) ;
+	                if (rowKey[0] === this.rowGrandTotalLabel || rowKey[0] === this.groupedGrandTotalKey) ;
 	                else if (((this.totals?.row?.subTotalsDimensions &&
 	                    this.totals?.row?.subTotalsDimensions?.length >= 1 &&
 	                    this.totals.row.subTotalsDimensions.find((dimension) => dimension === rowDimensionKey)) ||
@@ -102319,7 +103564,7 @@
 	                });
 	            }
 	            if (colKey.length < this.columns.length && this.columnHierarchyType === 'grid-tree') {
-	                if (colKey[0] === this.colGrandTotalLabel) ;
+	                if (colKey[0] === this.colGrandTotalLabel || colKey[0] === this.groupedGrandTotalKey) ;
 	                else if (((this.totals?.column?.subTotalsDimensions &&
 	                    this.totals?.column?.subTotalsDimensions?.length >= 1 &&
 	                    this.totals.column.subTotalsDimensions.find((dimension) => dimension === colDimensionKey)) ||
@@ -102330,6 +103575,28 @@
 	            }
 	            flatColKey = join(colKey, this.stringJoinChar);
 	        }
+	        if (Array.isArray(rowKey) &&
+	            rowKey[0] === this.rowGrandTotalLabel &&
+	            !this.tree[flatRowKey] &&
+	            this.getGrandTotalDimensionIndexes(this.rows.filter((_, index) => this.rowsHasValue[index]), this.totals?.row?.grandTotalDimensions, this.rows).length) {
+	            const internalRowKey = rowKey.slice();
+	            internalRowKey[0] = this.groupedGrandTotalKey;
+	            if (internalRowKey.length === 2 && internalRowKey[1] === this.rowSubTotalLabel) {
+	                internalRowKey[1] = this.groupedGrandTotalSubtotalKey;
+	            }
+	            flatRowKey = join(internalRowKey, this.stringJoinChar);
+	        }
+	        if (Array.isArray(colKey) &&
+	            colKey[0] === this.colGrandTotalLabel &&
+	            !this.tree[flatRowKey]?.[flatColKey] &&
+	            this.getGrandTotalDimensionIndexes(this.columns.filter((_, index) => this.columnsHasValue[index]), this.totals?.column?.grandTotalDimensions, this.columns).length) {
+	            const internalColKey = colKey.slice();
+	            internalColKey[0] = this.groupedGrandTotalKey;
+	            if (internalColKey.length === 2 && internalColKey[1] === this.colSubTotalLabel) {
+	                internalColKey[1] = this.groupedGrandTotalSubtotalKey;
+	            }
+	            flatColKey = join(internalColKey, this.stringJoinChar);
+	        }
 	        const agg = this.tree[flatRowKey]?.[flatColKey]?.[indicatorIndex];
 	        if (considerChangedValue && isValid$1(this.changedTree[flatRowKey]?.[flatColKey]?.[indicatorIndex])) {
 	            const changeValue = this.changedTree[flatRowKey][flatColKey][indicatorIndex];
@@ -102408,7 +103675,7 @@
 	            this.colKeys.sort(sortfun);
 	        }
 	    }
-	    arrSort(fieldArr, isRow) {
+	    arrSort(fieldArr, isRow, pathPrefix) {
 	        let field;
 	        const that = this;
 	        const sortersArr = function (_this) {
@@ -102440,20 +103707,24 @@
 	                    let bChanged = b;
 	                    if (sorter.fieldIndex < fieldArr.length - 1) {
 	                        aChanged = a.slice(0, sorter.fieldIndex + 1);
-	                        if (that.rowHierarchyType === 'grid' && isRow) {
+	                        if (!pathPrefix?.length && that.rowHierarchyType === 'grid' && isRow) {
 	                            aChanged.push(that.rowSubTotalLabel);
 	                        }
-	                        else if (!isRow) {
+	                        else if (!pathPrefix?.length && !isRow) {
 	                            aChanged.push(that.colSubTotalLabel);
 	                        }
 	                        bChanged = b.slice(0, sorter.fieldIndex + 1);
-	                        if (that.rowHierarchyType === 'grid' && isRow) {
+	                        if (!pathPrefix?.length && that.rowHierarchyType === 'grid' && isRow) {
 	                            bChanged.push(that.rowSubTotalLabel);
 	                        }
-	                        else if (!isRow) {
+	                        else if (!pathPrefix?.length && !isRow) {
 	                            bChanged.push(that.colSubTotalLabel);
 	                        }
 	                    }
+	                    if (pathPrefix?.length) {
+	                        aChanged = [...pathPrefix, ...aChanged];
+	                        bChanged = [...pathPrefix, ...bChanged];
+	                    }
 	                    comparison = sorter.func(aChanged, bChanged, sorter.sortRule?.sortType);
 	                }
 	                else {
@@ -102474,12 +103745,14 @@
 	                    if (that.rowHierarchyType === 'grid' &&
 	                        rowKey.length < that.rows.length &&
 	                        rowKey[rowKey.length - 1] !== that.rowSubTotalLabel &&
-	                        rowKey[rowKey.length - 1] !== that.rowGrandTotalLabel) {
+	                        rowKey[rowKey.length - 1] !== that.rowGrandTotalLabel &&
+	                        rowKey[0] !== that.groupedGrandTotalKey) {
 	                        rowKey.push(that.rowSubTotalLabel);
 	                    }
 	                    if (colKey.length < that.columns.length &&
 	                        colKey[colKey.length - 1] !== that.colSubTotalLabel &&
-	                        colKey[colKey.length - 1] !== that.colGrandTotalLabel) {
+	                        colKey[colKey.length - 1] !== that.colGrandTotalLabel &&
+	                        colKey[0] !== that.groupedGrandTotalKey) {
 	                        colKey.push(that.colSubTotalLabel);
 	                    }
 	                    return that.getAggregator(rowKey, colKey, sortRule.sortByIndicator).value();
@@ -102588,56 +103861,63 @@
 	                    }
 	                }
 	            }
-	            if (that.totals?.column?.showGrandTotals || this.rows.length === 0) {
-	                const flatColTotalKey = that.colGrandTotalLabel;
-	                if (this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey]) {
-	                    this.tree[flatRowKey][flatColTotalKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey];
-	                    return;
-	                }
-	                if (!this.tree[flatRowKey][flatColTotalKey]) {
-	                    this.tree[flatRowKey][flatColTotalKey] = [];
-	                }
-	                const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
-	                for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
-	                    if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
-	                        const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
-	                        if (!this.tree[flatRowKey]?.[flatColTotalKey]?.[i]) {
-	                            this.tree[flatRowKey][flatColTotalKey][i] = new registeredAggregators[AggregationType.RECALCULATE]({
-	                                key: toComputeIndicatorKeys[i],
-	                                field: toComputeIndicatorKeys[i],
-	                                isRecord: true,
-	                                formatFun: this.indicators?.find((indicator) => {
-	                                    if (typeof indicator !== 'string') {
-	                                        return indicator.indicatorKey === toComputeIndicatorKeys[i];
-	                                    }
-	                                    return false;
-	                                })?.format,
-	                                calculateFun: calculatedFieldRule?.calculateFun,
-	                                dependAggregators: this.tree[flatRowKey][flatColTotalKey],
-	                                dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
-	                            });
-	                        }
-	                        if (flatColTotalKey !== flatColKey) {
-	                            this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
-	                        }
+	            if ((that.totals?.column?.showGrandTotals || this.rows.length === 0) && colKey[0] !== this.groupedGrandTotalKey) {
+	                const flatColTotalKeys = this.getGrandTotalKeys(colKey, that.columns.filter((_, index) => that.columnsHasValue[index]), that.totals?.column?.grandTotalDimensions, that.colGrandTotalLabel, that.columns);
+	                for (const flatColTotalKey of flatColTotalKeys) {
+	                    if (this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey]) {
+	                        this.tree[flatRowKey][flatColTotalKey] = this.totalRecordsTree?.[flatRowKey]?.[flatColTotalKey];
+	                        continue;
 	                    }
-	                    else {
-	                        if (!this.tree[flatRowKey][flatColTotalKey][i]) {
-	                            const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
-	                            this.tree[flatRowKey][flatColTotalKey][i] = new registeredAggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
-	                                key: toComputeIndicatorKeys[i],
-	                                field: aggRule?.field ?? toComputeIndicatorKeys[i],
-	                                formatFun: aggRule?.formatFun ??
-	                                    this.indicators?.find((indicator) => {
+	                    if (!this.tree[flatRowKey][flatColTotalKey]) {
+	                        this.tree[flatRowKey][flatColTotalKey] = [];
+	                    }
+	                    const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
+	                    for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
+	                        if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
+	                            const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
+	                            if (!this.tree[flatRowKey]?.[flatColTotalKey]?.[i]) {
+	                                this.tree[flatRowKey][flatColTotalKey][i] = new registeredAggregators[AggregationType.RECALCULATE]({
+	                                    key: toComputeIndicatorKeys[i],
+	                                    field: toComputeIndicatorKeys[i],
+	                                    isRecord: true,
+	                                    formatFun: this.indicators?.find((indicator) => {
 	                                        if (typeof indicator !== 'string') {
 	                                            return indicator.indicatorKey === toComputeIndicatorKeys[i];
 	                                        }
 	                                        return false;
-	                                    })?.format
-	                            });
+	                                    })?.format,
+	                                    calculateFun: calculatedFieldRule?.calculateFun,
+	                                    dependAggregators: this.tree[flatRowKey][flatColTotalKey],
+	                                    dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
+	                                });
+	                            }
+	                            if (flatColTotalKey !== flatColKey) {
+	                                this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
+	                            }
 	                        }
-	                        if (flatColTotalKey !== flatColKey) {
-	                            this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
+	                        else {
+	                            if (!this.tree[flatRowKey][flatColTotalKey][i]) {
+	                                const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
+	                                this.tree[flatRowKey][flatColTotalKey][i] = new registeredAggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
+	                                    key: toComputeIndicatorKeys[i],
+	                                    field: aggRule?.field ?? toComputeIndicatorKeys[i],
+	                                    aggregationFun: aggRule?.aggregationFun,
+	                                    formatFun: aggRule?.formatFun ??
+	                                        this.indicators?.find((indicator) => {
+	                                            if (typeof indicator !== 'string') {
+	                                                return indicator.indicatorKey === toComputeIndicatorKeys[i];
+	                                            }
+	                                            return false;
+	                                        })?.format
+	                                });
+	                                if (this.tree[flatRowKey][flatColTotalKey][i] instanceof CustomAggregator &&
+	                                    flatColTotalKey.startsWith(this.groupedGrandTotalKey)) {
+	                                    this.tree[flatRowKey][flatColTotalKey][i].recalculateFromChildren = true;
+	                                }
+	                            }
+	                            if (flatColTotalKey !== flatColKey) {
+	                                this.tree[flatRowKey][flatColTotalKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
+	                            }
 	                        }
 	                    }
 	                }
@@ -102719,52 +103999,60 @@
 	                            }
 	                        }
 	                    }
-	                    if (that.totals?.row?.showGrandTotals || this.columns.length === 0) {
-	                        const flatRowTotalKey = that.rowGrandTotalLabel;
-	                        if (!this.tree[flatRowTotalKey]) {
-	                            this.tree[flatRowTotalKey] = {};
-	                            rowTotalKeys.push(flatRowTotalKey);
-	                        }
-	                        if (!this.tree[flatRowTotalKey][flatColKey]) {
-	                            this.tree[flatRowTotalKey][flatColKey] = [];
-	                        }
-	                        const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
-	                        for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
-	                            if (!this.tree[flatRowTotalKey][flatColKey][i]) {
-	                                if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
-	                                    const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
-	                                    this.tree[flatRowTotalKey][flatColKey][i] = new registeredAggregators[AggregationType.RECALCULATE]({
-	                                        key: toComputeIndicatorKeys[i],
-	                                        field: toComputeIndicatorKeys[i],
-	                                        isRecord: true,
-	                                        formatFun: this.indicators?.find((indicator) => {
-	                                            if (typeof indicator !== 'string') {
-	                                                return indicator.indicatorKey === toComputeIndicatorKeys[i];
-	                                            }
-	                                            return false;
-	                                        })?.format,
-	                                        calculateFun: calculatedFieldRule?.calculateFun,
-	                                        dependAggregators: this.tree[flatRowTotalKey][flatColKey],
-	                                        dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
-	                                    });
-	                                }
-	                                else {
-	                                    const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
-	                                    this.tree[flatRowTotalKey][flatColKey][i] = new registeredAggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
-	                                        key: toComputeIndicatorKeys[i],
-	                                        field: aggRule?.field ?? toComputeIndicatorKeys[i],
-	                                        formatFun: aggRule?.formatFun ??
-	                                            this.indicators?.find((indicator) => {
+	                    if ((that.totals?.row?.showGrandTotals || this.columns.length === 0) &&
+	                        rowKey[0] !== this.groupedGrandTotalKey) {
+	                        const flatRowTotalKeys = this.getGrandTotalKeys(rowKey, that.rows.filter((_, index) => that.rowsHasValue[index]), that.totals?.row?.grandTotalDimensions, that.rowGrandTotalLabel, that.rows);
+	                        for (const flatRowTotalKey of flatRowTotalKeys) {
+	                            if (!this.tree[flatRowTotalKey]) {
+	                                this.tree[flatRowTotalKey] = {};
+	                                rowTotalKeys.push(flatRowTotalKey);
+	                            }
+	                            if (!this.tree[flatRowTotalKey][flatColKey]) {
+	                                this.tree[flatRowTotalKey][flatColKey] = [];
+	                            }
+	                            const toComputeIndicatorKeys = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys;
+	                            for (let i = 0; i < toComputeIndicatorKeys.length; i++) {
+	                                if (!this.tree[flatRowTotalKey][flatColKey][i]) {
+	                                    if (this.calculatedFiledKeys.indexOf(toComputeIndicatorKeys[i]) >= 0) {
+	                                        const calculatedFieldRule = this.calculatedFieldRules?.find(rule => rule.key === toComputeIndicatorKeys[i]);
+	                                        this.tree[flatRowTotalKey][flatColKey][i] = new registeredAggregators[AggregationType.RECALCULATE]({
+	                                            key: toComputeIndicatorKeys[i],
+	                                            field: toComputeIndicatorKeys[i],
+	                                            isRecord: true,
+	                                            formatFun: this.indicators?.find((indicator) => {
 	                                                if (typeof indicator !== 'string') {
 	                                                    return indicator.indicatorKey === toComputeIndicatorKeys[i];
 	                                                }
 	                                                return false;
-	                                            })?.format
-	                                    });
+	                                            })?.format,
+	                                            calculateFun: calculatedFieldRule?.calculateFun,
+	                                            dependAggregators: this.tree[flatRowTotalKey][flatColKey],
+	                                            dependIndicatorKeys: calculatedFieldRule?.dependIndicatorKeys
+	                                        });
+	                                    }
+	                                    else {
+	                                        const aggRule = this.getAggregatorRule(toComputeIndicatorKeys[i]);
+	                                        this.tree[flatRowTotalKey][flatColKey][i] = new registeredAggregators[aggRule?.aggregationType ?? AggregationType.SUM]({
+	                                            key: toComputeIndicatorKeys[i],
+	                                            field: aggRule?.field ?? toComputeIndicatorKeys[i],
+	                                            aggregationFun: aggRule?.aggregationFun,
+	                                            formatFun: aggRule?.formatFun ??
+	                                                this.indicators?.find((indicator) => {
+	                                                    if (typeof indicator !== 'string') {
+	                                                        return indicator.indicatorKey === toComputeIndicatorKeys[i];
+	                                                    }
+	                                                    return false;
+	                                                })?.format
+	                                        });
+	                                        if (this.tree[flatRowTotalKey][flatColKey][i] instanceof CustomAggregator &&
+	                                            flatRowTotalKey.startsWith(this.groupedGrandTotalKey)) {
+	                                            this.tree[flatRowTotalKey][flatColKey][i].recalculateFromChildren = true;
+	                                        }
+	                                    }
+	                                }
+	                                if (flatRowTotalKey !== flatRowKey) {
+	                                    this.tree[flatRowTotalKey][flatColKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
 	                                }
-	                            }
-	                            if (flatRowTotalKey !== flatRowKey) {
-	                                this.tree[flatRowTotalKey][flatColKey][i].push(that.tree[flatRowKey]?.[flatColKey]?.[i]);
 	                            }
 	                        }
 	                    }
@@ -102783,7 +104071,64 @@
 	            }
 	        }
 	    }
-	    ArrToTree1(arr, rows, indicators, isGrandTotal, grandTotalLabel, showGrandTotalsOnTop) {
+	    getGrandTotalDimensionIndexes(dimensions, grandTotalDimensions, configuredDimensions = dimensions) {
+	        if (!grandTotalDimensions?.length) {
+	            return [];
+	        }
+	        return grandTotalDimensions
+	            .map(dimension => ({
+	            configuredIndex: configuredDimensions.indexOf(dimension),
+	            activeIndex: dimensions.indexOf(dimension)
+	        }))
+	            .filter(({ configuredIndex, activeIndex }, position, indexes) => configuredIndex > 0 &&
+	            activeIndex >= 0 &&
+	            indexes.findIndex(item => item.activeIndex === activeIndex) === position)
+	            .map(({ activeIndex }) => activeIndex)
+	            .sort((a, b) => a - b);
+	    }
+	    getCustomGroupedGrandTotalKey(record, dimensions, grandTotalDimensions) {
+	        const dimensionIndexes = this.getGrandTotalDimensionIndexes(dimensions, grandTotalDimensions);
+	        if (!dimensionIndexes.length ||
+	            dimensions.some((dimension, index) => dimensionIndexes.indexOf(index) === -1 && dimension in record)) {
+	            return undefined;
+	        }
+	        const prefixIndexes = [];
+	        for (const index of dimensionIndexes) {
+	            if (!(dimensions[index] in record)) {
+	                break;
+	            }
+	            prefixIndexes.push(index);
+	        }
+	        if (!prefixIndexes.length ||
+	            dimensionIndexes.slice(prefixIndexes.length).some(index => dimensions[index] in record)) {
+	            return undefined;
+	        }
+	        return [this.groupedGrandTotalKey, ...prefixIndexes.map(index => record[dimensions[index]])];
+	    }
+	    getGroupedGrandTotalPaths(keys, dimensions, grandTotalDimensions, isRow = true, configuredDimensions = dimensions) {
+	        const dimensionIndexes = this.getGrandTotalDimensionIndexes(dimensions, grandTotalDimensions, configuredDimensions);
+	        const groupedPaths = new Map();
+	        keys.forEach(key => {
+	            const path = dimensionIndexes.map(index => key[index]);
+	            groupedPaths.set(join(path, this.stringJoinChar), path);
+	        });
+	        return Array.from(groupedPaths.values()).sort(this.arrSort(dimensionIndexes.map(index => dimensions[index]), isRow, [this.groupedGrandTotalKey]));
+	    }
+	    getGrandTotalKeys(dimensionKey, dimensions, grandTotalDimensions, grandTotalLabel, configuredDimensions = dimensions) {
+	        const dimensionIndexes = this.getGrandTotalDimensionIndexes(dimensions, grandTotalDimensions, configuredDimensions);
+	        if (!dimensionIndexes.length) {
+	            return [grandTotalLabel];
+	        }
+	        const groupedKey = [
+	            this.groupedGrandTotalKey,
+	            ...dimensionIndexes.map(dimensionIndex => dimensionKey[dimensionIndex])
+	        ];
+	        return [
+	            ...groupedKey.slice(1).map((_, index) => join(groupedKey.slice(0, index + 2), this.stringJoinChar)),
+	            join([this.groupedGrandTotalKey, this.groupedGrandTotalSubtotalKey], this.stringJoinChar)
+	        ];
+	    }
+	    ArrToTree1(arr, rows, indicators, isGrandTotal, grandTotalLabel, showGrandTotalsOnTop, grandTotalDimensions, subTotalLabel, showSubTotalsOnTop, configuredRows = rows) {
 	        const result = [];
 	        const concatStr = this.stringJoinChar;
 	        const map = new Map();
@@ -102829,13 +104174,77 @@
 	                node = item;
 	            });
 	        }
+	        const createIndicatorChildren = () => indicators?.map(indicator => {
+	            if (typeof indicator === 'string') {
+	                return {
+	                    indicatorKey: indicator,
+	                    value: indicator
+	                };
+	            }
+	            return {
+	                indicatorKey: indicator.indicatorKey,
+	                value: indicator.title
+	            };
+	        }) ?? [];
 	        arr.forEach(item => addList(item, false));
 	        if (isGrandTotal) {
-	            addList([grandTotalLabel], isGrandTotal);
+	            const grandTotalDimensionIndexes = this.getGrandTotalDimensionIndexes(rows, grandTotalDimensions, configuredRows);
+	            if (!grandTotalDimensionIndexes.length) {
+	                addList([grandTotalLabel], isGrandTotal);
+	            }
+	            else {
+	                const grandTotalNode = {
+	                    value: grandTotalLabel,
+	                    dataValue: this.groupedGrandTotalKey,
+	                    dimensionKey: rows[0],
+	                    children: [],
+	                    role: 'grand-total'
+	                };
+	                const grandTotalMap = new Map();
+	                this.getGroupedGrandTotalPaths(arr, rows, grandTotalDimensions, true, configuredRows).forEach(list => {
+	                    let parent = grandTotalNode;
+	                    const path = [this.groupedGrandTotalKey];
+	                    grandTotalDimensionIndexes.forEach((dimensionIndex, index) => {
+	                        const value = list[index];
+	                        path.push(value);
+	                        const flatKey = join(path, concatStr);
+	                        let item = grandTotalMap.get(flatKey);
+	                        if (!item) {
+	                            item = {
+	                                value,
+	                                dataValue: value,
+	                                dimensionKey: rows[dimensionIndex],
+	                                children: index === grandTotalDimensionIndexes.length - 1 ? createIndicatorChildren() : []
+	                            };
+	                            grandTotalMap.set(flatKey, item);
+	                            parent.children.push(item);
+	                        }
+	                        parent = item;
+	                    });
+	                });
+	                const totalChild = {
+	                    value: subTotalLabel,
+	                    dataValue: this.groupedGrandTotalSubtotalKey,
+	                    dimensionKey: rows[grandTotalDimensionIndexes[0]],
+	                    children: createIndicatorChildren()
+	                };
+	                if (showSubTotalsOnTop) {
+	                    grandTotalNode.children.unshift(totalChild);
+	                }
+	                else {
+	                    grandTotalNode.children.push(totalChild);
+	                }
+	                if (showGrandTotalsOnTop) {
+	                    result.unshift(grandTotalNode);
+	                }
+	                else {
+	                    result.push(grandTotalNode);
+	                }
+	            }
 	        }
 	        return result;
 	    }
-	    ArrToTree(arr, rows, indicators, subTotalFlags, isGrandTotal, grandTotalLabel, subTotalLabel, showGrandTotalsOnTop, showSubTotalsOnTop) {
+	    ArrToTree(arr, rows, indicators, subTotalFlags, isGrandTotal, grandTotalLabel, subTotalLabel, showGrandTotalsOnTop, showSubTotalsOnTop, grandTotalDimensions, isRow, configuredRows = rows) {
 	        let result = [];
 	        const concatStr = this.stringJoinChar;
 	        const map = new Map();
@@ -102918,24 +104327,69 @@
 	            });
 	        }
 	        if (isGrandTotal && arr?.length) {
+	            const grandTotalDimensionIndexes = this.getGrandTotalDimensionIndexes(rows, grandTotalDimensions, configuredRows);
+	            const createIndicatorChildren = () => indicators?.map(indicator => {
+	                if (typeof indicator === 'string') {
+	                    return {
+	                        indicatorKey: indicator,
+	                        value: indicator
+	                    };
+	                }
+	                return {
+	                    indicatorKey: indicator.indicatorKey,
+	                    value: indicator.title
+	                };
+	            }) ?? [];
 	            const node = {
 	                value: grandTotalLabel,
+	                dataValue: grandTotalDimensionIndexes.length ? this.groupedGrandTotalKey : undefined,
 	                dimensionKey: rows[0],
-	                levelSpan: subTotalFlags.length,
-	                children: indicators?.map(indicator => {
-	                    if (typeof indicator === 'string') {
-	                        return {
-	                            indicatorKey: indicator,
-	                            value: indicator
-	                        };
-	                    }
-	                    return {
-	                        indicatorKey: indicator.indicatorKey,
-	                        value: indicator.title
-	                    };
-	                }) ?? [],
+	                levelSpan: Math.max(1, grandTotalDimensionIndexes[0] ?? subTotalFlags.length),
+	                children: [],
 	                role: 'grand-total'
 	            };
+	            if (grandTotalDimensionIndexes.length) {
+	                const grandTotalMap = new Map();
+	                this.getGroupedGrandTotalPaths(arr, rows, grandTotalDimensions, isRow, configuredRows).forEach(list => {
+	                    let parent = node;
+	                    const path = [this.groupedGrandTotalKey];
+	                    grandTotalDimensionIndexes.forEach((dimensionIndex, index) => {
+	                        const value = list[index];
+	                        path.push(value);
+	                        const flatKey = join(path, concatStr);
+	                        let item = grandTotalMap.get(flatKey);
+	                        if (!item) {
+	                            const nextDimensionIndex = grandTotalDimensionIndexes[index + 1] ?? rows.length;
+	                            item = {
+	                                value,
+	                                dataValue: value,
+	                                dimensionKey: rows[dimensionIndex],
+	                                levelSpan: nextDimensionIndex - dimensionIndex,
+	                                children: index === grandTotalDimensionIndexes.length - 1 ? createIndicatorChildren() : []
+	                            };
+	                            grandTotalMap.set(flatKey, item);
+	                            parent.children.push(item);
+	                        }
+	                        parent = item;
+	                    });
+	                });
+	                const totalChild = {
+	                    value: subTotalLabel,
+	                    dataValue: this.groupedGrandTotalSubtotalKey,
+	                    dimensionKey: rows[grandTotalDimensionIndexes[0]],
+	                    levelSpan: rows.length - grandTotalDimensionIndexes[0],
+	                    children: createIndicatorChildren()
+	                };
+	                if (showSubTotalsOnTop) {
+	                    node.children.unshift(totalChild);
+	                }
+	                else {
+	                    node.children.push(totalChild);
+	                }
+	            }
+	            else {
+	                node.children = createIndicatorChildren();
+	            }
 	            if (showGrandTotalsOnTop) {
 	                result.unshift(node);
 	            }
@@ -102989,7 +104443,7 @@
 	                });
 	            }
 	            if (rowKey.length < this.rows.length && this.rowHierarchyType === 'grid-tree') {
-	                if (rowKey[0] === this.rowGrandTotalLabel) ;
+	                if (rowKey[0] === this.rowGrandTotalLabel || rowKey[0] === this.groupedGrandTotalKey) ;
 	                else if (((this.totals?.row?.subTotalsDimensions &&
 	                    this.totals?.row?.subTotalsDimensions?.length >= 1 &&
 	                    this.totals.row.subTotalsDimensions.find((dimension) => dimension === rowDimensionKey)) ||
@@ -103012,7 +104466,7 @@
 	                });
 	            }
 	            if (colKey.length < this.columns.length && this.columnHierarchyType === 'grid-tree') {
-	                if (colKey[0] === this.colGrandTotalLabel) ;
+	                if (colKey[0] === this.colGrandTotalLabel || colKey[0] === this.groupedGrandTotalKey) ;
 	                else if (((this.totals?.column?.subTotalsDimensions &&
 	                    this.totals?.column?.subTotalsDimensions?.length >= 1 &&
 	                    this.totals.column.subTotalsDimensions.find((dimension) => dimension === colDimensionKey)) ||
@@ -103073,13 +104527,13 @@
 	                        this.totals.column.showSubTotals !== false)))) {
 	            return;
 	        }
-	        const flatRowKey = Array.isArray(rowKey) ? rowKey.join(this.stringJoinChar) : rowKey;
-	        const flatColKey = Array.isArray(colKey) ? colKey.join(this.stringJoinChar) : colKey;
+	        const flatRowKey = Array.isArray(rowKey) ? join(rowKey, this.stringJoinChar) : rowKey;
+	        const flatColKey = Array.isArray(colKey) ? join(colKey, this.stringJoinChar) : colKey;
 	        const indicatorIndex = this.indicatorKeysIncludeCalculatedFieldDependIndicatorKeys.indexOf(indicator);
 	        const aggregatorsToReset = new Set();
 	        const subTotalAggregators = new Set();
-	        const rowKeyParts = flatRowKey.split(this.stringJoinChar);
-	        const colKeyParts = flatColKey.split(this.stringJoinChar);
+	        const rowKeyParts = Array.isArray(rowKey) ? rowKey.slice() : rowKey.split(this.stringJoinChar);
+	        const colKeyParts = Array.isArray(colKey) ? colKey.slice() : colKey.split(this.stringJoinChar);
 	        const addAggregatorToResetSet = (agg, rowKey, colKey) => {
 	            if (agg && !(rowKey === flatRowKey && colKey === flatColKey)) {
 	                aggregatorsToReset.add(agg);
@@ -103088,6 +104542,8 @@
 	                }
 	            }
 	        };
+	        const rowAggregateKeys = [];
+	        const colAggregateKeys = [];
 	        if (this.totals?.row?.subTotalsDimensions && this.totals.row.showSubTotals !== false) {
 	            for (let i = 0; i < this.totals.row.subTotalsDimensions.length; i++) {
 	                const dimension = this.totals.row.subTotalsDimensions[i];
@@ -103098,80 +104554,59 @@
 	                        rowSubTotalKeyParts.push(this.rowSubTotalLabel);
 	                    }
 	                    const flatRowSubTotalKey = rowSubTotalKeyParts.join(this.stringJoinChar);
-	                    if (this.tree[flatRowSubTotalKey]?.[flatColKey]?.[indicatorIndex]) {
-	                        addAggregatorToResetSet(this.tree[flatRowSubTotalKey][flatColKey][indicatorIndex], flatRowSubTotalKey, flatColKey);
-	                    }
-	                    if (this.totals?.column?.subTotalsDimensions && this.totals.column.showSubTotals !== false) {
-	                        for (let j = 0; j < this.totals.column.subTotalsDimensions.length; j++) {
-	                            const colDimension = this.totals.column.subTotalsDimensions[j];
-	                            const colDimensionIndex = this.columns.indexOf(colDimension);
-	                            if (colDimensionIndex >= 0 && colDimensionIndex < colKeyParts.length) {
-	                                const colSubTotalKeyParts = colKeyParts.slice(0, colDimensionIndex + 1);
-	                                colSubTotalKeyParts.push(this.colSubTotalLabel);
-	                                const flatColSubTotalKey = colSubTotalKeyParts.join(this.stringJoinChar);
-	                                if (this.tree[flatRowSubTotalKey]?.[flatColSubTotalKey]?.[indicatorIndex]) {
-	                                    addAggregatorToResetSet(this.tree[flatRowSubTotalKey][flatColSubTotalKey][indicatorIndex], flatRowSubTotalKey, flatColSubTotalKey);
-	                                }
-	                            }
-	                        }
-	                    }
-	                    if (this.totals?.column?.showGrandTotals) {
-	                        if (this.tree[flatRowSubTotalKey]?.[this.colGrandTotalLabel]?.[indicatorIndex]) {
-	                            addAggregatorToResetSet(this.tree[flatRowSubTotalKey][this.colGrandTotalLabel][indicatorIndex], flatRowSubTotalKey, this.colGrandTotalLabel);
-	                        }
+	                    if (rowAggregateKeys.indexOf(flatRowSubTotalKey) === -1) {
+	                        rowAggregateKeys.push(flatRowSubTotalKey);
 	                    }
 	                }
 	            }
 	        }
 	        if (this.totals?.row?.showGrandTotals) {
-	            if (this.tree[this.rowGrandTotalLabel]?.[flatColKey]?.[indicatorIndex]) {
-	                addAggregatorToResetSet(this.tree[this.rowGrandTotalLabel][flatColKey][indicatorIndex], this.rowGrandTotalLabel, flatColKey);
-	                if (this.totals?.column?.subTotalsDimensions && this.totals.column.showSubTotals !== false) {
-	                    for (let j = 0; j < this.totals.column.subTotalsDimensions.length; j++) {
-	                        const colDimension = this.totals.column.subTotalsDimensions[j];
-	                        const colDimensionIndex = this.columns.indexOf(colDimension);
-	                        if (colDimensionIndex >= 0 && colDimensionIndex < colKeyParts.length) {
-	                            const colSubTotalKeyParts = colKeyParts.slice(0, colDimensionIndex + 1);
-	                            colSubTotalKeyParts.push(this.colSubTotalLabel);
-	                            const flatColSubTotalKey = colSubTotalKeyParts.join(this.stringJoinChar);
-	                            if (this.tree[this.rowGrandTotalLabel]?.[flatColSubTotalKey]?.[indicatorIndex]) {
-	                                addAggregatorToResetSet(this.tree[this.rowGrandTotalLabel][flatColSubTotalKey][indicatorIndex], this.rowGrandTotalLabel, flatColSubTotalKey);
-	                            }
-	                        }
-	                    }
-	                }
-	                if (this.totals?.column?.showGrandTotals) {
-	                    if (this.tree[this.rowGrandTotalLabel]?.[this.colGrandTotalLabel]?.[indicatorIndex]) {
-	                        addAggregatorToResetSet(this.tree[this.rowGrandTotalLabel][this.colGrandTotalLabel][indicatorIndex], this.rowGrandTotalLabel, this.colGrandTotalLabel);
-	                    }
+	            const rowGrandTotalKeys = this.getGrandTotalKeys(rowKeyParts, this.rows.filter((_, index) => this.rowsHasValue[index]), this.totals.row.grandTotalDimensions, this.rowGrandTotalLabel, this.rows);
+	            for (const rowGrandTotalKey of rowGrandTotalKeys) {
+	                if (rowAggregateKeys.indexOf(rowGrandTotalKey) === -1) {
+	                    rowAggregateKeys.push(rowGrandTotalKey);
 	                }
 	            }
-	            if (this.totals?.column?.subTotalsDimensions && this.totals.column.showSubTotals !== false) {
-	                for (let j = 0; j < this.totals.column.subTotalsDimensions.length; j++) {
-	                    const colDimension = this.totals.column.subTotalsDimensions[j];
-	                    const colDimensionIndex = this.columns.indexOf(colDimension);
-	                    if (colDimensionIndex >= 0 && colDimensionIndex < colKeyParts.length) {
-	                        const colSubTotalKeyParts = colKeyParts.slice(0, colDimensionIndex + 1);
-	                        colSubTotalKeyParts.push(this.colSubTotalLabel);
-	                        const flatColSubTotalKey = colSubTotalKeyParts.join(this.stringJoinChar);
-	                        if (this.tree[flatRowKey]?.[flatColSubTotalKey]?.[indicatorIndex]) {
-	                            addAggregatorToResetSet(this.tree[flatRowKey][flatColSubTotalKey][indicatorIndex], flatRowKey, flatColSubTotalKey);
-	                        }
+	        }
+	        if (this.totals?.column?.subTotalsDimensions && this.totals.column.showSubTotals !== false) {
+	            for (let j = 0; j < this.totals.column.subTotalsDimensions.length; j++) {
+	                const colDimension = this.totals.column.subTotalsDimensions[j];
+	                const colDimensionIndex = this.columns.indexOf(colDimension);
+	                if (colDimensionIndex >= 0 && colDimensionIndex < colKeyParts.length) {
+	                    const colSubTotalKeyParts = colKeyParts.slice(0, colDimensionIndex + 1);
+	                    colSubTotalKeyParts.push(this.colSubTotalLabel);
+	                    const flatColSubTotalKey = colSubTotalKeyParts.join(this.stringJoinChar);
+	                    if (colAggregateKeys.indexOf(flatColSubTotalKey) === -1) {
+	                        colAggregateKeys.push(flatColSubTotalKey);
 	                    }
 	                }
 	            }
-	            if (this.totals?.column?.showGrandTotals) {
-	                if (this.tree[flatRowKey]?.[this.colGrandTotalLabel]?.[indicatorIndex]) {
-	                    addAggregatorToResetSet(this.tree[flatRowKey][this.colGrandTotalLabel][indicatorIndex], flatRowKey, this.colGrandTotalLabel);
+	        }
+	        if (this.totals?.column?.showGrandTotals) {
+	            const colGrandTotalKeys = this.getGrandTotalKeys(colKeyParts, this.columns.filter((_, index) => this.columnsHasValue[index]), this.totals.column.grandTotalDimensions, this.colGrandTotalLabel, this.columns);
+	            for (const colGrandTotalKey of colGrandTotalKeys) {
+	                if (colAggregateKeys.indexOf(colGrandTotalKey) === -1) {
+	                    colAggregateKeys.push(colGrandTotalKey);
 	                }
 	            }
-	            aggregatorsToReset.forEach(agg => {
-	                if (newCellAggregator && subTotalAggregators.has(agg)) {
-	                    agg.push(newCellAggregator);
-	                }
-	                agg.recalculate();
-	            });
 	        }
+	        rowAggregateKeys.forEach(rowAggregateKey => {
+	            addAggregatorToResetSet(this.tree[rowAggregateKey]?.[flatColKey]?.[indicatorIndex], rowAggregateKey, flatColKey);
+	        });
+	        colAggregateKeys.forEach(colAggregateKey => {
+	            addAggregatorToResetSet(this.tree[flatRowKey]?.[colAggregateKey]?.[indicatorIndex], flatRowKey, colAggregateKey);
+	        });
+	        rowAggregateKeys.forEach(rowAggregateKey => {
+	            colAggregateKeys.forEach(colAggregateKey => {
+	                addAggregatorToResetSet(this.tree[rowAggregateKey]?.[colAggregateKey]?.[indicatorIndex], rowAggregateKey, colAggregateKey);
+	            });
+	        });
+	        aggregatorsToReset.forEach(agg => {
+	            if (newCellAggregator && subTotalAggregators.has(agg)) {
+	                agg.push(newCellAggregator);
+	            }
+	            agg.recalculate();
+	        });
 	    }
 	    changeRecordFieldValue(fieldName, oldValue, value) {
 	        let isIndicatorName = false;
@@ -103784,7 +105219,7 @@
 	                            index
 	                        };
 	                    }
-	                    return colPath.indicatorKey ?? colPath.value;
+	                    return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	                });
 	                const rowKeys = cellDimensionPath.rowHeaderPaths
 	                    ?.filter((path) => {
@@ -103797,7 +105232,7 @@
 	                            index
 	                        };
 	                    }
-	                    return rowPath.indicatorKey ?? rowPath.value;
+	                    return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	                });
 	                const aggregator = this.dataset.getAggregator(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), true, indicatorPosition);
 	                if (aggregator.records && aggregator.records.length >= 1) {
@@ -103808,10 +105243,10 @@
 	        else if (this.flatDataToObjects) {
 	            const cellDimensionPath = this.internalProps.layoutMap.getCellHeaderPaths(col, row);
 	            const colKeys = cellDimensionPath.colHeaderPaths.map((colPath) => {
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath) => {
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const treeNode = this.flatDataToObjects.getTreeNode(rowKeys, colKeys, this.internalProps.layoutMap.getBody(col, row).indicatorKey, false);
 	            if (treeNode?.record) {
@@ -103863,7 +105298,7 @@
 	                        index
 	                    };
 	                }
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths
 	                ?.filter((path) => {
@@ -103876,7 +105311,7 @@
 	                        index
 	                    };
 	                }
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const aggregator = this.dataset.getAggregator(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), true, indicatorPosition);
 	            const { fieldFormat } = this.internalProps.layoutMap.getBody(col, row);
@@ -103889,10 +105324,10 @@
 	        else if (this.flatDataToObjects) {
 	            const cellDimensionPath = this.internalProps.layoutMap.getCellHeaderPaths(col, row);
 	            const colKeys = cellDimensionPath.colHeaderPaths.map((colPath) => {
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath) => {
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const valueNode = this.flatDataToObjects.getTreeNode(rowKeys, colKeys, this.internalProps.layoutMap.getBody(col, row).indicatorKey);
 	            const { fieldFormat } = this.internalProps.layoutMap.getBody(col, row);
@@ -103927,7 +105362,7 @@
 	                        index
 	                    };
 	                }
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths
 	                ?.filter((path) => {
@@ -103940,7 +105375,7 @@
 	                        index
 	                    };
 	                }
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const aggregator = this.dataset.getAggregator(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), true, indicatorPosition);
 	            return aggregator.value ? aggregator.value() : undefined;
@@ -103948,10 +105383,10 @@
 	        else if (this.flatDataToObjects) {
 	            const cellDimensionPath = this.internalProps.layoutMap.getCellHeaderPaths(col, row);
 	            const colKeys = cellDimensionPath.colHeaderPaths.map((colPath) => {
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath) => {
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const treeNode = this.flatDataToObjects.getTreeNode(rowKeys, colKeys, this.internalProps.layoutMap.getBody(col, row).indicatorKey);
 	            return treeNode?.value;
@@ -103983,7 +105418,7 @@
 	                        index
 	                    };
 	                }
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths
 	                ?.filter((path) => {
@@ -103996,7 +105431,7 @@
 	                        index
 	                    };
 	                }
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const aggregator = this.dataset.getAggregator(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), false, indicatorPosition);
 	            return aggregator.value ? aggregator.value() : undefined;
@@ -104004,10 +105439,10 @@
 	        else if (this.flatDataToObjects) {
 	            const cellDimensionPath = this.internalProps.layoutMap.getCellHeaderPaths(col, row);
 	            const colKeys = cellDimensionPath.colHeaderPaths.map((colPath) => {
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath) => {
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const treeNode = this.flatDataToObjects.getTreeNode(rowKeys, colKeys, this.internalProps.layoutMap.getBody(col, row).indicatorKey, false);
 	            return treeNode?.value;
@@ -104038,7 +105473,7 @@
 	                        index
 	                    };
 	                }
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths
 	                ?.filter((path) => {
@@ -104051,7 +105486,7 @@
 	                        index
 	                    };
 	                }
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const aggregator = this.dataset.getAggregator(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), true, indicatorPosition);
 	            return aggregator.records;
@@ -104059,10 +105494,10 @@
 	        else if (this.flatDataToObjects) {
 	            const cellDimensionPath = this.internalProps.layoutMap.getCellHeaderPaths(col, row);
 	            const colKeys = cellDimensionPath.colHeaderPaths.map((colPath) => {
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath) => {
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const treeNode = this.flatDataToObjects.getTreeNode(rowKeys, colKeys, this.internalProps.layoutMap.getBody(col, row).indicatorKey);
 	            return treeNode?.record;
@@ -104093,7 +105528,7 @@
 	                        index
 	                    };
 	                }
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths
 	                ?.filter((path) => {
@@ -104106,7 +105541,7 @@
 	                        index
 	                    };
 	                }
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const aggregator = this.dataset.getAggregator(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), false, indicatorPosition);
 	            return aggregator.records;
@@ -104114,10 +105549,10 @@
 	        else if (this.flatDataToObjects) {
 	            const cellDimensionPath = this.internalProps.layoutMap.getCellHeaderPaths(col, row);
 	            const colKeys = cellDimensionPath.colHeaderPaths.map((colPath) => {
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath) => {
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const treeNode = this.flatDataToObjects.getTreeNode(rowKeys, colKeys, this.internalProps.layoutMap.getBody(col, row).indicatorKey, false);
 	            return treeNode?.record;
@@ -104829,7 +106264,11 @@
 	            this.scenegraph.updateNextFrame();
 	        }
 	    }
-	    changeCellValues(startCol, startRow, values, workOnEditableCell = false) {
+	    changeCellValues(startCol, startRow, values, workOnEditableCell = false, triggerEvent = true, _noTriggerChangeCellValuesEvent, shouldCancel) {
+	        const changedCellResults = [];
+	        if (shouldCancel?.()) {
+	            return changedCellResults;
+	        }
 	        let pasteColEnd = startCol;
 	        let pasteRowEnd = startRow;
 	        const beforeChangeValues = [];
@@ -104857,6 +106296,7 @@
 	            if (startRow + i > this.rowCount - 1) {
 	                break;
 	            }
+	            changedCellResults[i] = [];
 	            pasteRowEnd = startRow + i;
 	            const rowValues = values[i];
 	            let thisRowPasteColEnd = startCol;
@@ -104871,12 +106311,13 @@
 	                    let newValue = value;
 	                    const oldValue = oldValues[i][j];
 	                    const rawValue = beforeChangeValues[i][j];
-	                    if (typeof rawValue === 'number' && isAllDigits(value)) {
+	                    if (typeof rawValue === 'number' && typeof value === 'string' && isAllDigits(value)) {
 	                        newValue = parseFloat(value);
 	                    }
+	                    changedCellResults[i][j] = true;
 	                    this._changeCellValueToDataSet(startCol + j, startRow + i, oldValue, newValue);
 	                    const changedValue = this.getCellOriginValue(startCol + j, startRow + i);
-	                    if (changedValue !== oldValue) {
+	                    if (changedValue !== oldValue && triggerEvent) {
 	                        this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, {
 	                            col: startCol + j,
 	                            row: startRow + i,
@@ -104886,6 +106327,9 @@
 	                        });
 	                    }
 	                }
+	                else {
+	                    changedCellResults[i][j] = false;
+	                }
 	            }
 	            pasteColEnd = Math.max(pasteColEnd, thisRowPasteColEnd);
 	        }
@@ -104938,6 +106382,7 @@
 	            this.scenegraph.updateRowsHeight(rows, deltaYs);
 	        }
 	        this.scenegraph.updateNextFrame();
+	        return changedCellResults;
 	    }
 	    _changeCellValueToDataSet(col, row, oldValue, newValue) {
 	        if (this.internalProps.recordsIsTwoDimensionalArray) {
@@ -104972,7 +106417,7 @@
 	                            index
 	                        };
 	                    }
-	                    return colPath.indicatorKey ?? colPath.value;
+	                    return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	                });
 	                const rowKeys = cellDimensionPath.rowHeaderPaths
 	                    ?.filter((path) => {
@@ -104985,7 +106430,7 @@
 	                            index
 	                        };
 	                    }
-	                    return rowPath.indicatorKey ?? rowPath.value;
+	                    return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	                });
 	                this.dataset.changeTreeNodeValue(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), newValue, indicatorPosition);
 	            }
@@ -105003,10 +106448,10 @@
 	            }
 	            else {
 	                const colKeys = cellDimensionPath.colHeaderPaths.map((colPath) => {
-	                    return colPath.indicatorKey ?? colPath.value;
+	                    return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	                });
 	                const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath) => {
-	                    return rowPath.indicatorKey ?? rowPath.value;
+	                    return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	                });
 	                this.flatDataToObjects.changeTreeNodeValue(rowKeys, colKeys, this.internalProps.layoutMap.getBody(col, row).indicatorKey, newValue);
 	            }
@@ -105255,7 +106700,7 @@
 	        this.setCustomStateNameToSpec();
 	        this.internalProps.columnResizeType = options.resize?.columnResizeType ?? options.columnResizeType ?? 'column';
 	        this.internalProps.rowResizeType = options.resize?.rowResizeType ?? options.rowResizeType ?? 'row';
-	        this.internalProps.dataConfig = { isPivotChart: true };
+	        this.internalProps.dataConfig = { ...cloneDeep(options.dataConfig), isPivotChart: true };
 	        this.internalProps.columnWidthConfig = options.columnWidthConfig;
 	        this.internalProps.columnWidthConfigForRowHeader = options.columnWidthConfigForRowHeader;
 	        this._axes = isArray$5(options.axes) ? options.axes : [];
@@ -105425,7 +106870,7 @@
 	        this._selectedDataItemsInChart = [];
 	        internalProps.columnResizeType = options.resize?.columnResizeType ?? options.columnResizeType ?? 'column';
 	        internalProps.rowResizeType = options.resize?.rowResizeType ?? options.rowResizeType ?? 'row';
-	        internalProps.dataConfig = { isPivotChart: true };
+	        internalProps.dataConfig = { ...cloneDeep(options.dataConfig), isPivotChart: true };
 	        this.internalProps.columnWidthConfig = options.columnWidthConfig;
 	        this.internalProps.columnWidthConfigForRowHeader = options.columnWidthConfigForRowHeader;
 	        this._axes = isArray$5(options.axes) ? options.axes : [];
@@ -105640,7 +107085,7 @@
 	                        index
 	                    };
 	                }
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath, index) => {
 	                if (rowPath.indicatorKey) {
@@ -105649,7 +107094,7 @@
 	                        index
 	                    };
 	                }
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const aggregator = this.dataset.getAggregator(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), true, indicatorPosition);
 	            return aggregator.value ? aggregator.value() : undefined;
@@ -105692,7 +107137,7 @@
 	                        index
 	                    };
 	                }
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath, index) => {
 	                if (rowPath.indicatorKey) {
@@ -105701,7 +107146,7 @@
 	                        index
 	                    };
 	                }
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const aggregator = this.dataset.getAggregator(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), true, indicatorPosition);
 	            return aggregator.value ? aggregator.value() : undefined;
@@ -105729,7 +107174,7 @@
 	                        index
 	                    };
 	                }
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath, index) => {
 	                if (rowPath.indicatorKey) {
@@ -105738,7 +107183,7 @@
 	                        index
 	                    };
 	                }
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const aggregator = this.dataset.getAggregator(rowKeys, colKeys, this.internalProps.layoutMap.getIndicatorKey(col, row), true, indicatorPosition);
 	            return aggregator.records;
@@ -106725,7 +108170,7 @@
 
 	function createDataset(options) {
 	    const layoutNodeId = { seqId: 0 };
-	    const dataConfig = { isPivotChart: true };
+	    const dataConfig = { ...options.dataConfig, isPivotChart: true };
 	    let columnDimensionTree;
 	    let rowDimensionTree;
 	    let columnTree;
@@ -106742,7 +108187,7 @@
 	        }
 	        rowDimensionTree = new DimensionTree(options.rowTree ?? [], layoutNodeId);
 	    }
-	    const rowKeys = rowDimensionTree.dimensionKeys?.count
+	    const rowKeys = rowDimensionTree?.dimensionKeys?.count
 	        ? rowDimensionTree.dimensionKeys.valueArr()
 	        : options.rows?.reduce((keys, rowObj) => {
 	            if (typeof rowObj === 'string') {
@@ -106753,7 +108198,7 @@
 	            }
 	            return keys;
 	        }, []) ?? [];
-	    const columnKeys = columnDimensionTree.dimensionKeys?.count
+	    const columnKeys = columnDimensionTree?.dimensionKeys?.count
 	        ? columnDimensionTree.dimensionKeys.valueArr()
 	        : options.columns?.reduce((keys, columnObj) => {
 	            if (typeof columnObj === 'string') {
@@ -106983,10 +108428,10 @@
 	            }
 	            const cellDimensionPath = layoutMap.getCellHeaderPaths(col, row);
 	            const colKeys = cellDimensionPath.colHeaderPaths.map((colPath) => {
-	                return colPath.indicatorKey ?? colPath.value;
+	                return colPath.indicatorKey ?? colPath.dataValue ?? colPath.value;
 	            });
 	            const rowKeys = cellDimensionPath.rowHeaderPaths.map((rowPath) => {
-	                return rowPath.indicatorKey ?? rowPath.value;
+	                return rowPath.indicatorKey ?? rowPath.dataValue ?? rowPath.value;
 	            });
 	            const aggregator = dataset.getAggregator(!layoutMap.indicatorsAsCol ? rowKeys.slice(0, -1) : rowKeys, layoutMap.indicatorsAsCol ? colKeys.slice(0, -1) : colKeys, layoutMap.getIndicatorKey(col, row));
 	            const result = compareData(aggregator.value ? aggregator.value() : undefined, data, col, row, layoutMap, compareFunc);
@@ -107022,7 +108467,7 @@
 	}
 
 	registerForVrender();
-	const version = "1.26.7";
+	const version = "1.26.8";
 	function getIcons() {
 	    return get$4();
 	}