@visactor/vtable 1.11.3 → 1.11.5

package/dist/vtable.js

@@ -35957,94 +35957,6 @@
         });
     }
 
-    function isSameRange$1(range1, range2) {
-        if (!range1 && !range2) {
-            return true;
-        }
-        if (!range1 || !range2) {
-            return false;
-        }
-        return (range1.start.col === range2.start.col &&
-            range1.start.row === range2.start.row &&
-            range1.end.col === range2.end.col &&
-            range1.end.row === range2.end.row);
-    }
-
-    class InvertHighlightPlugin {
-        table;
-        range;
-        _fill;
-        _opacity;
-        constructor(table, options) {
-            this.table = table;
-            this._fill = options?.fill ?? '#000';
-            this._opacity = options?.opacity ?? 0.5;
-        }
-        setInvertHighlightRange(range) {
-            if (isSameRange$1(this.range, range)) {
-                return;
-            }
-            this.range = range;
-            if (!range) {
-                this.deleteAllCellGroupShadow();
-            }
-            else {
-                this.updateCellGroupShadow();
-            }
-            this.table.scenegraph.updateNextFrame();
-        }
-        deleteAllCellGroupShadow() {
-            if (!this.table.isPivotTable()) {
-                this.updateCellGroupShadowInContainer(this.table.scenegraph.rowHeaderGroup);
-                this.updateCellGroupShadowInContainer(this.table.scenegraph.leftBottomCornerGroup);
-            }
-            this.updateCellGroupShadowInContainer(this.table.scenegraph.bodyGroup);
-            this.updateCellGroupShadowInContainer(this.table.scenegraph.rightFrozenGroup);
-            this.updateCellGroupShadowInContainer(this.table.scenegraph.bottomFrozenGroup);
-            this.updateCellGroupShadowInContainer(this.table.scenegraph.rightBottomCornerGroup);
-        }
-        updateCellGroupShadow() {
-            if (!this.table.isPivotTable()) {
-                this.updateCellGroupShadowInContainer(this.table.scenegraph.rowHeaderGroup, this.range);
-                this.updateCellGroupShadowInContainer(this.table.scenegraph.leftBottomCornerGroup, this.range);
-            }
-            this.updateCellGroupShadowInContainer(this.table.scenegraph.bodyGroup, this.range);
-            this.updateCellGroupShadowInContainer(this.table.scenegraph.rightFrozenGroup, this.range);
-            this.updateCellGroupShadowInContainer(this.table.scenegraph.bottomFrozenGroup), this.range;
-            this.updateCellGroupShadowInContainer(this.table.scenegraph.rightBottomCornerGroup, this.range);
-        }
-        updateCellGroupShadowInContainer(container, range) {
-            container.forEachChildrenSkipChild((column) => {
-                if (column.role === 'column') {
-                    column.forEachChildrenSkipChild((cell) => {
-                        if (cell.role !== 'cell') {
-                            return;
-                        }
-                        cell.attachShadow(cell.shadowRoot);
-                        const shadowGroup = cell.shadowRoot;
-                        if (!range) {
-                            shadowGroup.removeAllChild();
-                        }
-                        else if (cellInRange(range, cell.col, cell.row)) {
-                            shadowGroup.removeAllChild();
-                        }
-                        else if (!shadowGroup.firstChild) {
-                            const shadowRect = createRect({
-                                x: 0,
-                                y: 0,
-                                width: cell.attribute.width,
-                                height: cell.attribute.height,
-                                fill: this._fill,
-                                opacity: this._opacity
-                            });
-                            shadowRect.name = 'shadow-rect';
-                            shadowGroup.appendChild(shadowRect);
-                        }
-                    });
-                }
-            });
-        }
-    }
     function onBeforeAttributeUpdateForInvertHighlight(val, attribute) {
         const graphic = this;
         if (graphic.shadowRoot && graphic.shadowRoot.childrenCount && (isValid$1(val.width) || isValid$1(val.height))) {
@@ -55485,159 +55397,6 @@
         }
     }
 
-    class CustomCellStylePlugin {
-        table;
-        customCellStyle;
-        customCellStyleArrangement;
-        constructor(table, customCellStyle, customCellStyleArrangement) {
-            this.table = table;
-            this.customCellStyle = customCellStyle;
-            this.customCellStyleArrangement = customCellStyleArrangement;
-        }
-        getCustomCellStyle(col, row) {
-            const customStyleIds = this.getCustomCellStyleIds(col, row);
-            if (customStyleIds.length) {
-                const styles = [];
-                customStyleIds.forEach(customStyleId => {
-                    const styleOption = this.getCustomCellStyleOption(customStyleId);
-                    if (styleOption?.style) {
-                        styles.push(styleOption.style);
-                    }
-                });
-                return merge({}, ...styles);
-            }
-            return undefined;
-        }
-        getCustomCellStyleIds(col, row) {
-            const customStyleIds = [];
-            const range = this.table.getCellRange(col, row);
-            for (let c = range.start.col; c <= range.end.col; c++) {
-                for (let r = range.start.row; r <= range.end.row; r++) {
-                    this.customCellStyleArrangement.forEach(style => {
-                        if (style.cellPosition.range) {
-                            if (style.cellPosition.range.start.col <= c &&
-                                style.cellPosition.range.end.col >= c &&
-                                style.cellPosition.range.start.row <= r &&
-                                style.cellPosition.range.end.row >= r) {
-                                customStyleIds.push(style.customStyleId);
-                            }
-                        }
-                        else if (style.cellPosition.col === c && style.cellPosition.row === r) {
-                            customStyleIds.push(style.customStyleId);
-                        }
-                    });
-                }
-            }
-            return customStyleIds;
-        }
-        getCustomCellStyleOption(customStyleId) {
-            return this.customCellStyle.find(style => style.id === customStyleId);
-        }
-        registerCustomCellStyle(customStyleId, customStyle) {
-            const index = this.customCellStyle.findIndex(style => style.id === customStyleId);
-            if (index === -1) {
-                this.customCellStyle.push({
-                    id: customStyleId,
-                    style: customStyle
-                });
-            }
-            else {
-                this.customCellStyle[index] = {
-                    id: customStyleId,
-                    style: customStyle
-                };
-            }
-            this.customCellStyleArrangement.forEach(cellStyle => {
-                const cellPos = cellStyle.cellPosition;
-                if (cellStyle.customStyleId === customStyleId) {
-                    if (cellPos.range) {
-                        for (let col = Math.max(0, cellPos.range.start.col); col <= Math.min(this.table.colCount - 1, cellPos.range.end.col); col++) {
-                            for (let row = Math.max(0, cellPos.range.start.row); row <= Math.min(this.table.rowCount - 1, cellPos.range.end.row); row++) {
-                                this.table.scenegraph.updateCellContent(col, row);
-                            }
-                        }
-                    }
-                    else {
-                        this.table.scenegraph.updateCellContent(cellPos.col, cellPos.row);
-                    }
-                }
-            });
-            this.table.scenegraph.updateNextFrame();
-        }
-        arrangeCustomCellStyle(cellPos, customStyleId) {
-            const index = this.customCellStyleArrangement.findIndex(style => {
-                if (style.cellPosition.range && cellPos.range) {
-                    return (style.cellPosition.range.start.col === cellPos.range.start.col &&
-                        style.cellPosition.range.start.row === cellPos.range.start.row &&
-                        style.cellPosition.range.end.col === cellPos.range.end.col &&
-                        style.cellPosition.range.end.row === cellPos.range.end.row);
-                }
-                return style.cellPosition.col === cellPos.col && style.cellPosition.row === cellPos.row;
-            });
-            if (index === -1 && !customStyleId) {
-                return;
-            }
-            else if (index === -1 && customStyleId) {
-                this.customCellStyleArrangement.push({
-                    cellPosition: {
-                        col: cellPos.col,
-                        row: cellPos.row,
-                        range: cellPos.range
-                    },
-                    customStyleId: customStyleId
-                });
-            }
-            else if (this.customCellStyleArrangement[index].customStyleId === customStyleId) {
-                return;
-            }
-            else if (customStyleId) {
-                this.customCellStyleArrangement[index].customStyleId = customStyleId;
-            }
-            else {
-                this.customCellStyleArrangement.splice(index, 1);
-            }
-            if (cellPos.range) {
-                for (let col = Math.max(0, cellPos.range.start.col); col <= Math.min(this.table.colCount - 1, cellPos.range.end.col); col++) {
-                    for (let row = Math.max(0, cellPos.range.start.row); row <= Math.min(this.table.rowCount - 1, cellPos.range.end.row); row++) {
-                        const range = this.table.getCellRange(col, row);
-                        for (let c = range.start.col; c <= range.end.col; c++) {
-                            for (let r = range.start.row; r <= range.end.row; r++) {
-                                this.table.scenegraph.updateCellContent(c, r);
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                this.table.scenegraph.updateCellContent(cellPos.col, cellPos.row);
-            }
-            this.table.scenegraph.updateNextFrame();
-        }
-        updateCustomCell(customCellStyle, customCellStyleArrangement) {
-            this.customCellStyle.length = 0;
-            this.customCellStyleArrangement.length = 0;
-            customCellStyle.forEach((cellStyle) => {
-                this.registerCustomCellStyle(cellStyle.id, cellStyle.style);
-            });
-            customCellStyleArrangement.forEach((cellStyle) => {
-                this.arrangeCustomCellStyle(cellStyle.cellPosition, cellStyle.customStyleId);
-            });
-        }
-        hasCustomCellStyle(customStyleId) {
-            return this.customCellStyle.some(style => style.id === customStyleId);
-        }
-    }
-    function mergeStyle(cacheStyle, customCellStyle) {
-        cacheStyle = cacheStyle.clone();
-        for (const key in customCellStyle) {
-            const value = customCellStyle[key];
-            if (value) {
-                cacheStyle[`_${key}`] = value;
-            }
-        }
-        return cacheStyle;
-    }
-
     class DimensionTree {
         sharedVar;
         sizeIncludeParent = false;
@@ -57387,9 +57146,165 @@
         return (isHorizontal && isThisXAxis) || (!isHorizontal && !isThisXAxis);
     }
 
+    class CustomCellStylePlugin {
+        table;
+        customCellStyle;
+        customCellStyleArrangement;
+        constructor(table, customCellStyle, customCellStyleArrangement) {
+            this.table = table;
+            this.customCellStyle = customCellStyle;
+            this.customCellStyleArrangement = customCellStyleArrangement;
+        }
+        getCustomCellStyle(col, row) {
+            const customStyleIds = this.getCustomCellStyleIds(col, row);
+            if (customStyleIds.length) {
+                const styles = [];
+                customStyleIds.forEach(customStyleId => {
+                    const styleOption = this.getCustomCellStyleOption(customStyleId);
+                    if (styleOption?.style) {
+                        styles.push(styleOption.style);
+                    }
+                });
+                return merge({}, ...styles);
+            }
+            return undefined;
+        }
+        getCustomCellStyleIds(col, row) {
+            const customStyleIds = [];
+            const range = this.table.getCellRange(col, row);
+            for (let c = range.start.col; c <= range.end.col; c++) {
+                for (let r = range.start.row; r <= range.end.row; r++) {
+                    this.customCellStyleArrangement.forEach(style => {
+                        if (style.cellPosition.range) {
+                            if (style.cellPosition.range.start.col <= c &&
+                                style.cellPosition.range.end.col >= c &&
+                                style.cellPosition.range.start.row <= r &&
+                                style.cellPosition.range.end.row >= r) {
+                                customStyleIds.push(style.customStyleId);
+                            }
+                        }
+                        else if (style.cellPosition.col === c && style.cellPosition.row === r) {
+                            customStyleIds.push(style.customStyleId);
+                        }
+                    });
+                }
+            }
+            return customStyleIds;
+        }
+        getCustomCellStyleOption(customStyleId) {
+            return this.customCellStyle.find(style => style.id === customStyleId);
+        }
+        registerCustomCellStyle(customStyleId, customStyle) {
+            const index = this.customCellStyle.findIndex(style => style.id === customStyleId);
+            if (index === -1) {
+                this.customCellStyle.push({
+                    id: customStyleId,
+                    style: customStyle
+                });
+            }
+            else {
+                this.customCellStyle[index] = {
+                    id: customStyleId,
+                    style: customStyle
+                };
+            }
+            this.customCellStyleArrangement.forEach(cellStyle => {
+                const cellPos = cellStyle.cellPosition;
+                if (cellStyle.customStyleId === customStyleId) {
+                    if (cellPos.range) {
+                        for (let col = Math.max(0, cellPos.range.start.col); col <= Math.min(this.table.colCount - 1, cellPos.range.end.col); col++) {
+                            for (let row = Math.max(0, cellPos.range.start.row); row <= Math.min(this.table.rowCount - 1, cellPos.range.end.row); row++) {
+                                this.table.scenegraph.updateCellContent(col, row);
+                            }
+                        }
+                    }
+                    else {
+                        this.table.scenegraph.updateCellContent(cellPos.col, cellPos.row);
+                    }
+                }
+            });
+            this.table.scenegraph.updateNextFrame();
+        }
+        arrangeCustomCellStyle(cellPos, customStyleId) {
+            const index = this.customCellStyleArrangement.findIndex(style => {
+                if (style.cellPosition.range && cellPos.range) {
+                    return (style.cellPosition.range.start.col === cellPos.range.start.col &&
+                        style.cellPosition.range.start.row === cellPos.range.start.row &&
+                        style.cellPosition.range.end.col === cellPos.range.end.col &&
+                        style.cellPosition.range.end.row === cellPos.range.end.row);
+                }
+                return style.cellPosition.col === cellPos.col && style.cellPosition.row === cellPos.row;
+            });
+            if (index === -1 && !customStyleId) {
+                return;
+            }
+            else if (index === -1 && customStyleId) {
+                this.customCellStyleArrangement.push({
+                    cellPosition: {
+                        col: cellPos.col,
+                        row: cellPos.row,
+                        range: cellPos.range
+                    },
+                    customStyleId: customStyleId
+                });
+            }
+            else if (this.customCellStyleArrangement[index].customStyleId === customStyleId) {
+                return;
+            }
+            else if (customStyleId) {
+                this.customCellStyleArrangement[index].customStyleId = customStyleId;
+            }
+            else {
+                this.customCellStyleArrangement.splice(index, 1);
+            }
+            if (cellPos.range) {
+                for (let col = Math.max(0, cellPos.range.start.col); col <= Math.min(this.table.colCount - 1, cellPos.range.end.col); col++) {
+                    for (let row = Math.max(0, cellPos.range.start.row); row <= Math.min(this.table.rowCount - 1, cellPos.range.end.row); row++) {
+                        const range = this.table.getCellRange(col, row);
+                        for (let c = range.start.col; c <= range.end.col; c++) {
+                            for (let r = range.start.row; r <= range.end.row; r++) {
+                                this.table.scenegraph.updateCellContent(c, r);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                this.table.scenegraph.updateCellContent(cellPos.col, cellPos.row);
+            }
+            this.table.scenegraph.updateNextFrame();
+        }
+        updateCustomCell(customCellStyle, customCellStyleArrangement) {
+            this.customCellStyle.length = 0;
+            this.customCellStyleArrangement.length = 0;
+            customCellStyle.forEach((cellStyle) => {
+                this.registerCustomCellStyle(cellStyle.id, cellStyle.style);
+            });
+            customCellStyleArrangement.forEach((cellStyle) => {
+                this.arrangeCustomCellStyle(cellStyle.cellPosition, cellStyle.customStyleId);
+            });
+        }
+        hasCustomCellStyle(customStyleId) {
+            return this.customCellStyle.some(style => style.id === customStyleId);
+        }
+    }
+    function mergeStyle(cacheStyle, customCellStyle) {
+        cacheStyle = cacheStyle.clone();
+        for (const key in customCellStyle) {
+            const value = customCellStyle[key];
+            if (value) {
+                cacheStyle[`_${key}`] = value;
+            }
+        }
+        return cacheStyle;
+    }
+    const registerCustomCellStylePlugin = () => {
+        Factory.registerComponent('customCellStylePlugin', CustomCellStylePlugin);
+    };
+
     const EMPTY_STYLE = {};
     function getCellStyle(col, row, table) {
-        const customCellStyle = table.customCellStylePlugin.getCustomCellStyle(col, row);
+        const customCellStyle = table.customCellStylePlugin?.getCustomCellStyle(col, row);
         const { layoutMap } = table.internalProps;
         const isHeader = layoutMap.isHeader(col, row);
         if (isHeader) {
@@ -57644,7 +57559,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.11.3";
+        version = "1.11.5";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -57845,7 +57760,10 @@
             this.bodyBottomStyleCache = new Map();
             internalProps.stick = { changedCells: new Map() };
             internalProps.customMergeCell = options.customMergeCell;
-            this.customCellStylePlugin = new CustomCellStylePlugin(this, options.customCellStyle ?? [], options.customCellStyleArrangement ?? []);
+            const CustomCellStylePlugin = Factory.getComponent('customCellStylePlugin');
+            if (CustomCellStylePlugin) {
+                this.customCellStylePlugin = new CustomCellStylePlugin(this, options.customCellStyle ?? [], options.customCellStyleArrangement ?? []);
+            }
         }
         throttleInvalidate = throttle2(this.render.bind(this), 200);
         getContainer() {
@@ -59064,7 +58982,7 @@
             this.clearColWidthCache();
             this.clearRowHeightCache();
             internalProps.customMergeCell = options.customMergeCell;
-            this.customCellStylePlugin.updateCustomCell(options.customCellStyle ?? [], options.customCellStyleArrangement ?? []);
+            this.customCellStylePlugin?.updateCustomCell(options.customCellStyle ?? [], options.customCellStyleArrangement ?? []);
         }
         renderWithRecreateCells() {
             const oldHoverState = { col: this.stateManager.hover.cellPos.col, row: this.stateManager.hover.cellPos.row };
@@ -60198,13 +60116,13 @@
         changeRecordOrder(source, target) {
         }
         hasCustomCellStyle(customStyleId) {
-            return this.customCellStylePlugin.hasCustomCellStyle(customStyleId);
+            return this.customCellStylePlugin?.hasCustomCellStyle(customStyleId);
         }
         registerCustomCellStyle(customStyleId, customStyle) {
-            this.customCellStylePlugin.registerCustomCellStyle(customStyleId, customStyle);
+            this.customCellStylePlugin?.registerCustomCellStyle(customStyleId, customStyle);
         }
         arrangeCustomCellStyle(cellPos, customStyleId) {
-            this.customCellStylePlugin.arrangeCustomCellStyle(cellPos, customStyleId);
+            this.customCellStylePlugin?.arrangeCustomCellStyle(cellPos, customStyleId);
         }
         isSeriesNumber(col, row) {
             return this.internalProps.layoutMap.isSeriesNumber(col, row);
@@ -69138,6 +69056,7 @@
     registerTitle();
     registerTooltip();
     registerListTreeStickCellPlugin();
+    registerCustomCellStylePlugin();
     registerChartCell();
     registerCheckboxCell();
     registerImageCell();
@@ -74755,10 +74674,27 @@
                 const dimensions = item.dimensions;
                 const width = item.width;
                 const cell = this.getCellAddressByHeaderPaths(dimensions);
-                if (cell.col >= this.rowHeaderLevelCount) {
-                    const cellPath = this.getCellHeaderPaths(cell.col, this.columnHeaderLevelCount - 1);
+                if (cell && cell.col >= this.rowHeaderLevelCount) {
+                    const cellPath = this.getCellHeaderPaths(cell.col, this.columnHeaderLevelCount);
                     if (cellPath.colHeaderPaths.length === dimensions.length) {
-                        if (cell && !this.internalProps._widthResizedColMap.has(cell.col)) {
+                        let match = true;
+                        for (let i = 0; i < dimensions.length; i++) {
+                            const dimension = dimensions[i];
+                            const finded = cellPath.colHeaderPaths.findIndex((colPath, index) => {
+                                if (colPath.indicatorKey === dimension.indicatorKey) {
+                                    return true;
+                                }
+                                if (colPath.dimensionKey === dimension.dimensionKey && colPath.value === dimension.value) {
+                                    return true;
+                                }
+                                return false;
+                            });
+                            if (finded < 0) {
+                                match = false;
+                                break;
+                            }
+                        }
+                        if (match && !this.internalProps._widthResizedColMap.has(cell.col)) {
                             this._setColWidth(cell.col, width);
                             this.internalProps._widthResizedColMap.add(cell.col);
                         }
@@ -77071,269 +77007,8 @@
         return new Radio(params ? params.attribute : {});
     }
 
-    class CarouselAnimationPlugin {
-        table;
-        rowCount;
-        colCount;
-        animationDuration;
-        animationDelay;
-        animationEasing;
-        replaceScrollAction;
-        playing;
-        row;
-        col;
-        willUpdateRow = false;
-        willUpdateCol = false;
-        customDistRowFunction;
-        customDistColFunction;
-        constructor(table, options) {
-            this.table = table;
-            this.rowCount = options?.rowCount ?? undefined;
-            this.colCount = options?.colCount ?? undefined;
-            this.animationDuration = options?.animationDuration ?? 500;
-            this.animationDelay = options?.animationDelay ?? 1000;
-            this.animationEasing = options?.animationEasing ?? 'linear';
-            this.replaceScrollAction = options?.replaceScrollAction ?? false;
-            this.customDistColFunction = options.customDistColFunction;
-            this.customDistRowFunction = options.customDistRowFunction;
-            this.reset();
-            this.init();
-        }
-        init() {
-            if (this.replaceScrollAction) {
-                this.table.disableScroll();
-                this.table.scenegraph.stage.addEventListener('wheel', this.onScrollEnd.bind(this));
-            }
-        }
-        reset() {
-            this.playing = false;
-            this.row = this.table.frozenRowCount;
-            this.col = this.table.frozenColCount;
-        }
-        onScrollEnd(e) {
-            if (this.rowCount) {
-                if (e.deltaY > 0) {
-                    this.row += this.rowCount;
-                    this.row = Math.min(this.row, this.table.rowCount - this.table.frozenRowCount);
-                }
-                else if (e.deltaY < 0) {
-                    this.row -= this.rowCount;
-                    this.row = Math.max(this.row, this.table.frozenRowCount);
-                }
-                this.table.scrollToRow(this.row, { duration: this.animationDuration, easing: this.animationEasing });
-            }
-            else if (this.colCount) {
-                if (e.deltaX > 0) {
-                    this.col += this.colCount;
-                    this.col = Math.min(this.col, this.table.colCount - this.table.frozenColCount);
-                }
-                else if (e.deltaX < 0) {
-                    this.col -= this.colCount;
-                    this.col = Math.max(this.col, this.table.frozenColCount);
-                }
-                this.table.scrollToCol(this.col, { duration: this.animationDuration, easing: this.animationEasing });
-            }
-        }
-        play() {
-            this.playing = true;
-            if (this.rowCount && !this.willUpdateRow) {
-                this.updateRow();
-            }
-            else if (this.colCount && !this.willUpdateCol) {
-                this.updateCol();
-            }
-        }
-        pause() {
-            this.playing = false;
-        }
-        updateRow() {
-            if (!this.playing || this.table.isReleased) {
-                return;
-            }
-            let animation = true;
-            const customRow = this.customDistRowFunction && this.customDistRowFunction(this.row, this.table);
-            if (customRow) {
-                this.row = customRow.distRow;
-                animation = customRow.animation ?? true;
-            }
-            else if (this.table.scenegraph.proxy.screenTopRow !== this.row) {
-                this.row = this.table.frozenRowCount;
-                animation = false;
-            }
-            else {
-                this.row += this.rowCount;
-            }
-            this.table.scrollToRow(this.row, animation ? { duration: this.animationDuration, easing: this.animationEasing } : undefined);
-            this.willUpdateRow = true;
-            setTimeout(() => {
-                this.willUpdateRow = false;
-                this.updateRow();
-            }, this.animationDuration + this.animationDelay);
-        }
-        updateCol() {
-            if (!this.playing || this.table.isReleased) {
-                return;
-            }
-            let animation = true;
-            const customCol = this.customDistColFunction && this.customDistColFunction(this.col, this.table);
-            if (customCol) {
-                this.col = customCol.distCol;
-                animation = customCol.animation ?? true;
-            }
-            else if (this.table.scenegraph.proxy.screenLeftCol !== this.col) {
-                this.col = this.table.frozenColCount;
-                animation = false;
-            }
-            else {
-                this.col += this.colCount;
-            }
-            this.table.scrollToCol(this.col, animation ? { duration: this.animationDuration, easing: this.animationEasing } : undefined);
-            this.willUpdateCol = true;
-            setTimeout(() => {
-                this.willUpdateCol = false;
-                this.updateCol();
-            }, this.animationDuration + this.animationDelay);
-        }
-    }
-
-    class HeaderHighlightPlugin {
-        table;
-        options;
-        colHeaderRange;
-        rowHeaderRange;
-        constructor(table, options) {
-            this.table = table;
-            this.options = options;
-            this.registerStyle();
-            this.bindEvent();
-        }
-        registerStyle() {
-            this.table.registerCustomCellStyle('col-highlight', {
-                bgColor: this.options?.colHighlightBGColor ?? '#82b2f5',
-                color: this.options?.colHighlightColor ?? '#FFF'
-            });
-            this.table.registerCustomCellStyle('row-highlight', {
-                bgColor: this.options?.rowHighlightBGColor ?? '#82b2f5',
-                color: this.options?.rowHighlightColor ?? '#FFF'
-            });
-        }
-        bindEvent() {
-            this.table.on('selected_cell', e => {
-                this.updateHighlight();
-            });
-            this.table.on('selected_clear', () => {
-                this.clearHighlight();
-            });
-            this.table.on('mousemove_table', () => {
-                if (this.table.stateManager.select.selecting) {
-                    this.updateHighlight();
-                }
-            });
-        }
-        clearHighlight() {
-            this.colHeaderRange && this.table.arrangeCustomCellStyle({ range: this.colHeaderRange }, undefined);
-            this.rowHeaderRange && this.table.arrangeCustomCellStyle({ range: this.rowHeaderRange }, undefined);
-            this.colHeaderRange = undefined;
-            this.rowHeaderRange = undefined;
-        }
-        updateHighlight() {
-            if (this.options?.colHighlight === false && this.options?.rowHighlight === false) {
-                return;
-            }
-            const selectRanges = this.table.getSelectedCellRanges();
-            if (selectRanges.length === 0) {
-                this.clearHighlight();
-                return;
-            }
-            const selectRange = selectRanges[0];
-            const rowSelectRange = [selectRange.start.row, selectRange.end.row];
-            rowSelectRange.sort((a, b) => a - b);
-            const colSelectRange = [selectRange.start.col, selectRange.end.col];
-            colSelectRange.sort((a, b) => a - b);
-            let colHeaderRange;
-            let rowHeaderRange;
-            if (this.table.isPivotTable()) {
-                colHeaderRange = {
-                    start: {
-                        col: colSelectRange[0],
-                        row: 0
-                    },
-                    end: {
-                        col: colSelectRange[1],
-                        row: this.table.columnHeaderLevelCount - 1
-                    }
-                };
-                rowHeaderRange = {
-                    start: {
-                        col: 0,
-                        row: rowSelectRange[0]
-                    },
-                    end: {
-                        col: this.table.rowHeaderLevelCount - 1,
-                        row: rowSelectRange[1]
-                    }
-                };
-            }
-            else if (this.table.internalProps.transpose) {
-                rowHeaderRange = {
-                    start: {
-                        col: 0,
-                        row: rowSelectRange[0]
-                    },
-                    end: {
-                        col: this.table.rowHeaderLevelCount - 1,
-                        row: rowSelectRange[1]
-                    }
-                };
-            }
-            else {
-                colHeaderRange = {
-                    start: {
-                        col: colSelectRange[0],
-                        row: 0
-                    },
-                    end: {
-                        col: colSelectRange[1],
-                        row: this.table.columnHeaderLevelCount - 1
-                    }
-                };
-                if (this.table.internalProps.rowSeriesNumber) {
-                    rowHeaderRange = {
-                        start: {
-                            col: 0,
-                            row: rowSelectRange[0]
-                        },
-                        end: {
-                            col: 0,
-                            row: rowSelectRange[1]
-                        }
-                    };
-                }
-            }
-            if (this.options?.colHighlight !== false && !isSameRange(this.colHeaderRange, colHeaderRange)) {
-                this.colHeaderRange && this.table.arrangeCustomCellStyle({ range: this.colHeaderRange }, undefined);
-                colHeaderRange && this.table.arrangeCustomCellStyle({ range: colHeaderRange }, 'col-highlight');
-                this.colHeaderRange = colHeaderRange;
-            }
-            if (this.options?.rowHighlight !== false && !isSameRange(this.rowHeaderRange, rowHeaderRange)) {
-                this.rowHeaderRange && this.table.arrangeCustomCellStyle({ range: this.rowHeaderRange }, undefined);
-                rowHeaderRange && this.table.arrangeCustomCellStyle({ range: rowHeaderRange }, 'row-highlight');
-                this.rowHeaderRange = rowHeaderRange;
-            }
-        }
-    }
-    function isSameRange(a, b) {
-        if (a === undefined && b === undefined) {
-            return true;
-        }
-        if (a === undefined || b === undefined) {
-            return false;
-        }
-        return (a.start.col === b.start.col && a.start.row === b.start.row && a.end.col === b.end.col && a.end.row === b.end.row);
-    }
-
     registerForVrender();
-    const version = "1.11.3";
+    const version = "1.11.5";
     function getIcons() {
         return get$2();
     }
@@ -77341,12 +77016,9 @@
         clearAll();
     }
 
-    exports.CarouselAnimationPlugin = CarouselAnimationPlugin;
     exports.CustomLayout = index;
     exports.DataStatistics = DataStatistics;
     exports.EventTarget = EventTarget$1;
-    exports.HeaderHighlightPlugin = HeaderHighlightPlugin;
-    exports.InvertHighlightPlugin = InvertHighlightPlugin;
     exports.ListTable = ListTableAll;
     exports.ListTableSimple = ListTableSimple;
     exports.PIVOT_CHART_EVENT_TYPE = PIVOT_CHART_EVENT_TYPE;
@@ -77379,7 +77051,6 @@
     exports.getTargetCell = getTargetCell;
     exports.graphicUtil = graphicUtil;
     exports.jsx = jsx;
-    exports.onBeforeAttributeUpdateForInvertHighlight = onBeforeAttributeUpdateForInvertHighlight;
     exports.register = register$1;
     exports.registerAxis = registerAxis;
     exports.registerChartCell = registerChartCell;