@canvas-components/list-table 0.3.24 → 0.3.26

package/dist/index.cjs

@@ -1058,6 +1058,11 @@ function getNextRightFixedInsertIndex(columns) {
 }
 
 // src/features/header-settings/header-settings-feature.ts
+function haveVisibleLeafColumnsChanged(previous, next) {
+  if (previous.length !== next.length) return true;
+  const previousKeys = new Set(previous.map((column) => column.key));
+  return next.some((column) => !previousKeys.has(column.key));
+}
 function cloneColumns(columns) {
   return columns.map((column) => ({
     ...column,
@@ -1184,6 +1189,7 @@ function saveHeaderSettingsColumn(columns, draft) {
     existing.minWidth = minWidth;
     existing.maxWidth = maxWidth;
     if (draft.order != null) moveColumnToOrder(siblings, existing, draft.order);
+    draft.key = resolveColumnKey(existing);
     return null;
   }
   const dataIndex = draft.dataIndex?.trim();
@@ -1209,6 +1215,7 @@ function saveHeaderSettingsColumn(columns, draft) {
   } else if (!existing) {
     siblings.splice((draft.order ?? maxOrder) - 1, 0, column);
   }
+  draft.key = resolveColumnKey(column);
   return null;
 }
 function findSiblingColumnsByKey(columns, key) {
@@ -1306,6 +1313,9 @@ function toggleHeaderColumnVisibility(params) {
   };
 }
 function resolveCollapsedHeaderColumnMarkers(params) {
+  if (params.showCollapsedColumnIcon === false) {
+    return [];
+  }
   ensureColumnKeysInPlace(params.columns);
   const allLeafKeys = collectLeafColumnKeys(params.columns);
   const excludedKeySet = new Set(params.excludedColumnKeys ?? []);
@@ -1482,6 +1492,7 @@ function buildHeaderSettingsItem(column, totalVisibleLeafCount, parentHidden, or
     minWidth: column.minWidth,
     maxWidth: column.maxWidth,
     fixed: column.fixed,
+    sortable: !column.children?.length && column.allowSort !== false && column.sorter !== false,
     order,
     siblingCount,
     checked,
@@ -1642,6 +1653,23 @@ function applyThemeVariables(wrapper, theme) {
   );
 }
 
+// src/interaction/pointer.ts
+function getCanvasPointerPosition(canvas, clientX, clientY) {
+  const rect = canvas.getBoundingClientRect();
+  const scale = getElementViewportScale(canvas, rect);
+  return {
+    x: (clientX - rect.left) / scale.x,
+    y: (clientY - rect.top) / scale.y
+  };
+}
+function getElementViewportScale(element, rect = element.getBoundingClientRect()) {
+  const resolveScale = (viewportSize, layoutSize) => layoutSize > 0 && Math.abs(viewportSize - layoutSize) >= 1 ? viewportSize / layoutSize : 1;
+  return {
+    x: resolveScale(rect.width, element.clientWidth),
+    y: resolveScale(rect.height, element.clientHeight)
+  };
+}
+
 // src/adapters/dom-host.ts
 var RESIZE_RENDER_SETTLE_DELAY = 240;
 var ListTableDomHost = class {
@@ -1811,23 +1839,27 @@ var ListTableDomHost = class {
     return this.nodes;
   }
   toViewportPoint(x, y) {
-    const hostRect = this.nodes?.canvasHostElement.getBoundingClientRect();
-    if (!hostRect) {
+    const hostElement = this.nodes?.canvasHostElement;
+    const hostRect = hostElement?.getBoundingClientRect();
+    if (!hostElement || !hostRect) {
       return { x, y };
     }
+    const scale = getElementViewportScale(hostElement, hostRect);
     return {
-      x: hostRect.left + x * this.contentZoom,
-      y: hostRect.top + y * this.contentZoom
+      x: hostRect.left + x * this.contentZoom * scale.x,
+      y: hostRect.top + y * this.contentZoom * scale.y
     };
   }
   toViewportRect(rect) {
     const point = this.toViewportPoint(rect.x, rect.y);
+    const hostElement = this.nodes?.canvasHostElement;
+    const scale = hostElement ? getElementViewportScale(hostElement) : { x: 1, y: 1 };
     return {
       ...rect,
       x: point.x,
       y: point.y,
-      width: rect.width * this.contentZoom,
-      height: rect.height * this.contentZoom
+      width: rect.width * this.contentZoom * scale.x,
+      height: rect.height * this.contentZoom * scale.y
     };
   }
   getCanvasViewportRect() {
@@ -1881,15 +1913,6 @@ var ListTableDomHost = class {
   }
 };
 
-// src/interaction/pointer.ts
-function getCanvasPointerPosition(canvas, clientX, clientY) {
-  const rect = canvas.getBoundingClientRect();
-  return {
-    x: clientX - rect.left,
-    y: clientY - rect.top
-  };
-}
-
 // src/adapters/canvas-host.ts
 var ListTableCanvasHost = class {
   constructor() {
@@ -2134,7 +2157,7 @@ function createEmptySelection() {
   };
 }
 function resolveAdjacentCellSelection(params) {
-  const { selection, rowCount, columnKeys, direction } = params;
+  const { selection, rowCount, columnKeys, direction, verticalWrap = true } = params;
   if (selection.rowIndex == null || selection.columnKey == null || selection.rowIndex < 0 || selection.rowIndex >= rowCount) {
     return null;
   }
@@ -2143,6 +2166,10 @@ function resolveAdjacentCellSelection(params) {
     return null;
   }
   if (direction === "up" || direction === "down") {
+    const nextRowIndex = selection.rowIndex + (direction === "up" ? -1 : 1);
+    if (!verticalWrap) {
+      return nextRowIndex < 0 || nextRowIndex >= rowCount ? null : { rowIndex: nextRowIndex, columnKey: selection.columnKey };
+    }
     const flatIndex = columnIndex * rowCount + selection.rowIndex;
     const nextFlatIndex = flatIndex + (direction === "up" ? -1 : 1);
     const cellCount = rowCount * columnKeys.length;
@@ -2165,7 +2192,7 @@ function resolveAdjacentCellSelection(params) {
   };
 }
 function resolveTabCellSelection(params) {
-  const { selection, rowCount, columnKeys, reverse = false } = params;
+  const { selection, rowCount, columnKeys, reverse = false, tabWrap = true } = params;
   if (selection.rowIndex == null || selection.columnKey == null || selection.rowIndex < 0 || selection.rowIndex >= rowCount || columnKeys.length === 0) {
     return null;
   }
@@ -2173,6 +2200,13 @@ function resolveTabCellSelection(params) {
   if (columnIndex < 0) {
     return null;
   }
+  if (!tabWrap) {
+    const nextColumnIndex = columnIndex + (reverse ? -1 : 1);
+    return nextColumnIndex < 0 || nextColumnIndex >= columnKeys.length ? null : {
+      rowIndex: selection.rowIndex,
+      columnKey: columnKeys[nextColumnIndex]
+    };
+  }
   const flatIndex = selection.rowIndex * columnKeys.length + columnIndex;
   const nextFlatIndex = flatIndex + (reverse ? -1 : 1);
   const cellCount = rowCount * columnKeys.length;
@@ -3287,14 +3321,17 @@ function mapKindToArea(kind, actionType) {
 }
 function getPriority(descriptor) {
   let priority = getBasePriority(descriptor.kind);
+  if (descriptor.debugNodeType === "header-edit-icon" || descriptor.debugNodeType === "nested-table-header-edit-icon") {
+    priority += 1;
+  }
   if (descriptor.kind === "summary" && descriptor.columnKey) {
     priority += 1;
   }
   if ((descriptor.kind === "body" || descriptor.kind === "body-content" || descriptor.kind === "body-control") && descriptor.frozen) {
     priority += 2;
   }
-  if (descriptor.kind === "body" && descriptor.fixed) {
-    priority += 1;
+  if ((descriptor.kind === "body" || descriptor.kind === "body-content" || descriptor.kind === "body-control") && descriptor.fixed) {
+    priority += 2;
   }
   if (isHeaderDescriptor(descriptor.kind) && descriptor.fixed) {
     priority += 3;
@@ -3314,6 +3351,9 @@ function getBasePriority(kind) {
       return 2;
     case "resize-handle":
       return 4;
+    // 折叠列图标覆盖列宽热区，但仍低于固定列表头的遮挡层（优先级 5）。
+    case "column-collapse-trigger":
+      return 4.5;
     case "header-action":
       return 3;
     case "header-selection":
@@ -3326,7 +3366,6 @@ function getBasePriority(kind) {
       return 2;
     case "expand-trigger":
     case "collapse-trigger":
-    case "column-collapse-trigger":
       return 3;
     case "expanded-row":
     case "body":
@@ -3485,6 +3524,60 @@ function applyListTableRenderPassResult(params) {
   params.setScrollPageSize(projection.scrollPageSize);
 }
 
+// src/rendering/cell-content/text-measure-cache.ts
+var MAX_ENTRIES = 2048;
+var MAX_TEXT_LENGTH = 512;
+var fontRevisions = /* @__PURE__ */ new WeakMap();
+var contextCaches = /* @__PURE__ */ new WeakMap();
+function measureCachedText(ctx, text) {
+  const fonts = ctx.canvas?.ownerDocument?.fonts;
+  let fontRevision = 0;
+  if (fonts) {
+    let revision = fontRevisions.get(fonts);
+    if (!revision) {
+      revision = { value: 0 };
+      fontRevisions.set(fonts, revision);
+      const invalidate = () => {
+        revision.value += 1;
+      };
+      fonts.addEventListener("loadingdone", invalidate);
+      fonts.addEventListener("loadingerror", invalidate);
+    }
+    fontRevision = revision.value;
+    if (fonts.status === "loading") {
+      contextCaches.delete(ctx);
+      return ctx.measureText(text);
+    }
+  }
+  if (text.length > MAX_TEXT_LENGTH) return ctx.measureText(text);
+  let cache = contextCaches.get(ctx);
+  if (!cache || cache.fontRevision !== fontRevision) {
+    cache = { fontRevision, entries: /* @__PURE__ */ new Map() };
+    contextCaches.set(ctx, cache);
+  }
+  const key = JSON.stringify([
+    ctx.font,
+    ctx.textAlign,
+    ctx.textBaseline,
+    ctx.direction,
+    ctx.fontKerning,
+    ctx.fontStretch,
+    ctx.fontVariantCaps,
+    ctx.letterSpacing,
+    ctx.wordSpacing,
+    ctx.textRendering,
+    text
+  ]);
+  const cached = cache.entries.get(key);
+  if (cached) return cached;
+  const metrics = ctx.measureText(text);
+  if (cache.entries.size >= MAX_ENTRIES) {
+    cache.entries.delete(cache.entries.keys().next().value);
+  }
+  cache.entries.set(key, metrics);
+  return metrics;
+}
+
 // src/rendering/cell-content/content-style.ts
 function resolveContentFontSize(content, fallbackFontSize) {
   return content.style?.fontSize ?? content.fontSize ?? fallbackFontSize;
@@ -3545,7 +3638,7 @@ function buildCanvasFont(params) {
   return `${fontWeight} ${fontSize}px ${fontFamily}`.trim();
 }
 function measureTextBounds(ctx, text) {
-  const metrics = ctx.measureText(text);
+  const metrics = measureCachedText(ctx, text);
   const ascent = metrics.actualBoundingBoxAscent || 0;
   const descent = metrics.actualBoundingBoxDescent || 0;
   const width = metrics.width;
@@ -5200,11 +5293,41 @@ function drawHeaderActionGlyph(ctx, rect, actionType, color = "#8c8c8c", sortOrd
     ctx.fill();
   } else if (actionType === "filter") {
     drawFilterIcon(ctx, rect);
-  } else {
+  } else if (actionType === "fixed") {
     drawFixedPinIcon(ctx, rect);
+  } else {
+    drawEditIcon(ctx, rect);
   }
   ctx.restore();
 }
+function drawEditIcon(ctx, rect) {
+  const scale = Math.min(rect.width, rect.height) / 14;
+  const x = rect.x + (rect.width - 14 * scale) / 2;
+  const y = rect.y + (rect.height - 14 * scale) / 2;
+  ctx.save();
+  ctx.translate(x, y);
+  ctx.scale(scale, scale);
+  ctx.beginPath();
+  ctx.moveTo(1.5, 10.15);
+  ctx.lineTo(9.4, 2.25);
+  ctx.lineTo(11.75, 4.6);
+  ctx.lineTo(3.85, 12.5);
+  ctx.lineTo(1.3, 12.7);
+  ctx.closePath();
+  ctx.fill();
+  ctx.beginPath();
+  ctx.moveTo(10.05, 1.6);
+  ctx.lineTo(10.7, 0.95);
+  ctx.lineTo(11.4, 0.6);
+  ctx.lineTo(12.1, 0.95);
+  ctx.lineTo(13.05, 1.9);
+  ctx.lineTo(13.4, 2.6);
+  ctx.lineTo(13.05, 3.3);
+  ctx.lineTo(12.4, 3.95);
+  ctx.closePath();
+  ctx.fill();
+  ctx.restore();
+}
 function drawFilterIcon(ctx, rect) {
   const iconWidth = rect.width * 0.92;
   const iconHeight = rect.height * 0.7;
@@ -7455,6 +7578,19 @@ function sortRows(rows, sortState, leafColumns) {
     return 0;
   });
 }
+async function sortRowsAsync(params) {
+  const { rows, signal } = params;
+  const indices = await sortRowIndicesAsync(params);
+  if (!indices) {
+    return rows;
+  }
+  return materializeRows({
+    rows,
+    indices,
+    signal,
+    abortMessage: "sort rows aborted"
+  });
+}
 async function sortRowIndicesAsync(params) {
   let rowIndices = params.rowIndices ?? null;
   const sorters = orderSortingState(params.sortState);
@@ -7698,6 +7834,21 @@ async function mapToSourceRowIndices(params) {
   recordQueryStageDuration(params.trace, "indexMapping", mappingStartedAt);
   return result;
 }
+async function materializeRows(params) {
+  const { rows, indices, signal, abortMessage } = params;
+  const result = Array(indices.length);
+  let sliceStartedAt = getTaskNow();
+  for (let index = 0; index < indices.length; index += 1) {
+    throwIfTaskAborted(signal, abortMessage);
+    result[index] = rows[indices[index]];
+    if ((index + 1) % ASYNC_QUERY_SLICE_ITEM_LIMIT === 0 || (index + 1) % 256 === 0 && isTaskSliceExpired(sliceStartedAt)) {
+      await yieldToMainThread();
+      throwIfTaskAborted(signal, abortMessage);
+      sliceStartedAt = getTaskNow();
+    }
+  }
+  return result;
+}
 function isAbortError(error) {
   return error instanceof Error && error.name === "AbortError";
 }
@@ -8090,12 +8241,17 @@ function toQueryFilters(filters) {
   );
 }
 function toQuerySorter(sortState, leafColumns) {
-  return orderSortingState(sortState).map((item) => ({
-    columnKey: item.key,
-    field: leafColumns.find((column) => column.key === item.key)?.dataIndex,
-    order: item.order,
-    priority: item.priority
-  }));
+  return orderSortingState(sortState).map((item) => {
+    const column = leafColumns.find((candidate) => candidate.key === item.key);
+    const animation = typeof column?.sorter === "object" ? column.sorter.animation : void 0;
+    return {
+      columnKey: item.key,
+      field: column?.dataIndex,
+      order: item.order,
+      priority: item.priority,
+      ...animation === void 0 ? {} : { animation }
+    };
+  });
 }
 function getActiveFilterColumnKeys(filters) {
   return Object.entries(filters).filter(([, value]) => isMeaningfulFilterValue(value)).map(([columnKey]) => columnKey);
@@ -8468,6 +8624,7 @@ function resolveHeaderTextLayout(params) {
     actionVisibilityState,
     allowActions,
     hasFilter,
+    hasEdit = false,
     contentInsetStart = 0,
     contentInsetEnd = 0,
     paddingInline = HEADER_TEXT_PADDING
@@ -8499,14 +8656,23 @@ function resolveHeaderTextLayout(params) {
     maxWidth: Math.max(contentVisibleRect.width - paddingInline * 2, 12),
     x: baseX
   };
-  if (!allowActions || !actionVisibilityState.visible || align === "left") {
+  if (!allowActions || !actionVisibilityState.visible) {
     return baseLayout;
   }
   const actionLayout = getHeaderActionLayout({
     rect,
     hasFilter,
+    hasEdit,
+    visibilityState: actionVisibilityState,
     trailingInset: contentInsetEnd
   });
+  if (align === "left") {
+    if (!hasEdit) return baseLayout;
+    return {
+      ...baseLayout,
+      maxWidth: Math.max(actionLayout.startX - baseX - paddingInline, 0)
+    };
+  }
   const textRight = Math.min(
     contentVisibleRect.x + contentVisibleRect.width - paddingInline,
     actionLayout.startX - paddingInline
@@ -8537,11 +8703,14 @@ function resolveHeaderTextLayout(params) {
   };
 }
 function getHeaderActionLayout(params) {
-  const actionTypes = ["sort"];
-  if (params.hasFilter) {
-    actionTypes.push("filter");
-  }
-  actionTypes.push("fixed");
+  const editOnly = params.hasEdit && params.visibilityState != null && !params.visibilityState.hovered && !params.visibilityState.sorted && !params.visibilityState.filtered && !params.visibilityState.fixed;
+  const actionTypes = [];
+  if (!editOnly) {
+    actionTypes.push("sort");
+    if (params.hasFilter) actionTypes.push("filter");
+    actionTypes.push("fixed");
+  }
+  if (params.hasEdit) actionTypes.push("edit");
   const totalWidth = ACTION_SIZE * actionTypes.length + ACTION_GAP * Math.max(actionTypes.length - 1, 0);
   return {
     actionTypes,
@@ -8592,6 +8761,9 @@ function drawHeaderLayer(params, layer) {
       if (cell.layer !== layer) {
         return;
       }
+      if (layer === "center" && centerClipRect && (cell.x + cell.width < centerClipRect.x - 1 || cell.x > centerClipRect.x + centerClipRect.width + 1)) {
+        return;
+      }
       if (layer === "center" && centerClipRect) {
         params.ctx.save();
         params.ctx.beginPath();
@@ -8637,7 +8809,11 @@ function drawHeaderCell(params, cell, clipRect) {
   };
   ctx.save();
   const isSelected = isHeaderCellSelected(params, cell.node.key, rect);
-  const isRangeSelected = isHeaderCellInRange(params.rangeHighlight, cell);
+  const isRangeSelected = isHeaderCellInRange(
+    params.rangeHighlight,
+    cell,
+    params.leafColumnKeys
+  );
   ctx.fillStyle = isSelected || isRangeSelected ? theme.selectionBackgroundColor : cell.node.style?.backgroundColor ?? theme.headerBackgroundColor;
   ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
   drawGridRect(
@@ -8661,13 +8837,15 @@ function drawHeaderCell(params, cell, clipRect) {
   );
   const isExpandSystemColumn = cell.node.children.length === 0 && cell.node.column.meta?.systemType === "expandable";
   const isRowSelectorSystemColumn = cell.node.children.length === 0 && cell.node.column.meta?.systemType === "rowSelector";
+  const isEditableLeaf = cell.node.children.length === 0 && !!cell.node.column.editable;
   const visibleState = getHeaderActionVisibilityState(
     cell.node.key,
     params.hoveredColumnKey,
     params.sortState.find((item) => item.key === cell.node.key)?.key ?? null,
     params.filteredColumnKeys,
     params.filterableColumnKeys,
-    params.fixedColumnKeys
+    params.fixedColumnKeys,
+    isEditableLeaf
   );
   const titleContent = cell.node.titleContent ?? [
     { type: "text", text: cell.node.title }
@@ -8679,6 +8857,7 @@ function drawHeaderCell(params, cell, clipRect) {
     actionVisibilityState: visibleState,
     allowActions: cell.node.children.length === 0,
     hasFilter: params.filterableColumnKeys.has(cell.node.key),
+    hasEdit: isEditableLeaf,
     contentWidth: measureHeaderContentWidth(ctx, titleContent),
     paddingInline: cell.node.style?.paddingInline,
     contentInsetStart: resolveHeaderContentInsetStart({
@@ -8711,6 +8890,7 @@ function drawHeaderCell(params, cell, clipRect) {
         rect: getHeaderSelectionRect(rect),
         columnKey: cell.node.key,
         controlType: params.rowSelection.type,
+        cursor: params.rowSelection.disabled ? "not-allowed" : "pointer",
         fixed: cell.node.fixed
       });
     }
@@ -8801,7 +8981,9 @@ function drawHeaderCell(params, cell, clipRect) {
       cell.node.key,
       visibleState,
       cell.node.fixed,
-      visibleRect
+      visibleRect,
+      isEditableLeaf,
+      isSelected || isRangeSelected
     );
     drawResizeHandles(params, rect, cell.node.key, cell.node.fixed);
   }
@@ -8837,11 +9019,11 @@ function resolveHeaderContentCenterY(rect, contents, fontSize, paddingBlock, ver
 function measureHeaderContentWidth(ctx, contents) {
   const gap = 4;
   return contents.reduce(
-    (sum, content) => sum + (content.type === "img" ? Math.max(content.width ?? content.height ?? 16, 1) : ctx.measureText(content.text).width),
+    (sum, content) => sum + (content.type === "img" ? Math.max(content.width ?? content.height ?? 16, 1) : measureCachedText(ctx, content.text).width),
     0
   ) + Math.max(contents.length - 1, 0) * gap;
 }
-function drawHeaderActions(params, rect, columnKey, visibilityState, fixed, visibleRect = rect) {
+function drawHeaderActions(params, rect, columnKey, visibilityState, fixed, visibleRect = rect, hasEdit = false, selected = false) {
   if (!visibilityState.visible) {
     return;
   }
@@ -8853,6 +9035,8 @@ function drawHeaderActions(params, rect, columnKey, visibilityState, fixed, visi
   const actionLayout = getHeaderActionLayout({
     rect,
     hasFilter: params.filterableColumnKeys.has(columnKey),
+    hasEdit,
+    visibilityState,
     trailingInset: resolveCollapsedColumnMarkerSet(
       params.collapsedColumnMarkers,
       columnKey
@@ -8860,7 +9044,7 @@ function drawHeaderActions(params, rect, columnKey, visibilityState, fixed, visi
   });
   const { actionTypes, startX, totalWidth } = actionLayout;
   const centerY = rect.y + rect.height / 2;
-  const headerSelected = isHeaderCellSelected(params, columnKey, rect);
+  const headerSelected = selected || isHeaderCellSelected(params, columnKey, rect);
   ctx.save();
   ctx.fillStyle = headerSelected ? params.theme.selectionBackgroundColor : params.theme.headerBackgroundColor;
   ctx.beginPath();
@@ -8882,6 +9066,28 @@ function drawHeaderActions(params, rect, columnKey, visibilityState, fixed, visi
       width: ACTION_SIZE2,
       height: ACTION_SIZE2
     };
+    if (actionType === "edit") {
+      drawHeaderActionIcon(
+        ctx,
+        actionRect,
+        "edit",
+        true,
+        false,
+        headerSelected,
+        params.theme.selectionBackgroundColor
+      );
+      const hitRect2 = intersectRects(actionRect, visibleRect);
+      if (hitRect2)
+        descriptors.push({
+          kind: "header",
+          rect: hitRect2,
+          columnKey,
+          fixed,
+          debugNodeType: "header-edit-icon",
+          debugText: "\u5F53\u524D\u5217\u53EF\u7F16\u8F91"
+        });
+      return;
+    }
     const iconHovered = params.hoveredColumnKey === columnKey && params.hoveredActionType === (actionType === "sort" ? "sort-trigger" : actionType === "filter" ? "filter-trigger" : "fixed-trigger");
     drawHeaderActionIcon(
       ctx,
@@ -8900,6 +9106,7 @@ function drawHeaderActions(params, rect, columnKey, visibilityState, fixed, visi
       rect: hitRect,
       columnKey,
       actionType,
+      cursor: "pointer",
       visibilityState,
       fixed
     });
@@ -8959,11 +9166,16 @@ function isHeaderCellSelected(params, columnKey, rect) {
   }
   return isSameRect(params.selectedHeaderRect, rect);
 }
-function isHeaderCellInRange(rangeHighlight, cell) {
-  const range = (rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT).selectedColumnRange;
-  if (!range) {
-    return false;
+function isHeaderCellInRange(rangeHighlight, cell, leafColumnKeys) {
+  const state = rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT;
+  if (state.selectedColumnKeys != null) {
+    if (leafColumnKeys) {
+      return leafColumnKeys.slice(cell.node.leafStartIndex, cell.node.leafEndIndex + 1).some((key) => state.selectedColumnKeys?.includes(key));
+    }
+    return state.selectedColumnKeys.includes(cell.node.key);
   }
+  const range = state.selectedColumnRange;
+  if (!range) return false;
   return cell.node.leafStartIndex <= range.end && cell.node.leafEndIndex >= range.start;
 }
 function isSameRect(left, right) {
@@ -9028,7 +9240,7 @@ function getHeaderSelectionRect(rect) {
     height: size
   };
 }
-function getHeaderActionVisibilityState(columnKey, hoveredColumnKey, sortedColumnKey, filteredColumnKeys, filterableColumnKeys, fixedColumnKeys) {
+function getHeaderActionVisibilityState(columnKey, hoveredColumnKey, sortedColumnKey, filteredColumnKeys, filterableColumnKeys, fixedColumnKeys, editable) {
   const hovered = hoveredColumnKey === columnKey;
   const sorted = sortedColumnKey === columnKey;
   const filtered = filterableColumnKeys.has(columnKey) && filteredColumnKeys.has(columnKey);
@@ -9038,7 +9250,7 @@ function getHeaderActionVisibilityState(columnKey, hoveredColumnKey, sortedColum
     sorted,
     filtered,
     fixed,
-    visible: hovered || sorted || filtered || fixed
+    visible: hovered || sorted || filtered || fixed || editable
   };
 }
 function getActionActive(actionType, visibilityState) {
@@ -9073,7 +9285,7 @@ function drawHeaderActionIcon(ctx, rect, actionType, active, hovered = false, se
 function drawHeaderContent(ctx, contents, x, y, maxWidth, align, requestRender) {
   const gap = 4;
   const widths = contents.map(
-    (content) => content.type === "img" ? Math.max(content.width ?? content.height ?? 16, 1) : ctx.measureText(content.text).width
+    (content) => content.type === "img" ? Math.max(content.width ?? content.height ?? 16, 1) : measureCachedText(ctx, content.text).width
   );
   const totalWidth = widths.reduce((sum, width) => sum + width, 0) + Math.max(contents.length - 1, 0) * gap;
   const displayWidth = Math.min(totalWidth, Math.max(maxWidth, 0));
@@ -9098,19 +9310,19 @@ function drawHeaderContent(ctx, contents, x, y, maxWidth, align, requestRender)
     ctx.textAlign = "left";
     const text = ellipsisText(ctx, content.text, availableWidth);
     ctx.fillText(text, cursorX, y);
-    cursorX += Math.min(ctx.measureText(text).width, availableWidth) + gap;
+    cursorX += Math.min(measureCachedText(ctx, text).width, availableWidth) + gap;
     ctx.restore();
   });
 }
 function ellipsisText(ctx, text, maxWidth) {
-  if (ctx.measureText(text).width <= maxWidth) {
+  if (measureCachedText(ctx, text).width <= maxWidth) {
     return text;
   }
   const ellipsis = "...";
   let content = text;
   while (content.length > 0) {
     content = content.slice(0, -1);
-    const measured = ctx.measureText(`${content}${ellipsis}`).width;
+    const measured = measureCachedText(ctx, `${content}${ellipsis}`).width;
     if (measured <= maxWidth) {
       return `${content}${ellipsis}`;
     }
@@ -9214,6 +9426,544 @@ function findCellByKey(headerRows, columnKey) {
   }
   return null;
 }
+
+// src/services/range-highlight-service.ts
+var EMPTY_RANGE_HIGHLIGHT_STATE = {
+  selectedRowAnchorIndex: null,
+  selectedRowRange: null,
+  selectedColumnAnchorKey: null,
+  selectedColumnRange: null
+};
+function isIndexInHighlightRange(index, range) {
+  return Boolean(range && index >= range.start && index <= range.end);
+}
+function isColumnInHighlight(state, columnKey, columnIndex) {
+  return state.selectedColumnKeys != null ? state.selectedColumnKeys.includes(columnKey) : isIndexInHighlightRange(columnIndex, state.selectedColumnRange);
+}
+function isRowInHighlight(state, rowIndex) {
+  const ranges = state.selectedRowRanges ?? (state.selectedRowRange ? [state.selectedRowRange] : []);
+  return ranges.some((range) => isIndexInHighlightRange(rowIndex, range));
+}
+function isCellInHighlight(state, rowIndex, columnIndex) {
+  const ranges = state.selectedCellRanges ?? (state.selectedCellRange ? [state.selectedCellRange] : []);
+  return ranges.some(
+    (range) => rowIndex >= range.startRowIndex && rowIndex <= range.endRowIndex && columnIndex >= range.startColumnIndex && columnIndex <= range.endColumnIndex
+  );
+}
+function resolveRowHighlightForSelectorClick(params) {
+  const rowIndex = Math.max(0, Math.floor(params.rowIndex));
+  const base = {
+    ...params.current,
+    selectedColumnAnchorKey: null,
+    selectedColumnRange: null,
+    selectedColumnKeys: null,
+    selectedCellRange: params.ctrlKey ? params.current.selectedCellRange ?? null : null,
+    selectedCellRanges: params.ctrlKey ? params.current.selectedCellRanges ?? null : null,
+    selectedCellAnchor: params.ctrlKey ? params.current.selectedCellAnchor ?? null : null
+  };
+  if (params.ctrlKey) {
+    const ranges = params.current.selectedRowRanges ?? (params.current.selectedRowRange ? [params.current.selectedRowRange] : []);
+    const nextRanges = ranges.flatMap((range) => {
+      if (!isIndexInHighlightRange(rowIndex, range)) return [range];
+      return [
+        ...range.start < rowIndex ? [{ start: range.start, end: rowIndex - 1 }] : [],
+        ...rowIndex < range.end ? [{ start: rowIndex + 1, end: range.end }] : []
+      ];
+    });
+    if (!ranges.some((range) => isIndexInHighlightRange(rowIndex, range))) {
+      nextRanges.push({ start: rowIndex, end: rowIndex });
+    }
+    nextRanges.sort((left, right) => left.start - right.start);
+    return {
+      ...base,
+      selectedRowAnchorIndex: nextRanges.length ? isRowInHighlight(
+        { selectedRowRange: null, selectedRowRanges: nextRanges },
+        rowIndex
+      ) ? rowIndex : nextRanges[nextRanges.length - 1].end : null,
+      selectedRowRange: null,
+      selectedRowRanges: nextRanges
+    };
+  }
+  const anchor = params.shiftKey ? params.current.selectedRowAnchorIndex ?? rowIndex : rowIndex;
+  return {
+    ...base,
+    selectedRowAnchorIndex: anchor,
+    selectedRowRange: createHighlightRange(anchor, rowIndex),
+    selectedRowRanges: null
+  };
+}
+function resolveCellHighlightForClick(params) {
+  const columnIndex = params.leafColumnKeys.indexOf(params.columnKey);
+  if (columnIndex < 0) return params.current;
+  const base = {
+    ...params.current,
+    selectedRowAnchorIndex: params.ctrlKey && params.preserveRowSelection ? params.current.selectedRowAnchorIndex : null,
+    selectedRowRange: params.ctrlKey && params.preserveRowSelection ? params.current.selectedRowRange : null,
+    selectedRowRanges: params.ctrlKey && params.preserveRowSelection ? params.current.selectedRowRanges ?? null : null,
+    selectedColumnAnchorKey: null,
+    selectedColumnRange: null,
+    selectedColumnKeys: null
+  };
+  if (params.shiftKey && !params.ctrlKey) {
+    const anchor = params.current.selectedCellAnchor ?? params.previousCell ?? {
+      rowIndex: params.rowIndex,
+      columnKey: params.columnKey
+    };
+    const anchorColumnIndex = params.leafColumnKeys.indexOf(anchor.columnKey);
+    return {
+      ...base,
+      selectedCellAnchor: anchor,
+      selectedCellRange: {
+        startRowIndex: Math.min(anchor.rowIndex, params.rowIndex),
+        endRowIndex: Math.max(anchor.rowIndex, params.rowIndex),
+        startColumnIndex: Math.min(
+          anchorColumnIndex < 0 ? columnIndex : anchorColumnIndex,
+          columnIndex
+        ),
+        endColumnIndex: Math.max(
+          anchorColumnIndex < 0 ? columnIndex : anchorColumnIndex,
+          columnIndex
+        )
+      },
+      selectedCellRanges: null
+    };
+  }
+  if (params.ctrlKey) {
+    const previous = params.previousCell;
+    const previousColumnIndex = previous ? params.leafColumnKeys.indexOf(previous.columnKey) : -1;
+    const ranges = params.current.selectedCellRanges ?? (params.current.selectedCellRange ? [params.current.selectedCellRange] : previous && previousColumnIndex >= 0 ? [
+      {
+        startRowIndex: previous.rowIndex,
+        endRowIndex: previous.rowIndex,
+        startColumnIndex: previousColumnIndex,
+        endColumnIndex: previousColumnIndex
+      }
+    ] : []);
+    const selected = ranges.some(
+      (range) => isCellInHighlight(
+        { selectedCellRange: range },
+        params.rowIndex,
+        columnIndex
+      )
+    );
+    const nextRanges = selected ? ranges.flatMap(
+      (range) => removeCellFromHighlightRange(range, params.rowIndex, columnIndex)
+    ) : [
+      ...ranges,
+      {
+        startRowIndex: params.rowIndex,
+        endRowIndex: params.rowIndex,
+        startColumnIndex: columnIndex,
+        endColumnIndex: columnIndex
+      }
+    ];
+    return {
+      ...base,
+      selectedCellAnchor: selected ? params.current.selectedCellAnchor ?? null : {
+        rowIndex: params.rowIndex,
+        columnKey: params.columnKey
+      },
+      selectedCellRange: null,
+      selectedCellRanges: nextRanges
+    };
+  }
+  return {
+    ...params.current,
+    selectedCellAnchor: {
+      rowIndex: params.rowIndex,
+      columnKey: params.columnKey
+    },
+    selectedCellRange: null,
+    selectedCellRanges: null
+  };
+}
+function removeCellFromHighlightRange(range, rowIndex, columnIndex) {
+  return subtractCellHighlightRange(range, {
+    startRowIndex: rowIndex,
+    endRowIndex: rowIndex,
+    startColumnIndex: columnIndex,
+    endColumnIndex: columnIndex
+  });
+}
+function subtractCellHighlightRange(range, cut) {
+  const top = Math.max(range.startRowIndex, cut.startRowIndex);
+  const bottom = Math.min(range.endRowIndex, cut.endRowIndex);
+  const left = Math.max(range.startColumnIndex, cut.startColumnIndex);
+  const right = Math.min(range.endColumnIndex, cut.endColumnIndex);
+  if (top > bottom || left > right) {
+    return [range];
+  }
+  return [
+    ...range.startRowIndex < top ? [{ ...range, endRowIndex: top - 1 }] : [],
+    ...bottom < range.endRowIndex ? [{ ...range, startRowIndex: bottom + 1 }] : [],
+    ...range.startColumnIndex < left ? [
+      {
+        startRowIndex: top,
+        endRowIndex: bottom,
+        startColumnIndex: range.startColumnIndex,
+        endColumnIndex: left - 1
+      }
+    ] : [],
+    ...right < range.endColumnIndex ? [
+      {
+        startRowIndex: top,
+        endRowIndex: bottom,
+        startColumnIndex: right + 1,
+        endColumnIndex: range.endColumnIndex
+      }
+    ] : []
+  ];
+}
+function resolveRowHighlightForDrag(params) {
+  const target = createHighlightRange(params.startRowIndex, params.endRowIndex);
+  const ranges = params.current.selectedRowRanges ?? (params.current.selectedRowRange ? [params.current.selectedRowRange] : []);
+  const nextRanges = params.remove ? ranges.flatMap(
+    (range) => target.end < range.start || target.start > range.end ? [range] : [
+      ...range.start < target.start ? [{ start: range.start, end: target.start - 1 }] : [],
+      ...target.end < range.end ? [{ start: target.end + 1, end: range.end }] : []
+    ]
+  ) : [...ranges, target];
+  nextRanges.sort((left, right) => left.start - right.start);
+  const mergedRanges = nextRanges.reduce(
+    (merged, range) => {
+      const previous = merged[merged.length - 1];
+      if (previous && range.start <= previous.end + 1) {
+        previous.end = Math.max(previous.end, range.end);
+      } else {
+        merged.push({ ...range });
+      }
+      return merged;
+    },
+    []
+  );
+  return {
+    ...params.current,
+    selectedRowAnchorIndex: params.remove ? mergedRanges[mergedRanges.length - 1]?.end ?? null : params.startRowIndex,
+    selectedRowRange: null,
+    selectedRowRanges: mergedRanges,
+    selectedColumnAnchorKey: null,
+    selectedColumnRange: null,
+    selectedColumnKeys: null
+  };
+}
+function resolveCellHighlightForDrag(params) {
+  const target = {
+    startRowIndex: Math.min(params.startRowIndex, params.endRowIndex),
+    endRowIndex: Math.max(params.startRowIndex, params.endRowIndex),
+    startColumnIndex: Math.min(params.startColumnIndex, params.endColumnIndex),
+    endColumnIndex: Math.max(params.startColumnIndex, params.endColumnIndex)
+  };
+  const ranges = params.current.selectedCellRanges ?? (params.current.selectedCellRange ? [params.current.selectedCellRange] : []);
+  return {
+    ...params.current,
+    selectedRowAnchorIndex: params.preserveRowSelection ? params.current.selectedRowAnchorIndex : null,
+    selectedRowRange: params.preserveRowSelection ? params.current.selectedRowRange : null,
+    selectedRowRanges: params.preserveRowSelection ? params.current.selectedRowRanges ?? null : null,
+    selectedColumnAnchorKey: null,
+    selectedColumnRange: null,
+    selectedColumnKeys: null,
+    selectedCellAnchor: {
+      rowIndex: params.startRowIndex,
+      columnKey: params.columnKey
+    },
+    selectedCellRange: null,
+    selectedCellRanges: params.remove ? ranges.flatMap((range) => subtractCellHighlightRange(range, target)) : [...ranges, target]
+  };
+}
+function resolveNextRowHighlight(params) {
+  return resolveNextRowHighlightByIndexRange({
+    current: params.current,
+    rangeStartIndex: params.rowIndex,
+    rangeEndIndex: params.rowIndex,
+    shiftKey: params.shiftKey
+  });
+}
+function resolveNextRowHighlightByIndexRange(params) {
+  const rangeStartIndex = Math.max(0, Math.floor(params.rangeStartIndex));
+  const rangeEndIndex = Math.max(
+    rangeStartIndex,
+    Math.floor(params.rangeEndIndex)
+  );
+  const anchor = params.shiftKey && params.current.selectedRowAnchorIndex != null ? params.current.selectedRowAnchorIndex : rangeStartIndex;
+  return {
+    ...params.current,
+    selectedRowAnchorIndex: anchor,
+    selectedRowRange: createHighlightRange(anchor, rangeEndIndex),
+    selectedRowRanges: null
+  };
+}
+function resolveNextRowHighlightForContextMenu(params) {
+  if (isRowInHighlight(params.current, params.rowIndex)) {
+    return params.current;
+  }
+  return resolveNextRowHighlight({
+    current: params.current,
+    rowIndex: params.rowIndex,
+    shiftKey: false
+  });
+}
+function resolveNextColumnHighlightForContextMenu(params) {
+  const currentRange = params.current.selectedColumnRange;
+  const selectedKeys = params.current.selectedColumnKeys;
+  if (selectedKeys?.length && params.leafColumnKeys.slice(params.rangeStartIndex, params.rangeEndIndex + 1).every((key) => selectedKeys.includes(key))) {
+    return {
+      ...params.current,
+      selectedRowAnchorIndex: null,
+      selectedRowRange: null
+    };
+  }
+  if (currentRange && params.rangeStartIndex >= currentRange.start && params.rangeEndIndex <= currentRange.end) {
+    return {
+      ...params.current,
+      selectedRowAnchorIndex: null,
+      selectedRowRange: null
+    };
+  }
+  return resolveNextColumnHighlightForHeaderClick({
+    ...params,
+    shiftKey: false
+  });
+}
+function resolveColumnKeysForContextMenuAction(params) {
+  const columnIndex = params.leafColumnKeys.indexOf(params.columnKey);
+  const rangeStartIndex = params.rangeStartIndex ?? columnIndex;
+  const rangeEndIndex = params.rangeEndIndex ?? columnIndex;
+  const hasValidTargetRange = rangeStartIndex >= 0 && rangeEndIndex >= rangeStartIndex && rangeEndIndex < params.leafColumnKeys.length;
+  const currentRange = params.current.selectedColumnRange;
+  const selectedKeys = params.current.selectedColumnKeys;
+  if (selectedKeys?.length && hasValidTargetRange && params.leafColumnKeys.slice(rangeStartIndex, rangeEndIndex + 1).every((key) => selectedKeys.includes(key))) {
+    return params.leafColumnKeys.filter((key) => selectedKeys.includes(key));
+  }
+  if (currentRange && hasValidTargetRange && rangeStartIndex >= currentRange.start && rangeEndIndex <= currentRange.end) {
+    return params.leafColumnKeys.slice(
+      currentRange.start,
+      currentRange.end + 1
+    );
+  }
+  if (hasValidTargetRange) {
+    return params.leafColumnKeys.slice(rangeStartIndex, rangeEndIndex + 1);
+  }
+  return [];
+}
+function resolveNextColumnHighlight(params) {
+  const columnIndex = params.leafColumnKeys.indexOf(params.columnKey);
+  if (columnIndex < 0) {
+    return params.current;
+  }
+  return resolveNextColumnHighlightByIndexRange({
+    current: params.current,
+    columnKey: params.columnKey,
+    leafColumnKeys: params.leafColumnKeys,
+    rangeStartIndex: columnIndex,
+    rangeEndIndex: columnIndex,
+    shiftKey: params.shiftKey
+  });
+}
+function resolveNextColumnHighlightForHeaderClick(params) {
+  const nextCurrent = {
+    ...params.current,
+    selectedRowAnchorIndex: null,
+    selectedRowRange: null,
+    ...params.current.selectedRowRanges !== void 0 ? { selectedRowRanges: null } : {},
+    selectedCellRange: null,
+    selectedCellRanges: null,
+    selectedCellAnchor: null
+  };
+  const hasValidRange = params.rangeStartIndex >= 0 && params.rangeEndIndex >= 0 && params.rangeStartIndex < params.leafColumnKeys.length && params.rangeEndIndex < params.leafColumnKeys.length;
+  if (params.ctrlKey) {
+    const leafIndex = params.leafColumnKeys.indexOf(params.columnKey);
+    const targetKeys = hasValidRange ? params.leafColumnKeys.slice(
+      params.rangeStartIndex,
+      params.rangeEndIndex + 1
+    ) : leafIndex >= 0 ? [params.columnKey] : [];
+    if (!targetKeys.length) return nextCurrent;
+    const selected = new Set(
+      params.current.selectedColumnKeys ?? (params.current.selectedColumnRange ? params.leafColumnKeys.slice(
+        params.current.selectedColumnRange.start,
+        params.current.selectedColumnRange.end + 1
+      ) : [])
+    );
+    if (targetKeys.every((key) => selected.has(key))) {
+      targetKeys.forEach((key) => selected.delete(key));
+    } else {
+      targetKeys.forEach((key) => selected.add(key));
+    }
+    const selectedColumnKeys = params.leafColumnKeys.filter(
+      (key) => selected.has(key)
+    );
+    return {
+      ...nextCurrent,
+      selectedColumnAnchorKey: selectedColumnKeys.length ? selected.has(params.columnKey) ? params.columnKey : selectedColumnKeys[selectedColumnKeys.length - 1] : null,
+      selectedColumnRange: null,
+      selectedColumnKeys
+    };
+  }
+  if (!params.shiftKey) {
+    const leafColumnIndex = params.leafColumnKeys.indexOf(params.columnKey);
+    if (leafColumnIndex >= 0) {
+      return resolveNextColumnHighlightByIndexRange({
+        ...params,
+        current: nextCurrent,
+        rangeStartIndex: leafColumnIndex,
+        rangeEndIndex: leafColumnIndex
+      });
+    }
+    if (hasValidRange) {
+      return resolveNextColumnHighlightByIndexRange({
+        ...params,
+        current: nextCurrent
+      });
+    }
+    return {
+      ...nextCurrent,
+      selectedColumnAnchorKey: params.columnKey,
+      selectedColumnRange: null,
+      selectedColumnKeys: null
+    };
+  }
+  if (hasValidRange) {
+    return resolveNextColumnHighlightByIndexRange({
+      ...params,
+      current: nextCurrent
+    });
+  }
+  return resolveNextColumnHighlight({
+    current: nextCurrent,
+    columnKey: params.columnKey,
+    leafColumnKeys: params.leafColumnKeys,
+    shiftKey: params.shiftKey
+  });
+}
+function resolveNextColumnHighlightByIndexRange(params) {
+  if (params.rangeStartIndex < 0 || params.rangeEndIndex < 0 || params.rangeStartIndex >= params.leafColumnKeys.length || params.rangeEndIndex >= params.leafColumnKeys.length) {
+    return params.current;
+  }
+  const anchorIndex = resolveColumnAnchorIndex({
+    anchorKey: params.current.selectedColumnAnchorKey,
+    leafColumnKeys: params.leafColumnKeys
+  });
+  const nextAnchorIndex = params.shiftKey && anchorIndex != null ? anchorIndex : params.rangeStartIndex;
+  return {
+    ...params.current,
+    selectedColumnAnchorKey: params.leafColumnKeys[nextAnchorIndex] ?? params.columnKey,
+    selectedColumnRange: createHighlightRange(
+      nextAnchorIndex,
+      params.shiftKey ? params.rangeEndIndex : params.rangeEndIndex
+    ),
+    selectedColumnKeys: null
+  };
+}
+function resolveColumnAnchorIndex(params) {
+  if (!params.anchorKey) {
+    return null;
+  }
+  const anchorIndex = params.leafColumnKeys.indexOf(params.anchorKey);
+  return anchorIndex >= 0 ? anchorIndex : null;
+}
+function createHighlightRange(start, end) {
+  return {
+    start: Math.min(start, end),
+    end: Math.max(start, end)
+  };
+}
+function resolveHighlightMode(mode) {
+  if (mode === "cell" || mode === "column" || mode === "cross") {
+    return mode;
+  }
+  return "row";
+}
+function resolveRangeHighlightForHeaderSelection(params) {
+  const nextRangeHighlight = {
+    ...params.current,
+    selectedRowAnchorIndex: null,
+    selectedRowRange: null,
+    ...params.current.selectedRowRanges !== void 0 ? { selectedRowRanges: null } : {}
+  };
+  if (!params.shiftKey && !params.ctrlKey) {
+    nextRangeHighlight.selectedColumnAnchorKey = EMPTY_RANGE_HIGHLIGHT_STATE.selectedColumnAnchorKey;
+    nextRangeHighlight.selectedColumnRange = EMPTY_RANGE_HIGHLIGHT_STATE.selectedColumnRange;
+    if (params.current.selectedColumnKeys !== void 0) {
+      nextRangeHighlight.selectedColumnKeys = null;
+    }
+  }
+  return nextRangeHighlight;
+}
+function resolveRangeHighlightForBodyInteraction(params) {
+  const mode = resolveHighlightMode(params.mode);
+  const canHighlightColumn = params.columnKey !== params.selectionColumnKey && params.columnKey !== params.expandColumnKey;
+  const rangeEndIndex = params.rowIndex + Math.max(Math.floor(params.rowSpan ?? 1), 1) - 1;
+  if (mode === "cell") {
+    return EMPTY_RANGE_HIGHLIGHT_STATE;
+  }
+  if (mode === "row") {
+    return {
+      ...resolveNextRowHighlightByIndexRange({
+        current: params.current,
+        rangeStartIndex: params.rowIndex,
+        rangeEndIndex,
+        shiftKey: params.shiftKey
+      }),
+      selectedColumnAnchorKey: null,
+      selectedColumnRange: null,
+      selectedColumnKeys: null,
+      selectedCellRange: null,
+      selectedCellRanges: null
+    };
+  }
+  if (mode === "column") {
+    if (!canHighlightColumn || !params.columnRange) {
+      return {
+        ...params.current,
+        selectedRowAnchorIndex: null,
+        selectedRowRange: null
+      };
+    }
+    return {
+      ...resolveNextColumnHighlightByIndexRange({
+        current: params.current,
+        columnKey: params.columnKey,
+        leafColumnKeys: params.leafColumnKeys,
+        rangeStartIndex: params.columnRange.start,
+        rangeEndIndex: params.columnRange.end,
+        shiftKey: params.shiftKey
+      }),
+      selectedRowAnchorIndex: null,
+      selectedRowRange: null
+    };
+  }
+  let next = resolveNextRowHighlightByIndexRange({
+    current: params.current,
+    rangeStartIndex: params.rowIndex,
+    rangeEndIndex,
+    shiftKey: params.shiftKey
+  });
+  if (canHighlightColumn && params.columnRange) {
+    next = resolveNextColumnHighlightByIndexRange({
+      current: next,
+      columnKey: params.columnKey,
+      leafColumnKeys: params.leafColumnKeys,
+      rangeStartIndex: params.columnRange.start,
+      rangeEndIndex: params.columnRange.end,
+      shiftKey: false
+    });
+  }
+  return next;
+}
+function isCellHighlightedByMode(params) {
+  const mode = resolveHighlightMode(params.mode);
+  if (mode === "cell") {
+    return params.isCellSelected;
+  }
+  if (mode === "row") {
+    return params.isRowRangeSelected;
+  }
+  if (mode === "column") {
+    return params.isColumnRangeSelected;
+  }
+  return params.isRowRangeSelected || params.isColumnRangeSelected;
+}
+
+// src/rendering/primitives/draw-summary.ts
 var EMPTY_RANGE_HIGHLIGHT2 = {
   selectedColumnRange: null
 };
@@ -9262,6 +10012,9 @@ function drawSummarySegment(params, columns, clipRect, defaultTitleColumnKey) {
   ctx.rect(minX, summaryTop, totalWidth, summaryHeight);
   ctx.clip();
   columns.forEach((column) => {
+    if (clipRect && (column.drawX + column.width < clipRect.x - 1 || column.drawX > clipRect.x + clipRect.width + 1)) {
+      return;
+    }
     const rect = {
       x: column.drawX,
       y: summaryTop,
@@ -9299,9 +10052,10 @@ function drawSummaryCell(ctx, rect, column, theme, summaryValues, selectedHeader
     return;
   }
   const isHeaderColumnSelected = selectedHeaderKey != null && column.key === selectedHeaderKey;
-  const isColumnRangeSelected = isIndexInHighlightRange(
-    column.leafIndex,
-    (rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT2).selectedColumnRange
+  const isColumnRangeSelected = isColumnInHighlight(
+    rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT2,
+    column.key,
+    column.leafIndex
   );
   ctx.fillStyle = summarySelected || isHeaderColumnSelected || isColumnRangeSelected ? theme.selectionBackgroundColor : style?.backgroundColor ?? theme.headerBackgroundColor;
   ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
@@ -9514,9 +10268,6 @@ function intersectRects2(left, right) {
     height: maxY - y
   };
 }
-function isIndexInHighlightRange(index, range) {
-  return Boolean(range && index >= range.start && index <= range.end);
-}
 
 // src/rendering/cell-content/draw-nested-table-content.ts
 var DEFAULT_COLUMN_WIDTH2 = 140;
@@ -9586,7 +10337,8 @@ function drawBodyNestedTableContent(params) {
       align: column.align ?? "left",
       actionVisibilityState,
       allowActions: true,
-      hasFilter: column.allowFilter === true
+      hasFilter: column.allowFilter === true,
+      hasEdit: !!column.editable
     });
     const headerHighlighted = isNestedTableHeaderHighlighted(
       content,
@@ -9966,7 +10718,9 @@ function drawNestedTableHeaderActions(params) {
   if (!visibilityState.visible) return;
   const { actionTypes, startX, totalWidth } = getHeaderActionLayout({
     rect,
-    hasFilter: column.allowFilter === true
+    hasFilter: column.allowFilter === true,
+    hasEdit: !!column.editable,
+    visibilityState
   });
   drawParams.ctx.save();
   drawParams.ctx.fillStyle = headerSelected ? drawParams.theme.selectionBackgroundColor : drawParams.theme.headerBackgroundColor;
@@ -9987,6 +10741,33 @@ function drawNestedTableHeaderActions(params) {
       width: size,
       height: size
     };
+    if (actionType === "edit") {
+      drawHeaderActionIcon(
+        drawParams.ctx,
+        actionRect,
+        "edit",
+        true,
+        false,
+        headerSelected,
+        drawParams.theme.selectionBackgroundColor
+      );
+      drawParams.descriptors.push({
+        kind: "body-content",
+        rect: actionRect,
+        columnKey: drawParams.column.key,
+        rowIndex: drawParams.rowIndex,
+        contentIndex: drawParams.contentIndex,
+        contentKey: "nested-table",
+        nestedColumnDataIndex: columnKey,
+        nestedColumnIndex: columnIndex,
+        fixed: drawParams.column.fixed,
+        frozen: drawParams.frozen,
+        debugNodeType: "nested-table-header-edit-icon",
+        debugText: "\u5F53\u524D\u5217\u53EF\u7F16\u8F91"
+      });
+      actionX += size + gap;
+      return;
+    }
     const active = actionType === "sort" && sortOrder != null || actionType === "filter" && filtered || actionType === "fixed" && fixed != null;
     drawHeaderActionIcon(
       drawParams.ctx,
@@ -10030,7 +10811,7 @@ function resolveNestedTableHeaderActionVisibility(params) {
     sorted,
     filtered,
     fixed,
-    visible: hovered || sorted || filtered || fixed
+    visible: hovered || sorted || filtered || fixed || !!column.editable
   };
 }
 function isNestedTableRowHighlighted(content, record, rowIndex, highlight, highlightMode) {
@@ -11099,7 +11880,7 @@ function drawBodySelectionContent(params) {
     controlType: content.type,
     contentIndex,
     contentKey: content.key,
-    cursor: content.disabled === true ? "not-allowed" : content.cursor ?? (content.onClick ? "pointer" : void 0)
+    cursor: content.disabled === true ? "not-allowed" : content.cursor ?? (content.onClick || column.key === ROW_SELECTION_COLUMN_KEY ? "pointer" : void 0)
   });
   return controlRect.width;
 }
@@ -11115,7 +11896,14 @@ function drawSelectionControl(ctx, rect, type, checked, disabled, indeterminate
     ctx.fillStyle = fillColor;
     ctx.strokeStyle = strokeColor;
     ctx.lineWidth = 1.5;
-    roundRectPath2(ctx, rect.x, rect.y, rect.width, rect.height, 4);
+    roundRectPath2(
+      ctx,
+      rect.x + 1,
+      rect.y + 1,
+      Math.max(rect.width - 2, 0),
+      Math.max(rect.height - 2, 0),
+      4
+    );
     ctx.fill();
     ctx.stroke();
     if (indeterminate) {
@@ -11599,7 +12387,7 @@ function drawBodyTagContent(params) {
 function measureTagContentWidth(ctx, content, theme) {
   applyTagTextStyle(ctx, content, theme);
   const intrinsicWidth = Math.max(
-    ctx.measureText(content.text).width + resolveContentTextIndent(content),
+    measureCachedText(ctx, content.text).width + resolveContentTextIndent(content),
     0
   ) + (content.paddingInline ?? TAG_HORIZONTAL_PADDING) * 2;
   return resolveContentLayoutWidth(content, intrinsicWidth);
@@ -11739,8 +12527,8 @@ function drawBodyTextContent(params) {
   if (searchMatch && searchMatch.rowIndex === rowIndex && searchMatch.columnKey === column.key && (searchMatch.contentIndex == null || searchMatch.contentIndex === contentIndex) && searchMatch.keyword) {
     const start = Math.max(0, Math.min(searchMatch.start, content.text.length));
     const end = Math.max(start, Math.min(searchMatch.end, content.text.length));
-    const prefixWidth = ctx.measureText(content.text.slice(0, start)).width;
-    const matchWidth = ctx.measureText(content.text.slice(start, end)).width;
+    const prefixWidth = measureCachedText(ctx, content.text.slice(0, start)).width;
+    const matchWidth = measureCachedText(ctx, content.text.slice(start, end)).width;
     ctx.save();
     ctx.fillStyle = "#f59e0b";
     ctx.globalAlpha = 0.35;
@@ -11813,7 +12601,7 @@ function measureTextContentWidth(ctx, content, theme) {
   }
   applyTextContentStyle(ctx, content, theme.textColor, theme);
   const intrinsicWidth = Math.max(
-    ctx.measureText(content.text).width + resolveContentTextIndent(content),
+    measureCachedText(ctx, content.text).width + resolveContentTextIndent(content),
     0
   );
   return resolveContentLayoutWidth(content, intrinsicWidth);
@@ -15112,6 +15900,7 @@ function createListTableAnimationRuntime() {
     lastExpandedRowKeys: /* @__PURE__ */ new Set(),
     expandAnimationFrameId: null,
     collapseRowAnimations: /* @__PURE__ */ new Map(),
+    sortRowAnimations: /* @__PURE__ */ new Map(),
     collapseCellHeightAnimations: /* @__PURE__ */ new Map(),
     collapseAnimationFrameId: null,
     nestedTableHighlights: /* @__PURE__ */ new Map(),
@@ -16181,8 +16970,11 @@ function resolveCollapsedRowRange(params) {
 
 // src/engine/controllers/animation-controller.ts
 var ROW_EXPAND_ANIMATION_DURATION = 240;
+var ROW_SORT_ANIMATION_DURATION = 420;
 var ListTableAnimationController = class {
   constructor(options) {
+    __publicField(this, "pendingSortRowPositions", null);
+    __publicField(this, "sortRowsReady", false);
     __publicField(this, "runtime");
     __publicField(this, "getScrollbarVisibleOption");
     __publicField(this, "isScrollbarVisible");
@@ -16329,6 +17121,37 @@ var ListTableAnimationController = class {
   setPendingCollapseRowPositions(positions) {
     this.runtime.pendingCollapseRowPositions = positions;
   }
+  /** 在排序前捕获可视行；异步查询完成之前不消费旧位置。 */
+  setPendingSortRowPositions(positions, ready = false) {
+    this.pendingSortRowPositions = positions;
+    this.sortRowsReady = ready;
+  }
+  markSortRowsReady() {
+    if (this.pendingSortRowPositions) this.sortRowsReady = true;
+  }
+  hasPendingSortRows() {
+    return this.pendingSortRowPositions != null;
+  }
+  reconcileSortAnimations(snapshot) {
+    if (!this.sortRowsReady || !this.pendingSortRowPositions) return false;
+    const previousPositions = this.pendingSortRowPositions;
+    this.pendingSortRowPositions = null;
+    this.sortRowsReady = false;
+    const now2 = this.scheduler.now();
+    this.runtime.sortRowAnimations.clear();
+    forEachRenderedVisibleRow(snapshot, (row, nextIndex) => {
+      if (row.kind !== "data") return;
+      const previousIndex = previousPositions.get(String(row.rowKey));
+      if (previousIndex == null || previousIndex === nextIndex) return;
+      this.runtime.sortRowAnimations.set(String(row.rowKey), {
+        from: (previousIndex - nextIndex) * snapshot.rowHeight,
+        to: 0,
+        startTime: now2,
+        duration: ROW_SORT_ANIMATION_DURATION
+      });
+    });
+    return true;
+  }
   reconcileCollapseAnimations(snapshot) {
     const previousPositions = this.runtime.pendingCollapseRowPositions;
     if (!previousPositions) {
@@ -16397,11 +17220,12 @@ var ListTableAnimationController = class {
     return getRowAnimationValue(animation, this.scheduler.now());
   }
   getCollapseRowOffset(rowKey) {
-    const animation = this.runtime.collapseRowAnimations.get(String(rowKey));
-    if (!animation) {
-      return void 0;
-    }
-    return getRowAnimationValue(animation, this.scheduler.now());
+    const key = String(rowKey);
+    const now2 = this.scheduler.now();
+    const collapse = this.runtime.collapseRowAnimations.get(key);
+    const sort = this.runtime.sortRowAnimations.get(key);
+    if (!collapse && !sort) return void 0;
+    return (collapse ? getRowAnimationValue(collapse, now2) : 0) + (sort ? getRowAnimationValue(sort, now2) : 0);
   }
   getCollapseCellHeight(params) {
     const animation = this.runtime.collapseCellHeightAnimations.get(
@@ -16430,13 +17254,16 @@ var ListTableAnimationController = class {
       columnKey: this.runtime.controlAnimationColumnKey,
       displayRows: snapshot.displayRows,
       nextWindowKey: buildControlAnimationWindowKey(snapshot),
-      nextColumnKey: buildControlAnimationColumnKey(snapshot.leafColumns)
+      nextColumnKey: buildControlAnimationColumnKey(
+        collectVisibleControlColumns(snapshot)
+      )
     });
   }
   reconcileControlAnimations(snapshot, resolveCellContents = resolveBodyCellContents) {
     const now2 = this.scheduler.now();
     this.pruneFinishedControlAnimations(now2);
     const nextValues = /* @__PURE__ */ new Map();
+    const visibleColumns = collectVisibleControlColumns(snapshot);
     forEachVisibleSnapshotRow(
       {
         frozenRows: snapshot.frozenRows,
@@ -16446,7 +17273,7 @@ var ListTableAnimationController = class {
       },
       (record, rowIndex) => {
         const rowKey = this.getRowKey(record, rowIndex);
-        collectVisibleControlColumns(snapshot).forEach((column) => {
+        visibleColumns.forEach((column) => {
           const contents = resolveCellContents({
             record,
             rowIndex,
@@ -16489,9 +17316,7 @@ var ListTableAnimationController = class {
     this.runtime.lastControlValues = nextValues;
     this.runtime.controlAnimationRowsRef = snapshot.displayRows;
     this.runtime.controlAnimationWindowKey = buildControlAnimationWindowKey(snapshot);
-    this.runtime.controlAnimationColumnKey = buildControlAnimationColumnKey(
-      snapshot.leafColumns
-    );
+    this.runtime.controlAnimationColumnKey = buildControlAnimationColumnKey(visibleColumns);
     Array.from(this.runtime.controlAnimations.keys()).forEach((key) => {
       if (!nextValues.has(key)) {
         this.runtime.controlAnimations.delete(key);
@@ -16869,7 +17694,7 @@ var ListTableAnimationController = class {
     );
   }
   ensureCollapseAnimationFrame() {
-    if (this.runtime.collapseRowAnimations.size === 0 && this.runtime.collapseCellHeightAnimations.size === 0 || this.runtime.collapseAnimationFrameId != null) {
+    if (this.runtime.collapseRowAnimations.size === 0 && this.runtime.sortRowAnimations.size === 0 && this.runtime.collapseCellHeightAnimations.size === 0 || this.runtime.collapseAnimationFrameId != null) {
       return;
     }
     this.runtime.collapseAnimationFrameId = this.scheduler.requestAnimationFrame(() => {
@@ -16893,8 +17718,11 @@ var ListTableAnimationController = class {
       this.runtime.collapseAnimationFrameId = null;
     }
     this.runtime.collapseRowAnimations.clear();
+    this.runtime.sortRowAnimations.clear();
     this.runtime.collapseCellHeightAnimations.clear();
     this.runtime.pendingCollapseRowPositions = null;
+    this.pendingSortRowPositions = null;
+    this.sortRowsReady = false;
   }
   destroy() {
     this.stopScrollbarOpacityAnimation();
@@ -17001,6 +17829,7 @@ var ListTableAnimationController = class {
   }
   pruneFinishedCollapseAnimations(now2) {
     pruneFinishedAnimations(this.runtime.collapseRowAnimations, now2);
+    pruneFinishedAnimations(this.runtime.sortRowAnimations, now2);
     pruneFinishedAnimations(this.runtime.collapseCellHeightAnimations, now2);
   }
 };
@@ -17011,7 +17840,11 @@ function collectVisibleControlColumns(snapshot) {
   }
   const columns = [
     ...segments.leftSegment,
-    ...segments.centerSegment,
+    ...segments.centerSegment.filter((column) => {
+      const metrics = snapshot.columnMetrics;
+      if (!metrics) return true;
+      return metrics.availableCenterWidth > 0 && column.drawX + column.width >= metrics.fixedWidthLeft - 1 && column.drawX <= metrics.fixedWidthLeft + metrics.availableCenterWidth + 1;
+    }),
     ...segments.rightSegment
   ];
   const seen = /* @__PURE__ */ new Set();
@@ -17830,8 +18663,11 @@ function createListTableSelectionCopyText(params) {
     (column2) => column2.key !== ROW_SELECTION_COLUMN_KEY && column2.key !== ROW_SELECTOR_COLUMN_KEY && column2.key !== EXPAND_COLUMN_KEY
   );
   const columnRange = params.rangeHighlight.selectedColumnRange;
+  const selectedColumnKeys = params.rangeHighlight.selectedColumnKeys;
   const rowRange = params.rangeHighlight.selectedRowRange;
+  const rowRanges = params.rangeHighlight.selectedRowRanges;
   const cellRange = params.rangeHighlight.selectedCellRange;
+  const cellRanges = params.rangeHighlight.selectedCellRanges;
   if (cellRange) {
     const selectedColumns2 = params.columns.filter(
       (column2, index) => index >= cellRange.startColumnIndex && index <= cellRange.endColumnIndex && column2.key !== ROW_SELECTION_COLUMN_KEY && column2.key !== ROW_SELECTOR_COLUMN_KEY && column2.key !== EXPAND_COLUMN_KEY
@@ -17852,22 +18688,57 @@ function createListTableSelectionCopyText(params) {
     return `${headerText}
 ${bodyText}`;
   }
-  const mode = params.highlightMode ?? (rowRange && columnRange ? "cross" : rowRange ? "row" : "column");
-  const selectedColumns = columnRange ? params.columns.filter(
+  if (cellRanges != null) {
+    const lines = [];
+    const fullRowRanges = rowRanges ?? (rowRange ? [rowRange] : []);
+    const selectedRowSpans = [
+      ...cellRanges.map((range) => ({
+        start: range.startRowIndex,
+        end: range.endRowIndex
+      })),
+      ...fullRowRanges
+    ].sort((left, right) => left.start - right.start);
+    let lastRowIndex = -1;
+    for (const range of selectedRowSpans) {
+      for (let rowIndex2 = Math.max(range.start, lastRowIndex + 1, 0); rowIndex2 <= Math.min(range.end, params.rows.length - 1); rowIndex2++) {
+        const fullRowSelected = fullRowRanges.some(
+          (rowRange2) => rowIndex2 >= rowRange2.start && rowIndex2 <= rowRange2.end
+        );
+        const selectedColumns2 = params.columns.filter(
+          (column2, columnIndex) => column2.key !== ROW_SELECTION_COLUMN_KEY && column2.key !== ROW_SELECTOR_COLUMN_KEY && column2.key !== EXPAND_COLUMN_KEY && (fullRowSelected || cellRanges.some(
+            (cellRange2) => rowIndex2 >= cellRange2.startRowIndex && rowIndex2 <= cellRange2.endRowIndex && columnIndex >= cellRange2.startColumnIndex && columnIndex <= cellRange2.endColumnIndex
+          ))
+        );
+        if (selectedColumns2.length) {
+          lines.push(
+            selectedColumns2.map(
+              (column2) => getCellClipboardText(params.rows[rowIndex2], rowIndex2, column2)
+            ).join(" ")
+          );
+        }
+        lastRowIndex = rowIndex2;
+      }
+    }
+    return lines.length ? lines.join("\n") : null;
+  }
+  const mode = params.highlightMode ?? (rowRange && (columnRange || selectedColumnKeys?.length) ? "cross" : rowRange ? "row" : "column");
+  const selectedColumns = selectedColumnKeys != null ? columns.filter((column2) => selectedColumnKeys.includes(column2.key)) : columnRange ? params.columns.filter(
     (column2, index) => index >= columnRange.start && index <= columnRange.end
   ).filter(
     (column2) => column2.key !== ROW_SELECTION_COLUMN_KEY && column2.key !== ROW_SELECTOR_COLUMN_KEY && column2.key !== EXPAND_COLUMN_KEY
   ) : columns;
   const startRow = rowRange ? Math.max(rowRange.start, 0) : 0;
   const endRow = rowRange ? Math.min(rowRange.end, params.rows.length - 1) : params.rows.length - 1;
-  if (rowRange && params.selection.columnKey === ROW_SELECTOR_COLUMN_KEY) {
-    return params.rows.slice(startRow, endRow + 1).map(
-      (record2, offset) => columns.map(
-        (column2) => getCellClipboardText(record2, startRow + offset, column2)
-      ).join(" ")
+  if ((rowRange || rowRanges?.length) && params.selection.columnKey === ROW_SELECTOR_COLUMN_KEY) {
+    const selectedRows = rowRanges != null ? rowRanges.flatMap((range) => {
+      const start = Math.max(range.start, 0);
+      return params.rows.slice(start, range.end + 1).map((record2, offset) => ({ record: record2, rowIndex: start + offset }));
+    }) : params.rows.slice(startRow, endRow + 1).map((record2, offset) => ({ record: record2, rowIndex: startRow + offset }));
+    return selectedRows.map(
+      ({ record: record2, rowIndex: rowIndex2 }) => columns.map((column2) => getCellClipboardText(record2, rowIndex2, column2)).join(" ")
     ).join("\n");
   }
-  if (mode === "column" && columnRange && params.selection.rowIndex == null) {
+  if ((mode === "column" || selectedColumnKeys != null) && (columnRange || selectedColumnKeys?.length) && params.selection.rowIndex == null) {
     return params.rows.map(
       (record2, rowIndex2) => selectedColumns.map((column2) => getCellClipboardText(record2, rowIndex2, column2)).join(" ")
     ).join("\n");
@@ -17967,42 +18838,99 @@ async function copyRowJsonContent(params) {
   }
 }
 async function exportAllRowsJsonContent(params) {
+  const columns = resolveListTableExportColumns(
+    params.columns,
+    params.settings
+  );
+  const rows = await resolveListTableExportRows(
+    params.rows,
+    columns,
+    params.settings
+  );
+  const data = utils.mapRowsToExportRecords({
+    rows,
+    columns: buildExportColumns(columns)
+  });
+  const footerRows = await buildListTableExportFooterRows(
+    rows,
+    columns,
+    params.settings
+  );
+  if (footerRows.length) {
+    data.push(
+      Object.fromEntries(
+        columns.map((column, index) => [column.title, footerRows[0][index]])
+      )
+    );
+  }
   await utils.downloadJsonFile({
     fileName: params.fileName?.trim() || buildTableExportFileName("json"),
-    data: utils.mapRowsToExportRecords({
-      rows: params.rows,
-      columns: buildExportColumns(params.columns)
-    })
+    data
   });
 }
 async function exportAllRowsCsvContent(params) {
+  const columns = resolveListTableExportColumns(
+    params.columns,
+    params.settings
+  );
+  const rows = await resolveListTableExportRows(
+    params.rows,
+    columns,
+    params.settings
+  );
   await utils.exportTableToCsv({
     fileName: params.fileName?.trim() || buildTableExportFileName("csv"),
-    rows: params.rows,
-    columns: buildExportColumns(params.columns)
+    rows,
+    columns: buildExportColumns(columns),
+    footerRows: await buildListTableExportFooterRows(
+      rows,
+      columns,
+      params.settings
+    )
   });
 }
 async function exportAllRowsTxtContent(params) {
+  const columns = resolveListTableExportColumns(
+    params.columns,
+    params.settings
+  );
+  const rows = await resolveListTableExportRows(
+    params.rows,
+    columns,
+    params.settings
+  );
   await utils.exportTableToTxt({
     fileName: params.fileName?.trim() || buildTableExportFileName("txt"),
-    rows: params.rows,
-    columns: buildExportColumns(params.columns)
+    rows,
+    columns: buildExportColumns(columns),
+    footerRows: await buildListTableExportFooterRows(
+      rows,
+      columns,
+      params.settings
+    )
   });
 }
 async function exportAllRowsXlsxContent(params) {
-  const columns = params.columns.filter(isExportableColumn);
-  const footerRows = [];
-  if (params.includeSummary) {
-    const values = await computeSummaryValuesAsync({
-      rows: params.rows,
-      columns,
-      signal: params.signal
-    });
-    footerRows.push(columns.map((column) => values.get(column.key) ?? ""));
-  }
+  const columns = resolveListTableExportColumns(
+    params.columns,
+    params.settings
+  );
+  const rows = await resolveListTableExportRows(
+    params.rows,
+    columns,
+    params.settings,
+    params.signal
+  );
+  const footerRows = await buildListTableExportFooterRows(
+    rows,
+    columns,
+    params.settings,
+    params.includeSummary,
+    params.signal
+  );
   await utils.exportTableToXlsx({
     fileName: params.fileName?.trim() || buildTableExportFileName("xlsx"),
-    rows: params.rows,
+    rows,
     footerRows,
     worker: params.worker,
     signal: params.signal,
@@ -18018,6 +18946,95 @@ async function exportAllRowsXlsxContent(params) {
     sheetName: "TableData"
   });
 }
+function getListTableExportCandidateColumns(columns) {
+  const hiddenByKey = /* @__PURE__ */ new Map();
+  const exportableByKey = /* @__PURE__ */ new Map();
+  const reveal = (items, parentHidden = false) => items.map((column) => {
+    const hidden = parentHidden || column.hidden === true;
+    const key = resolveColumnKey(column);
+    hiddenByKey.set(key, hidden);
+    exportableByKey.set(key, column.exportable);
+    return {
+      ...column,
+      hidden: false,
+      ...column.children?.length ? { children: reveal(column.children, hidden) } : null
+    };
+  });
+  return flattenLeafColumns(normalizeColumns(reveal(columns))).map(
+    (column) => ({
+      ...column,
+      hidden: hiddenByKey.get(column.key) ?? false,
+      exportable: exportableByKey.get(column.key)
+    })
+  );
+}
+function getListTableExportColumnChoices(columns, sortState = []) {
+  return columns.filter(isExportableColumn).map((column) => ({
+    key: column.key,
+    title: column.title ?? column.key,
+    selected: column.hidden !== true,
+    sortOrder: sortState.find((item) => item.key === column.key)?.order ?? "default",
+    sortIndex: sortState.findIndex((item) => item.key === column.key),
+    sortPriority: sortState.find((item) => item.key === column.key)?.priority,
+    summary: {
+      type: column.summaryTitle != null ? "title" : column.summary === true ? "sum" : column.summary && typeof column.summary === "object" ? column.summary.type ?? "sum" : "none",
+      showTypePrefix: column.summary === true || typeof column.summary === "object" && column.summary?.showTypePrefix !== false,
+      precision: typeof column.summary === "object" && column.summary ? column.summary.precision : void 0,
+      roundingMode: typeof column.summary === "object" && column.summary ? column.summary.roundingMode ?? "round" : "round",
+      preserveTrailingZeros: typeof column.summary === "object" && column.summary ? column.summary.preserveTrailingZeros === true : false
+    },
+    ...column.summaryTitle != null ? { summaryTitle: column.summaryTitle } : null
+  }));
+}
+function resolveListTableExportColumns(columns, settings) {
+  const exportable = columns.filter(isExportableColumn);
+  if (!settings) return exportable.filter((column) => !column.hidden);
+  const byKey = new Map(exportable.map((column) => [column.key, column]));
+  const selected = [...new Set(settings.columnKeys)].flatMap((key) => {
+    const column = byKey.get(key);
+    if (!column) return [];
+    const summary = settings.summaries[key];
+    if (!summary || summary.type === "original") return [column];
+    const result = { ...column };
+    if (summary.type === "none") {
+      result.summary = false;
+      delete result.summaryTitle;
+    } else if (summary.type === "title") {
+      result.summary = false;
+    } else {
+      result.summary = {
+        ...typeof column.summary === "object" ? column.summary : null,
+        type: summary.type,
+        showTypePrefix: summary.showTypePrefix,
+        precision: summary.precision,
+        roundingMode: summary.roundingMode,
+        preserveTrailingZeros: summary.preserveTrailingZeros
+      };
+      delete result.summaryTitle;
+    }
+    return [result];
+  });
+  if (selected.length === 0) throw new Error("\u8BF7\u81F3\u5C11\u9009\u62E9\u4E00\u5217\u5BFC\u51FA\u3002");
+  return selected;
+}
+async function resolveListTableExportRows(rows, columns, settings, signal) {
+  if (!settings?.sortState.length) return rows;
+  return sortRowsAsync({
+    rows,
+    leafColumns: columns,
+    sortState: settings.sortState,
+    signal
+  });
+}
+async function buildListTableExportFooterRows(rows, columns, settings, includeSummary = false, signal) {
+  if (!(settings?.includeSummary ?? includeSummary)) return [];
+  const values = await computeSummaryValuesAsync({ rows, columns, signal });
+  return [
+    columns.map(
+      (column) => resolveSummaryCellDisplayValue(column, values.get(column.key))
+    )
+  ];
+}
 function renderResultToClipboardText(result) {
   if (result == null) {
     return "";
@@ -18282,11 +19299,14 @@ var ListTableContentActionController = class {
     const includeSummary = options?.includeSummary ?? this.options.getSummaryVisible?.() ?? false;
     options = { ...this.options.getOptions().exportOptions, ...options };
     this.startExportTask(
-      (fileName) => exportAllRowsXlsxContent({
+      (fileName, settings) => exportAllRowsXlsxContent({
         rows: this.options.getOptions().dataSource,
-        columns: this.options.getLeafColumns(),
+        columns: getListTableExportCandidateColumns(
+          this.options.getOptions().columns
+        ),
         ...options,
         includeSummary,
+        ...settings ? { settings } : null,
         fileName: fileName ?? options?.fileName,
         onProgress: (progress) => {
           const fileLabel = progress.fileCount && progress.fileCount > 1 ? `\uFF08\u7B2C ${progress.fileIndex}/${progress.fileCount} \u4EFD\uFF09` : "";
@@ -18299,10 +19319,17 @@ var ListTableContentActionController = class {
       "\u6B63\u5728\u5BFC\u51FA XLSX\u2026",
       options?.onError,
       options?.fileName?.trim() ? `${options.fileName.trim().replace(/\.xlsx$/i, "")}.xlsx` : buildTableExportFileName("xlsx"),
-      options?.promptFileName
+      options?.promptFileName,
+      {
+        columns: getListTableExportColumnChoices(
+          getListTableExportCandidateColumns(this.options.getOptions().columns),
+          this.options.getSortState?.()
+        ),
+        includeSummary
+      }
     );
   }
-  startExportTask(task, text, onError, defaultFileName, promptFileName = this.options.getOptions().exportOptions?.promptFileName ?? true) {
+  startExportTask(task, text, onError, defaultFileName, promptFileName = this.options.getOptions().exportOptions?.promptFileName ?? true, dialog) {
     if (this.exportTaskRunning || this.exportNamePending) {
       return;
     }
@@ -18317,14 +19344,15 @@ var ListTableContentActionController = class {
       };
       const request = {
         fileName: defaultFileName,
-        onConfirm: (value) => {
+        ...dialog,
+        onConfirm: (value, settings) => {
           if (settled || !value.trim()) return;
           close();
           const extension = defaultFileName.match(
             /\.(xlsx|csv|txt|json)$/i
           )?.[0];
           const name = extension && !value.trim().toLowerCase().endsWith(extension.toLowerCase()) ? `${value.trim()}${extension}` : value.trim();
-          this.startExportTask(() => task(name), text, onError);
+          this.startExportTask(() => task(name, settings), text, onError);
         },
         onCancel: () => {
           if (!settled) close();
@@ -19245,7 +20273,7 @@ function resolveScrollTopToRevealRow(params) {
   if (frozenRows.top.rowIndexMap?.includes(rowIndex) || frozenRows.bottom.rowIndexMap?.includes(rowIndex)) {
     return null;
   }
-  const scrollSectionIndex = frozenRows.scroll.rowIndexMap ? frozenRows.scroll.rowIndexMap.indexOf(rowIndex) : rowIndex;
+  const scrollSectionIndex = frozenRows.scroll.dataRowIndexAligned ? rowIndex : frozenRows.scroll.rowIndexMap ? frozenRows.scroll.rowIndexMap.indexOf(rowIndex) : rowIndex;
   if (scrollSectionIndex < 0) {
     return null;
   }
@@ -19488,7 +20516,7 @@ var ListTableEditingController = class {
     });
     const nextTop = resolveScrollTopToRevealRow({
       rowIndex,
-      rowCount: snapshot.visibleRows.length,
+      rowCount: snapshot.frozenRows.scroll.dataRowIndexAligned ? snapshot.dataRowCount : snapshot.visibleRows.length,
       rowHeight: snapshot.rowHeight,
       bodyHeight: snapshot.bodyLayout.scrollBodyHeight,
       scrollTop: scroll.top,
@@ -19707,257 +20735,6 @@ function setColumnConditionalFormats(columns, key, rules, cache) {
   }
   return false;
 }
-
-// src/services/range-highlight-service.ts
-var EMPTY_RANGE_HIGHLIGHT_STATE = {
-  selectedRowAnchorIndex: null,
-  selectedRowRange: null,
-  selectedColumnAnchorKey: null,
-  selectedColumnRange: null
-};
-function isIndexInHighlightRange2(index, range) {
-  return Boolean(range && index >= range.start && index <= range.end);
-}
-function resolveNextRowHighlight(params) {
-  return resolveNextRowHighlightByIndexRange({
-    current: params.current,
-    rangeStartIndex: params.rowIndex,
-    rangeEndIndex: params.rowIndex,
-    shiftKey: params.shiftKey
-  });
-}
-function resolveNextRowHighlightByIndexRange(params) {
-  const rangeStartIndex = Math.max(0, Math.floor(params.rangeStartIndex));
-  const rangeEndIndex = Math.max(
-    rangeStartIndex,
-    Math.floor(params.rangeEndIndex)
-  );
-  const anchor = params.shiftKey && params.current.selectedRowAnchorIndex != null ? params.current.selectedRowAnchorIndex : rangeStartIndex;
-  return {
-    ...params.current,
-    selectedRowAnchorIndex: anchor,
-    selectedRowRange: createHighlightRange(anchor, rangeEndIndex)
-  };
-}
-function resolveNextRowHighlightForContextMenu(params) {
-  if (isIndexInHighlightRange2(params.rowIndex, params.current.selectedRowRange)) {
-    return params.current;
-  }
-  return resolveNextRowHighlight({
-    current: params.current,
-    rowIndex: params.rowIndex,
-    shiftKey: false
-  });
-}
-function resolveNextColumnHighlightForContextMenu(params) {
-  const currentRange = params.current.selectedColumnRange;
-  if (currentRange && params.rangeStartIndex >= currentRange.start && params.rangeEndIndex <= currentRange.end) {
-    return {
-      ...params.current,
-      selectedRowAnchorIndex: null,
-      selectedRowRange: null
-    };
-  }
-  return resolveNextColumnHighlightForHeaderClick({
-    ...params,
-    shiftKey: false
-  });
-}
-function resolveColumnKeysForContextMenuAction(params) {
-  const columnIndex = params.leafColumnKeys.indexOf(params.columnKey);
-  const rangeStartIndex = params.rangeStartIndex ?? columnIndex;
-  const rangeEndIndex = params.rangeEndIndex ?? columnIndex;
-  const hasValidTargetRange = rangeStartIndex >= 0 && rangeEndIndex >= rangeStartIndex && rangeEndIndex < params.leafColumnKeys.length;
-  const currentRange = params.current.selectedColumnRange;
-  if (currentRange && hasValidTargetRange && rangeStartIndex >= currentRange.start && rangeEndIndex <= currentRange.end) {
-    return params.leafColumnKeys.slice(
-      currentRange.start,
-      currentRange.end + 1
-    );
-  }
-  if (hasValidTargetRange) {
-    return params.leafColumnKeys.slice(rangeStartIndex, rangeEndIndex + 1);
-  }
-  return [];
-}
-function resolveNextColumnHighlight(params) {
-  const columnIndex = params.leafColumnKeys.indexOf(params.columnKey);
-  if (columnIndex < 0) {
-    return params.current;
-  }
-  return resolveNextColumnHighlightByIndexRange({
-    current: params.current,
-    columnKey: params.columnKey,
-    leafColumnKeys: params.leafColumnKeys,
-    rangeStartIndex: columnIndex,
-    rangeEndIndex: columnIndex,
-    shiftKey: params.shiftKey
-  });
-}
-function resolveNextColumnHighlightForHeaderClick(params) {
-  const nextCurrent = {
-    ...params.current,
-    selectedRowAnchorIndex: null,
-    selectedRowRange: null
-  };
-  const hasValidRange = params.rangeStartIndex >= 0 && params.rangeEndIndex >= 0 && params.rangeStartIndex < params.leafColumnKeys.length && params.rangeEndIndex < params.leafColumnKeys.length;
-  if (!params.shiftKey) {
-    const leafColumnIndex = params.leafColumnKeys.indexOf(params.columnKey);
-    if (leafColumnIndex >= 0) {
-      return resolveNextColumnHighlightByIndexRange({
-        ...params,
-        current: nextCurrent,
-        rangeStartIndex: leafColumnIndex,
-        rangeEndIndex: leafColumnIndex
-      });
-    }
-    if (hasValidRange) {
-      return resolveNextColumnHighlightByIndexRange({
-        ...params,
-        current: nextCurrent
-      });
-    }
-    return {
-      ...nextCurrent,
-      selectedColumnAnchorKey: params.columnKey,
-      selectedColumnRange: null
-    };
-  }
-  if (hasValidRange) {
-    return resolveNextColumnHighlightByIndexRange({
-      ...params,
-      current: nextCurrent
-    });
-  }
-  return resolveNextColumnHighlight({
-    current: nextCurrent,
-    columnKey: params.columnKey,
-    leafColumnKeys: params.leafColumnKeys,
-    shiftKey: params.shiftKey
-  });
-}
-function resolveNextColumnHighlightByIndexRange(params) {
-  if (params.rangeStartIndex < 0 || params.rangeEndIndex < 0 || params.rangeStartIndex >= params.leafColumnKeys.length || params.rangeEndIndex >= params.leafColumnKeys.length) {
-    return params.current;
-  }
-  const anchorIndex = resolveColumnAnchorIndex({
-    anchorKey: params.current.selectedColumnAnchorKey,
-    leafColumnKeys: params.leafColumnKeys
-  });
-  const nextAnchorIndex = params.shiftKey && anchorIndex != null ? anchorIndex : params.rangeStartIndex;
-  return {
-    ...params.current,
-    selectedColumnAnchorKey: params.leafColumnKeys[nextAnchorIndex] ?? params.columnKey,
-    selectedColumnRange: createHighlightRange(
-      nextAnchorIndex,
-      params.shiftKey ? params.rangeEndIndex : params.rangeEndIndex
-    )
-  };
-}
-function resolveColumnAnchorIndex(params) {
-  if (!params.anchorKey) {
-    return null;
-  }
-  const anchorIndex = params.leafColumnKeys.indexOf(params.anchorKey);
-  return anchorIndex >= 0 ? anchorIndex : null;
-}
-function createHighlightRange(start, end) {
-  return {
-    start: Math.min(start, end),
-    end: Math.max(start, end)
-  };
-}
-function resolveHighlightMode(mode) {
-  if (mode === "cell" || mode === "column" || mode === "cross") {
-    return mode;
-  }
-  return "row";
-}
-function resolveRangeHighlightForHeaderSelection(params) {
-  const nextRangeHighlight = {
-    ...params.current,
-    selectedRowAnchorIndex: null,
-    selectedRowRange: null
-  };
-  if (!params.shiftKey) {
-    nextRangeHighlight.selectedColumnAnchorKey = EMPTY_RANGE_HIGHLIGHT_STATE.selectedColumnAnchorKey;
-    nextRangeHighlight.selectedColumnRange = EMPTY_RANGE_HIGHLIGHT_STATE.selectedColumnRange;
-  }
-  return nextRangeHighlight;
-}
-function resolveRangeHighlightForBodyInteraction(params) {
-  const mode = resolveHighlightMode(params.mode);
-  const canHighlightColumn = params.columnKey !== params.selectionColumnKey && params.columnKey !== params.expandColumnKey;
-  const rangeEndIndex = params.rowIndex + Math.max(Math.floor(params.rowSpan ?? 1), 1) - 1;
-  if (mode === "cell") {
-    return EMPTY_RANGE_HIGHLIGHT_STATE;
-  }
-  if (mode === "row") {
-    return {
-      ...resolveNextRowHighlightByIndexRange({
-        current: params.current,
-        rangeStartIndex: params.rowIndex,
-        rangeEndIndex,
-        shiftKey: params.shiftKey
-      }),
-      selectedColumnAnchorKey: null,
-      selectedColumnRange: null
-    };
-  }
-  if (mode === "column") {
-    if (!canHighlightColumn || !params.columnRange) {
-      return {
-        ...params.current,
-        selectedRowAnchorIndex: null,
-        selectedRowRange: null
-      };
-    }
-    return {
-      ...resolveNextColumnHighlightByIndexRange({
-        current: params.current,
-        columnKey: params.columnKey,
-        leafColumnKeys: params.leafColumnKeys,
-        rangeStartIndex: params.columnRange.start,
-        rangeEndIndex: params.columnRange.end,
-        shiftKey: params.shiftKey
-      }),
-      selectedRowAnchorIndex: null,
-      selectedRowRange: null
-    };
-  }
-  let next = resolveNextRowHighlightByIndexRange({
-    current: params.current,
-    rangeStartIndex: params.rowIndex,
-    rangeEndIndex,
-    shiftKey: params.shiftKey
-  });
-  if (canHighlightColumn && params.columnRange) {
-    next = resolveNextColumnHighlightByIndexRange({
-      current: next,
-      columnKey: params.columnKey,
-      leafColumnKeys: params.leafColumnKeys,
-      rangeStartIndex: params.columnRange.start,
-      rangeEndIndex: params.columnRange.end,
-      shiftKey: false
-    });
-  }
-  return next;
-}
-function isCellHighlightedByMode(params) {
-  const mode = resolveHighlightMode(params.mode);
-  if (mode === "cell") {
-    return params.isCellSelected;
-  }
-  if (mode === "row") {
-    return params.isRowRangeSelected;
-  }
-  if (mode === "column") {
-    return params.isColumnRangeSelected;
-  }
-  return params.isRowRangeSelected || params.isColumnRangeSelected;
-}
-
-// src/rendering/primitives/draw-body.ts
 var VALIDATION_ERROR_COLOR = "#ff4d4f";
 var VALIDATION_TEXT_COLOR = "#ffffff";
 var VALIDATION_MUTED_TEXT_COLOR = "rgba(255, 255, 255, 0.72)";
@@ -20041,7 +20818,8 @@ function drawSegmentRows(params, segment, columns, startRowIndex, endRowIndex, r
       columns,
       startRowIndex,
       endRowIndex,
-      rowIndexMap: params.rowIndexMap
+      rowIndexMap: params.rowIndexMap,
+      horizontalClip: clipRect
     });
     const animatedCellHeights = /* @__PURE__ */ new Map();
     let collapseAnimationOverflow = 0;
@@ -20077,7 +20855,7 @@ function drawSegmentRows(params, segment, columns, startRowIndex, endRowIndex, r
       renderClipRect.height
     );
     ctx.clip();
-    const orderedCells = [...visibleCells].sort(
+    const orderedCells = animatedCellHeights.size === 0 ? visibleCells : [...visibleCells].sort(
       (left, right) => Number(animatedCellHeights.has(left)) - Number(animatedCellHeights.has(right))
     );
     orderedCells.forEach((cell) => {
@@ -20103,7 +20881,7 @@ function drawSegmentRows(params, segment, columns, startRowIndex, endRowIndex, r
         width: getMergedCellWidth(columns, cell.columnIndex, cell.colSpan),
         height: animatedCellHeights.get(cell) ?? baseHeight
       };
-      if (rect.y + rect.height <= params.bodyTop || rect.y >= params.bodyTop + params.bodyHeight) {
+      if (rect.x + rect.width < clipRect.x - 1 || rect.x > clipRect.x + clipRect.width + 1 || rect.y + rect.height <= params.bodyTop || rect.y >= params.bodyTop + params.bodyHeight) {
         return;
       }
       const isHovered = params.hover.area === "body" && params.hover.rowIndex === cell.sourceRowIndex && params.hover.columnKey === cell.column.key;
@@ -20111,24 +20889,28 @@ function drawSegmentRows(params, segment, columns, startRowIndex, endRowIndex, r
       const hasCellTextSelection = params.selection.textSelection?.fragments.some(
         (fragment) => fragment.rowIndex === cell.sourceRowIndex && fragment.columnKey === cell.column.key
       ) === true;
-      const isRowRangeSelected = cell.row.kind === "data" && isRowSpanInHighlightRange(
-        cell.sourceRowIndex,
-        cell.rowSpan,
+      const isRowRangeSelected = cell.row.kind === "data" && (params.rangeHighlight?.selectedRowRanges ?? ((params.rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT3).selectedRowRange ? [
         (params.rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT3).selectedRowRange
+      ] : [])).some(
+        (range) => isRowSpanInHighlightRange(cell.sourceRowIndex, cell.rowSpan, range)
       );
-      const isColumnRangeSelected = cell.row.kind === "data" && isIndexInHighlightRange3(
-        cell.column.leafIndex,
-        (params.rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT3).selectedColumnRange
+      const isColumnRangeSelected = cell.row.kind === "data" && isColumnInHighlight(
+        params.rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT3,
+        cell.column.key,
+        cell.column.leafIndex
+      );
+      const isSelectedCellRange = cell.row.kind === "data" && isCellInHighlight(
+        params.rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT3,
+        cell.sourceRowIndex,
+        cell.column.leafIndex
       );
-      const selectedCellRange = (params.rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT3).selectedCellRange;
-      const isSelectedCellRange = cell.row.kind === "data" && selectedCellRange != null && cell.sourceRowIndex >= selectedCellRange.startRowIndex && cell.sourceRowIndex <= selectedCellRange.endRowIndex && cell.column.leafIndex >= selectedCellRange.startColumnIndex && cell.column.leafIndex <= selectedCellRange.endColumnIndex;
       const isHeaderColumnSelected = cell.row.kind === "data" && params.selectedHeaderKey != null && cell.column.key === params.selectedHeaderKey;
-      const isRangeHighlighted = isCellHighlightedByMode({
+      const isRangeHighlighted = isSelectedCellRange || isCellHighlightedByMode({
         mode: params.highlightMode,
         isCellSelected: isSelected || isSelectedCellRange,
         isRowRangeSelected,
         isColumnRangeSelected
-      });
+      }) || params.selection.rowIndex == null && (params.selectedHeaderKey != null || (params.rangeHighlight ?? EMPTY_RANGE_HIGHLIGHT3).selectedColumnKeys != null) && isColumnRangeSelected;
       const validationMessage = cell.row.kind === "data" ? params.getValidationMessage?.({
         record: cell.record,
         rowIndex: cell.sourceRowIndex,
@@ -20193,6 +20975,7 @@ function drawSegmentRows(params, segment, columns, startRowIndex, endRowIndex, r
         kind: "body",
         rect,
         columnKey: cell.column.key,
+        cursor: cell.column.key === ROW_SELECTOR_COLUMN_KEY ? "pointer" : void 0,
         rowIndex: cell.sourceRowIndex,
         rowSpan: cell.rowSpan,
         fixed: cell.column.fixed,
@@ -20459,9 +21242,6 @@ function findVisibleDataRow(rows, startIndex, step) {
   }
   return null;
 }
-function isIndexInHighlightRange3(index, range) {
-  return Boolean(range && index >= range.start && index <= range.end);
-}
 function isRowSpanInHighlightRange(rowIndex, rowSpan, range) {
   if (!range) {
     return false;
@@ -20556,6 +21336,14 @@ function buildMergedBodyCells(rows, columns, mergeCell, rowIndexMap) {
 function buildPlainVisibleBodyCells(params) {
   const { rows, columns, startRowIndex, endRowIndex } = params;
   const visibleCells = [];
+  const clip = params.horizontalClip;
+  const visibleColumnIndexes = [];
+  for (let index = 0; index < columns.length; index += 1) {
+    const column = columns[index];
+    if (column && (!clip || column.drawX + column.width >= clip.x - 1 && column.drawX <= clip.x + clip.width + 1)) {
+      visibleColumnIndexes.push(index);
+    }
+  }
   for (let rowIndex = startRowIndex; rowIndex < endRowIndex; rowIndex += 1) {
     const row = rows[rowIndex];
     if (!row) {
@@ -20579,7 +21367,7 @@ function buildPlainVisibleBodyCells(params) {
       continue;
     }
     const sourceRowIndex = row.dataRowIndex;
-    for (let columnIndex = 0; columnIndex < columns.length; columnIndex += 1) {
+    for (const columnIndex of visibleColumnIndexes) {
       const column = columns[columnIndex];
       if (!column) {
         continue;
@@ -21561,7 +22349,7 @@ function getMaxDepth(columns) {
 var DEFAULT_HORIZONTAL_LEFT = 0;
 var DEFAULT_HORIZONTAL_RIGHT = 0;
 var DEFAULT_HORIZONTAL_BOTTOM = 0;
-var DEFAULT_VERTICAL_TOP = 6;
+var DEFAULT_VERTICAL_TOP = 0;
 var DEFAULT_VERTICAL_RIGHT = 0;
 var DEFAULT_VERTICAL_BOTTOM = 0;
 var MIN_SCROLLBAR_THUMB_SIZE = 36;
@@ -21571,6 +22359,7 @@ function computeScrollbarLayout(params) {
   const vertical = utils.resolveCanvasScrollbarAxis(params.scrollbar, "vertical");
   const horizontalLeft = Math.max(
     params.scrollbar?.horizontalLeft ?? DEFAULT_HORIZONTAL_LEFT,
+    params.rowSelectorWidth ?? 0,
     0
   );
   const horizontalRight = Math.max(
@@ -21600,43 +22389,69 @@ function computeScrollbarLayout(params) {
   const horizontalTrackY = params.height - horizontal.thickness - horizontalBottom;
   if (horizontal.visible && params.maxScrollLeft > 0 && horizontalTrackWidth > 0) {
     const thickness = horizontal.thickness;
-    const buttonSize = Math.min(thickness, horizontalTrackWidth / 3);
-    const trackX = horizontalLeft + buttonSize;
-    const trackWidth = Math.max(horizontalTrackWidth - buttonSize * 2, 0);
-    const thumbWidth = Math.min(
-      Math.max(
-        params.centerVisibleWidth / params.centerContentWidth * trackWidth,
-        MIN_SCROLLBAR_THUMB_SIZE
-      ),
-      trackWidth
-    );
-    const thumbOffset = params.maxScrollLeft === 0 ? 0 : params.scrollLeft / params.maxScrollLeft * (trackWidth - thumbWidth);
-    layout.horizontal = {
-      decreaseButton: {
-        x: horizontalLeft,
-        y: horizontalTrackY,
-        width: buttonSize,
-        height: thickness
-      },
-      increaseButton: {
-        x: horizontalLeft + horizontalTrackWidth - buttonSize,
+    if (horizontal.mode === "button") {
+      const halfWidth = horizontalTrackWidth / 2;
+      const empty = {
+        x: horizontalLeft + halfWidth,
         y: horizontalTrackY,
-        width: buttonSize,
-        height: thickness
-      },
-      track: {
-        x: trackX,
-        y: horizontalTrackY,
-        width: trackWidth,
-        height: thickness
-      },
-      thumb: {
-        x: trackX + thumbOffset,
-        y: horizontalTrackY,
-        width: thumbWidth,
-        height: thickness
-      }
-    };
+        width: 0,
+        height: 0
+      };
+      layout.horizontal = {
+        decreaseButton: {
+          x: horizontalLeft,
+          y: horizontalTrackY,
+          width: halfWidth,
+          height: thickness
+        },
+        increaseButton: {
+          x: horizontalLeft + halfWidth,
+          y: horizontalTrackY,
+          width: horizontalTrackWidth - halfWidth,
+          height: thickness
+        },
+        track: empty,
+        thumb: empty
+      };
+    } else {
+      const buttonSize = Math.min(thickness, horizontalTrackWidth / 3);
+      const trackX = horizontalLeft + buttonSize;
+      const trackWidth = Math.max(horizontalTrackWidth - buttonSize * 2, 0);
+      const thumbWidth = Math.min(
+        Math.max(
+          params.centerVisibleWidth / params.centerContentWidth * trackWidth,
+          MIN_SCROLLBAR_THUMB_SIZE
+        ),
+        trackWidth
+      );
+      const thumbOffset = params.maxScrollLeft === 0 ? 0 : params.scrollLeft / params.maxScrollLeft * (trackWidth - thumbWidth);
+      layout.horizontal = {
+        decreaseButton: {
+          x: horizontalLeft,
+          y: horizontalTrackY,
+          width: buttonSize,
+          height: thickness
+        },
+        increaseButton: {
+          x: horizontalLeft + horizontalTrackWidth - buttonSize,
+          y: horizontalTrackY,
+          width: buttonSize,
+          height: thickness
+        },
+        track: {
+          x: trackX,
+          y: horizontalTrackY,
+          width: trackWidth,
+          height: thickness
+        },
+        thumb: {
+          x: trackX + thumbOffset,
+          y: horizontalTrackY,
+          width: thumbWidth,
+          height: thickness
+        }
+      };
+    }
   }
   const verticalTrackHeight = Math.max(
     params.bodyHeight - verticalTop - verticalBottom,
@@ -21646,43 +22461,69 @@ function computeScrollbarLayout(params) {
   const verticalTrackY = params.bodyTop + verticalTop;
   if (vertical.visible && params.maxScrollTop > 0 && verticalTrackHeight > 0) {
     const thickness = vertical.thickness;
-    const buttonSize = Math.min(thickness, verticalTrackHeight / 3);
-    const trackY = verticalTrackY + buttonSize;
-    const trackHeight = Math.max(verticalTrackHeight - buttonSize * 2, 0);
-    const thumbHeight = Math.min(
-      Math.max(
-        params.bodyHeight / params.totalBodyHeight * trackHeight,
-        MIN_SCROLLBAR_THUMB_SIZE
-      ),
-      trackHeight
-    );
-    const thumbOffset = params.maxScrollTop === 0 ? 0 : params.scrollTop / params.maxScrollTop * (trackHeight - thumbHeight);
-    layout.vertical = {
-      decreaseButton: {
-        x: verticalTrackX,
-        y: verticalTrackY,
-        width: thickness,
-        height: buttonSize
-      },
-      increaseButton: {
-        x: verticalTrackX,
-        y: verticalTrackY + verticalTrackHeight - buttonSize,
-        width: thickness,
-        height: buttonSize
-      },
-      track: {
-        x: verticalTrackX,
-        y: trackY,
-        width: thickness,
-        height: trackHeight
-      },
-      thumb: {
+    if (vertical.mode === "button") {
+      const halfHeight = verticalTrackHeight / 2;
+      const empty = {
         x: verticalTrackX,
-        y: trackY + thumbOffset,
-        width: thickness,
-        height: thumbHeight
-      }
-    };
+        y: verticalTrackY + halfHeight,
+        width: 0,
+        height: 0
+      };
+      layout.vertical = {
+        decreaseButton: {
+          x: verticalTrackX,
+          y: verticalTrackY,
+          width: thickness,
+          height: halfHeight
+        },
+        increaseButton: {
+          x: verticalTrackX,
+          y: verticalTrackY + halfHeight,
+          width: thickness,
+          height: verticalTrackHeight - halfHeight
+        },
+        track: empty,
+        thumb: empty
+      };
+    } else {
+      const buttonSize = Math.min(thickness, verticalTrackHeight / 3);
+      const trackY = verticalTrackY + buttonSize;
+      const trackHeight = Math.max(verticalTrackHeight - buttonSize * 2, 0);
+      const thumbHeight = Math.min(
+        Math.max(
+          params.bodyHeight / params.totalBodyHeight * trackHeight,
+          MIN_SCROLLBAR_THUMB_SIZE
+        ),
+        trackHeight
+      );
+      const thumbOffset = params.maxScrollTop === 0 ? 0 : params.scrollTop / params.maxScrollTop * (trackHeight - thumbHeight);
+      layout.vertical = {
+        decreaseButton: {
+          x: verticalTrackX,
+          y: verticalTrackY,
+          width: thickness,
+          height: buttonSize
+        },
+        increaseButton: {
+          x: verticalTrackX,
+          y: verticalTrackY + verticalTrackHeight - buttonSize,
+          width: thickness,
+          height: buttonSize
+        },
+        track: {
+          x: verticalTrackX,
+          y: trackY,
+          width: thickness,
+          height: trackHeight
+        },
+        thumb: {
+          x: verticalTrackX,
+          y: trackY + thumbOffset,
+          width: thickness,
+          height: thumbHeight
+        }
+      };
+    }
   }
   return layout;
 }
@@ -21900,30 +22741,25 @@ function resolveColumnSegments(params) {
 // src/domain/columns/header-layout.ts
 function buildHeaderLayouts(nodes, leafColumns, rightStartX, headerRowHeight, fixedWidthLeft, fixedWidthRight, scrollLeft) {
   const rows = /* @__PURE__ */ new Map();
-  const leftCols = leafColumns.filter((c) => c.fixed === "left");
-  const centerCols = leafColumns.filter((c) => !c.fixed);
-  const rightCols = leafColumns.filter((c) => c.fixed === "right");
-  function segmentOffset(cols, targetKey) {
-    let offset = 0;
-    for (const c of cols) {
-      if (c.key === targetKey) return offset;
-      offset += c.width;
-    }
-    return offset;
-  }
-  const getLeafX = (leafIndex) => {
-    const leaf = leafColumns[leafIndex];
-    if (!leaf) {
-      return 0;
-    }
+  let leftX = 0;
+  let centerX = fixedWidthLeft - scrollLeft;
+  let rightX = rightStartX;
+  const leafPositions = leafColumns.map((leaf) => {
     if (leaf.fixed === "left") {
-      return segmentOffset(leftCols, leaf.key);
+      const x2 = leftX;
+      leftX += leaf.width;
+      return x2;
     }
     if (leaf.fixed === "right") {
-      return rightStartX + segmentOffset(rightCols, leaf.key);
+      const x2 = rightX;
+      rightX += leaf.width;
+      return x2;
     }
-    return fixedWidthLeft + segmentOffset(centerCols, leaf.key) - scrollLeft;
-  };
+    const x = centerX;
+    centerX += leaf.width;
+    return x;
+  });
+  const getLeafX = (leafIndex) => leafPositions[leafIndex] ?? 0;
   const visit = (node) => {
     const rowItems = rows.get(node.depth) ?? [];
     buildHeaderCellSegments(node, leafColumns, {
@@ -23524,13 +24360,15 @@ var AUTO_ROW_HEIGHT_SAMPLE_COUNT = 200;
 function buildListTableRenderSnapshot(params) {
   if (params.cache?.snapshot && params.cache.snapshot.groupIndex === params.cache.groupIndex && isSameRenderCacheInputs(params.cache.inputs, params)) {
     const snapshotStartedAt2 = resolvePerformanceNow3();
-    const snapshot2 = updateListTableRenderSnapshotScroll({
+    const cached = params.cache.snapshot;
+    const snapshot2 = !cached.swapAnimation && cached.scroll.left === params.scroll.left && cached.scroll.top === params.scroll.top ? cached : updateListTableRenderSnapshotScroll({
       snapshot: params.cache.snapshot,
       width: params.width,
       height: params.height,
       scroll: params.scroll,
       options: params.options
     });
+    params.cache.snapshot = snapshot2;
     params.options.debug?.onPerformance?.({
       phase: "snapshot",
       durationMs: resolvePerformanceNow3() - snapshotStartedAt2,
@@ -23893,6 +24731,7 @@ function buildListTableRenderSnapshot(params) {
   });
   const scrollbarLayout = computeScrollbarLayout({
     width: hostWidth,
+    rowSelectorWidth: leafColumns.find((column) => column.key === ROW_SELECTOR_COLUMN_KEY)?.width ?? 0,
     height: hostHeight,
     bodyTop: bodyState.bodyLayout.scrollBodyTop,
     bodyHeight: bodyState.bodyLayout.scrollBodyHeight,
@@ -24105,12 +24944,13 @@ function updateListTableRenderSnapshotScroll(params) {
     scroll
   });
   const nextScroll = viewportResult.scroll;
-  const columnSegments = resolveColumnSegments({
+  const reuseHorizontalLayout = nextScroll.left === snapshot.scroll.left && !snapshot.swapAnimation;
+  const columnSegments = reuseHorizontalLayout ? snapshot.columnSegments : resolveColumnSegments({
     metrics: snapshot.columnMetrics,
     scrollLeft: nextScroll.left,
     swapAnimation: snapshot.swapAnimation
   });
-  const headerRows = buildHeaderLayouts(
+  const headerRows = reuseHorizontalLayout ? snapshot.headerRows : buildHeaderLayouts(
     snapshot.headerTree,
     snapshot.leafColumns,
     snapshot.columnMetrics.rightStartX,
@@ -24119,7 +24959,8 @@ function updateListTableRenderSnapshotScroll(params) {
     snapshot.columnMetrics.fixedWidthRight,
     nextScroll.left
   );
-  offsetHeaderRows(headerRows, snapshot.groupingBarHeight);
+  if (!reuseHorizontalLayout)
+    offsetHeaderRows(headerRows, snapshot.groupingBarHeight);
   if (snapshot.swapAnimation) {
     applyColumnSegmentPositionsToHeaderRows({
       headerRows,
@@ -24129,6 +24970,9 @@ function updateListTableRenderSnapshotScroll(params) {
   }
   const scrollbarLayout = computeScrollbarLayout({
     width,
+    rowSelectorWidth: snapshot.leafColumns.find(
+      (column) => column.key === ROW_SELECTOR_COLUMN_KEY
+    )?.width ?? 0,
     height,
     bodyTop: snapshot.bodyLayout.scrollBodyTop,
     bodyHeight: snapshot.bodyLayout.scrollBodyHeight,
@@ -24467,7 +25311,7 @@ function buildListTableDebugSnapshot(params) {
     hitTest: hitTest2.area === "empty" ? void 0 : hitTest2
   };
 }
-function drawScrollbars(ctx, layout, descriptors, borderColor, opacity = 1, interactive = true, verticalFrame, options) {
+function drawScrollbars(ctx, layout, descriptors, borderColor, opacity = 1, interactive = true, verticalFrame, options, hover) {
   const alpha = Number.isFinite(opacity) ? Math.min(Math.max(opacity, 0), 1) : 1;
   if (alpha <= 1e-3) {
     return;
@@ -24492,7 +25336,8 @@ function drawScrollbars(ctx, layout, descriptors, borderColor, opacity = 1, inte
       descriptors,
       borderColor,
       interactive,
-      utils.resolveCanvasScrollbarAxis(options, "horizontal")
+      utils.resolveCanvasScrollbarAxis(options, "horizontal"),
+      hover
     );
   }
   if (layout.vertical) {
@@ -24503,7 +25348,8 @@ function drawScrollbars(ctx, layout, descriptors, borderColor, opacity = 1, inte
       descriptors,
       borderColor,
       interactive,
-      utils.resolveCanvasScrollbarAxis(options, "vertical")
+      utils.resolveCanvasScrollbarAxis(options, "vertical"),
+      hover
     );
   }
   if (layout.horizontal) {
@@ -24514,10 +25360,13 @@ function drawScrollbars(ctx, layout, descriptors, borderColor, opacity = 1, inte
       borderColor
     );
   }
+  if (layout.vertical) {
+    drawVerticalAxisFrame(ctx, layout.vertical, borderColor, verticalFrame);
+  }
   ctx.restore();
 }
 function drawHorizontalScrollbarMask(ctx, layout, backgroundColor) {
-  const left = layout.decreaseButton.x;
+  const left = 0;
   const right = layout.increaseButton.x + layout.increaseButton.width;
   const top = layout.decreaseButton.y;
   const height = layout.decreaseButton.height;
@@ -24530,7 +25379,7 @@ function drawHorizontalScrollbarMask(ctx, layout, backgroundColor) {
   ctx.restore();
 }
 function drawHorizontalScrollbarTopBorder(ctx, horizontal, vertical, borderColor) {
-  const left = Math.round(horizontal.decreaseButton.x) + 0.5;
+  const left = 0.5;
   const horizontalRight = horizontal.increaseButton.x + horizontal.increaseButton.width;
   const verticalRight = vertical ? vertical.decreaseButton.x + vertical.decreaseButton.width : horizontalRight;
   const right = Math.round(Math.max(horizontalRight, verticalRight)) - 0.5;
@@ -24547,21 +25396,23 @@ function drawHorizontalScrollbarTopBorder(ctx, horizontal, vertical, borderColor
   ctx.stroke();
   ctx.restore();
 }
-function drawAxisScrollbar(ctx, layout, axis, descriptors, borderColor, interactive, style) {
+function drawAxisScrollbar(ctx, layout, axis, descriptors, borderColor, interactive, style, hover) {
   const kind = axis === "horizontal" ? "horizontal-scrollbar" : "vertical-scrollbar";
   if (interactive) {
-    descriptors.push({
-      kind,
-      rect: layout.thumb,
-      columnKey: `__${axis}_scrollbar_thumb__`,
-      scrollbarRole: "thumb"
-    });
-    descriptors.push({
-      kind,
-      rect: layout.track,
-      columnKey: `__${axis}_scrollbar_track__`,
-      scrollbarRole: "track"
-    });
+    if (style.mode === "scrollbar") {
+      descriptors.push({
+        kind,
+        rect: layout.thumb,
+        columnKey: `__${axis}_scrollbar_thumb__`,
+        scrollbarRole: "thumb"
+      });
+      descriptors.push({
+        kind,
+        rect: layout.track,
+        columnKey: `__${axis}_scrollbar_track__`,
+        scrollbarRole: "track"
+      });
+    }
     descriptors.push({
       kind,
       rect: layout.decreaseButton,
@@ -24587,10 +25438,101 @@ function drawAxisScrollbar(ctx, layout, axis, descriptors, borderColor, interact
     }
     ctx.restore();
   }
+  if (style.mode === "scrollbar") {
+    const pressedTrack = hover?.pressedScrollbarPart?.axis === axis && hover.pressedScrollbarPart.role === "track";
+    const hoveredTrack = hover?.area === `${axis}-scrollbar` && hover.scrollbarRole === "track";
+    if (pressedTrack || hoveredTrack) {
+      ctx.fillStyle = pressedTrack ? style.buttonPressedBackgroundColor : style.buttonHoverBackgroundColor;
+      ctx.fillRect(
+        layout.track.x,
+        layout.track.y,
+        layout.track.width,
+        layout.track.height
+      );
+    }
+  }
+  for (const [role, rect] of [
+    ["decrease-button", layout.decreaseButton],
+    ["increase-button", layout.increaseButton]
+  ]) {
+    const pressed = hover?.pressedScrollbarButton?.axis === axis && hover.pressedScrollbarButton.role === role;
+    const hovered = hover?.area === `${axis}-scrollbar` && hover.scrollbarRole === role;
+    const background = pressed ? style.buttonPressedBackgroundColor : hovered ? style.buttonHoverBackgroundColor : style.buttonBackgroundColor;
+    if (background) {
+      ctx.fillStyle = background;
+      ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+    }
+  }
   drawButton(ctx, layout.decreaseButton, axis, "decrease", style.buttonColor);
   drawButton(ctx, layout.increaseButton, axis, "increase", style.buttonColor);
-  drawThumb(ctx, layout.thumb, style);
-  drawTrackBorder(ctx, layout.track, axis, borderColor);
+  if (style.mode === "button") {
+    drawButtonDivider(ctx, layout.increaseButton, axis, borderColor);
+    if (axis === "horizontal") {
+      drawButtonModeFrame(ctx, layout.decreaseButton, borderColor);
+    }
+  } else {
+    const pressedThumb = hover?.pressedScrollbarPart?.axis === axis && hover.pressedScrollbarPart.role === "thumb";
+    const hoveredThumb = hover?.area === `${axis}-scrollbar` && hover.scrollbarRole === "thumb";
+    drawThumb(
+      ctx,
+      layout.thumb,
+      style,
+      pressedThumb ? style.buttonPressedBackgroundColor : hoveredThumb ? style.buttonHoverBackgroundColor : void 0
+    );
+    drawTrackBorder(ctx, layout.track, axis, borderColor);
+    if (axis === "horizontal") {
+      drawButtonModeFrame(ctx, layout.decreaseButton, borderColor);
+    }
+  }
+}
+function drawButtonModeFrame(ctx, first, borderColor) {
+  const left = Math.round(first.x) + 0.5;
+  const top = Math.round(first.y) + 0.5;
+  ctx.save();
+  ctx.strokeStyle = borderColor;
+  ctx.lineWidth = 1;
+  ctx.beginPath();
+  ctx.moveTo(left, top);
+  ctx.lineTo(left, Math.round(first.y + first.height) - 0.5);
+  ctx.stroke();
+  ctx.restore();
+}
+function drawVerticalAxisFrame(ctx, layout, borderColor, frame) {
+  const first = layout.decreaseButton;
+  const last = layout.increaseButton;
+  const left = Math.round(first.x) + 0.5;
+  const right = Math.round(first.x + first.width) - 0.5;
+  const top = Math.round(frame?.top ?? first.y) + 0.5;
+  const buttonTop = Math.round(first.y) + 0.5;
+  const bottom = Math.round(frame ? frame.top + frame.height : last.y + last.height) - 0.5;
+  if (right <= left || bottom <= top) return;
+  ctx.save();
+  ctx.strokeStyle = borderColor;
+  ctx.lineWidth = 1;
+  ctx.beginPath();
+  ctx.moveTo(left, bottom);
+  ctx.lineTo(left, top);
+  ctx.moveTo(left, buttonTop);
+  ctx.lineTo(right, buttonTop);
+  ctx.stroke();
+  ctx.restore();
+}
+function drawButtonDivider(ctx, second, axis, borderColor) {
+  ctx.save();
+  ctx.strokeStyle = borderColor;
+  ctx.lineWidth = 1;
+  ctx.beginPath();
+  if (axis === "horizontal") {
+    const x = Math.round(second.x) + 0.5;
+    ctx.moveTo(x, second.y);
+    ctx.lineTo(x, second.y + second.height);
+  } else {
+    const y = Math.round(second.y) + 0.5;
+    ctx.moveTo(Math.round(second.x) + 0.5, y);
+    ctx.lineTo(Math.round(second.x + second.width) - 0.5, y);
+  }
+  ctx.stroke();
+  ctx.restore();
 }
 function drawTrackBorder(ctx, rect, axis, borderColor) {
   const left = Math.round(rect.x) + 0.5;
@@ -24652,7 +25594,7 @@ function drawVerticalScrollbarFrame(ctx, frame, borderColor) {
   }
   ctx.restore();
 }
-function drawThumb(ctx, rect, style) {
+function drawThumb(ctx, rect, style, highlightColor) {
   ctx.save();
   ctx.fillStyle = style.thumbColor;
   roundRect2(
@@ -24664,6 +25606,18 @@ function drawThumb(ctx, rect, style) {
     style.thumbRadius ?? rect.height / 2
   );
   ctx.fill();
+  if (highlightColor) {
+    ctx.fillStyle = highlightColor;
+    roundRect2(
+      ctx,
+      rect.x,
+      rect.y,
+      rect.width,
+      rect.height,
+      style.thumbRadius ?? rect.height / 2
+    );
+    ctx.fill();
+  }
   ctx.restore();
 }
 function drawButton(ctx, rect, axis, direction, color) {
@@ -24995,6 +25949,7 @@ function drawListTableHeader(params) {
   const collapsedColumnMarkers = resolveCollapsedHeaderColumnMarkers({
     columns: options.columns,
     visibleColumnKeys: leafColumns.map((column) => column.key),
+    showCollapsedColumnIcon: options.showCollapsedColumnIcon,
     // 系统列是否存在由功能配置决定，不属于用户隐藏的业务列，不能绘制恢复标记。
     excludedColumnKeys: [
       ...groupingColumnKeys ?? [],
@@ -25093,7 +26048,7 @@ function resolveActiveCellOverlayLayout(params) {
     highlightMode: params.highlightMode,
     columnKeys: params.columnKeys ?? [],
     allowColumnRange: selection.rowIndex == null,
-    allowRowRange: selection.columnKey === ROW_SELECTOR_COLUMN_KEY,
+    allowRowRange: selection.columnKey === ROW_SELECTOR_COLUMN_KEY || params.rangeHighlight?.selectedRowRanges != null || params.rangeHighlight?.selectedCellRanges != null && params.rangeHighlight.selectedRowRange != null,
     resolveClipRect: (item) => resolveActiveCellSectionClipRect(item, params),
     width: params.width,
     height: params.height
@@ -25184,10 +26139,13 @@ function drawActiveCellOverlay(params) {
 }
 function resolveRangeHighlightLayouts(params) {
   const rowRange = params.rangeHighlight?.selectedRowRange;
+  const rowRanges = params.rangeHighlight?.selectedRowRanges ?? (rowRange ? [rowRange] : []);
   const columnRange = params.rangeHighlight?.selectedColumnRange;
+  const selectedColumnKeys = params.rangeHighlight?.selectedColumnKeys;
   const cellRange = params.rangeHighlight?.selectedCellRange;
-  const rowSelectorRange = rowRange && params.allowRowRange;
-  if (!cellRange && !rowSelectorRange && (!columnRange || !params.allowColumnRange)) {
+  const cellRanges = params.rangeHighlight?.selectedCellRanges ?? (cellRange ? [cellRange] : []);
+  const rowSelectorRange = rowRanges.length > 0 && params.allowRowRange;
+  if (cellRanges.length === 0 && !rowSelectorRange && (!(columnRange || selectedColumnKeys?.length) || !params.allowColumnRange)) {
     return { rects: [], segments: [] };
   }
   const bodyDescriptors = params.descriptors.filter(
@@ -25196,20 +26154,33 @@ function resolveRangeHighlightLayouts(params) {
   const selected = bodyDescriptors.filter((item) => {
     const itemRowStart = item.rowIndex;
     const itemRowEnd = itemRowStart + Math.max(item.rowSpan ?? 1, 1) - 1;
-    const rowSelected = rowRange != null && itemRowEnd >= rowRange.start && itemRowStart <= rowRange.end;
+    const rowSelected = rowRanges.some(
+      (range) => itemRowEnd >= range.start && itemRowStart <= range.end
+    );
     const columnIndex = params.columnKeys.indexOf(item.columnKey);
-    const columnSelected = columnRange != null && columnIndex >= columnRange.start && columnIndex <= columnRange.end;
-    if (cellRange) {
-      return itemRowEnd >= cellRange.startRowIndex && itemRowStart <= cellRange.endRowIndex && columnIndex >= cellRange.startColumnIndex && columnIndex <= cellRange.endColumnIndex;
-    }
-    if (rowSelectorRange) {
-      return rowSelected;
-    }
-    return params.allowColumnRange && columnSelected;
+    const columnSelected = selectedColumnKeys != null ? selectedColumnKeys.includes(item.columnKey) : columnRange != null && columnIndex >= columnRange.start && columnIndex <= columnRange.end;
+    const cellSelected = cellRanges.some(
+      (range) => itemRowEnd >= range.startRowIndex && itemRowStart <= range.endRowIndex && columnIndex >= range.startColumnIndex && columnIndex <= range.endColumnIndex
+    );
+    return cellSelected || rowSelectorRange && rowSelected || params.allowColumnRange && columnSelected;
   });
   const groups = /* @__PURE__ */ new Map();
+  const selectedKeySet = new Set(selectedColumnKeys ?? []);
   selected.forEach((descriptor) => {
-    const groupKey = cellRange || rowSelectorRange ? `${descriptor.fixed ?? "center"}:${descriptor.frozen ? "frozen" : "scroll"}` : `column:${descriptor.fixed ?? "center"}:${descriptor.frozen ? "frozen" : "scroll"}`;
+    const columnIndex = params.columnKeys.indexOf(descriptor.columnKey);
+    let runStart = columnIndex;
+    if (selectedColumnKeys != null) {
+      while (runStart > 0 && selectedKeySet.has(params.columnKeys[runStart - 1])) {
+        runStart--;
+      }
+    }
+    const cellRangeIndex = cellRanges.findIndex(
+      (range) => descriptor.rowIndex >= range.startRowIndex && descriptor.rowIndex <= range.endRowIndex && columnIndex >= range.startColumnIndex && columnIndex <= range.endColumnIndex
+    );
+    const rowRangeIndex = rowRanges.findIndex(
+      (range) => descriptor.rowIndex >= range.start && descriptor.rowIndex <= range.end
+    );
+    const groupKey = rowSelectorRange && rowRangeIndex >= 0 ? `row:${rowRangeIndex}:${descriptor.fixed ?? "center"}:${descriptor.frozen ? "frozen" : "scroll"}` : cellRangeIndex >= 0 ? `cell:${cellRangeIndex}:${descriptor.fixed ?? "center"}:${descriptor.frozen ? "frozen" : "scroll"}` : `column:${selectedColumnKeys != null ? runStart : "range"}:${descriptor.fixed ?? "center"}:${descriptor.frozen ? "frozen" : "scroll"}`;
     const current = groups.get(groupKey);
     const rect = current ? {
       x: Math.min(current.rect.x, descriptor.rect.x),
@@ -25244,8 +26215,8 @@ function resolveRangeHighlightLayouts(params) {
     );
     return {
       ...range,
-      omitLeft: range.rect.x > minX,
-      omitRight: range.rect.x + range.rect.width < maxX
+      omitLeft: selectedColumnKeys == null && range.rect.x > minX,
+      omitRight: selectedColumnKeys == null && range.rect.x + range.rect.width < maxX
     };
   });
   const rangeSegments = resolveRangeBorderSegments(
@@ -25762,7 +26733,8 @@ function executeListTableRenderPipeline(params) {
       headerBackgroundColor: theme.headerBackgroundColor,
       bodyBackgroundColor: theme.backgroundColor
     },
-    options.scrollbar
+    options.scrollbar,
+    hover
   );
   drawActiveCellOverlay({
     ctx,
@@ -25815,8 +26787,8 @@ function drawGroupingBar(params) {
   ctx.fillRect(0, 0, width, height);
   ctx.strokeStyle = theme.borderColor;
   ctx.beginPath();
-  ctx.moveTo(0, height - 0.5);
-  ctx.lineTo(width, height - 0.5);
+  ctx.moveTo(0, height + 0.5);
+  ctx.lineTo(width, height + 0.5);
   ctx.stroke();
   ctx.fillStyle = theme.headerTextColor;
   ctx.font = `${theme.headerFontWeight} ${theme.fontSize}px ${theme.fontFamily}`;
@@ -25908,6 +26880,16 @@ function drawColumnResizeIndicator(params) {
 // src/services/image-clipboard-service.ts
 var MAX_IMAGE_SIDE = 16384;
 var MAX_IMAGE_PIXELS = 16e6;
+function collectSelectedIndices(ranges, count) {
+  const indices = /* @__PURE__ */ new Set();
+  for (const range of ranges) {
+    for (let index = Math.max(range.start, 0); index <= Math.min(range.end, count - 1); index++) {
+      indices.add(index);
+      if (indices.size > MAX_IMAGE_SIDE) return null;
+    }
+  }
+  return [...indices].sort((left, right) => left - right);
+}
 function assertTableImageSize(width, height) {
   if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
     throw new Error("\u6CA1\u6709\u53EF\u590D\u5236\u7684\u8868\u683C\u533A\u57DF\u3002");
@@ -25918,8 +26900,96 @@ function assertTableImageSize(width, height) {
 }
 function resolveImageSelection(host) {
   const state = host.rangeHighlight;
-  if (state.selectedCellRange) return state.selectedCellRange;
   const rowCount = host.getDisplayData().length;
+  const columnCount = host.leafColumns.length;
+  if (state.selectedCellRanges != null) {
+    const rowRanges = state.selectedRowRanges ?? (state.selectedRowRange ? [state.selectedRowRange] : []);
+    if (!state.selectedCellRanges.length && !rowRanges.length) return null;
+    const rowIndices = collectSelectedIndices(
+      [
+        ...state.selectedCellRanges.map((range) => ({
+          start: range.startRowIndex,
+          end: range.endRowIndex
+        })),
+        ...rowRanges
+      ],
+      rowCount
+    );
+    if (rowIndices === null) {
+      return {
+        startRowIndex: 0,
+        endRowIndex: rowCount - 1,
+        startColumnIndex: 0,
+        endColumnIndex: columnCount - 1,
+        tooLarge: true
+      };
+    }
+    const columnIndices = collectSelectedIndices(
+      rowRanges.length ? [{ start: 0, end: columnCount - 1 }] : state.selectedCellRanges.map((range) => ({
+        start: range.startColumnIndex,
+        end: range.endColumnIndex
+      })),
+      columnCount
+    );
+    if (columnIndices === null) {
+      return {
+        startRowIndex: 0,
+        endRowIndex: rowCount - 1,
+        startColumnIndex: 0,
+        endColumnIndex: columnCount - 1,
+        tooLarge: true
+      };
+    }
+    if (!rowIndices.length || !columnIndices.length) return null;
+    return {
+      startRowIndex: rowIndices[0],
+      endRowIndex: rowIndices[rowIndices.length - 1],
+      startColumnIndex: columnIndices[0],
+      endColumnIndex: columnIndices[columnIndices.length - 1],
+      rowIndices,
+      columnIndices,
+      cellRanges: state.selectedCellRanges,
+      rowRanges
+    };
+  }
+  if (state.selectedCellRange) return state.selectedCellRange;
+  if (state.selectedColumnKeys != null) {
+    const columnIndices = host.leafColumns.flatMap(
+      (column, index) => state.selectedColumnKeys?.includes(column.key) ? [index] : []
+    );
+    if (!columnIndices.length || !rowCount) return null;
+    return {
+      startRowIndex: 0,
+      endRowIndex: rowCount - 1,
+      startColumnIndex: columnIndices[0],
+      endColumnIndex: columnIndices[columnIndices.length - 1],
+      columnIndices
+    };
+  }
+  if (state.selectedRowRanges != null) {
+    if (!state.selectedRowRanges.length) return null;
+    const rowIndices = collectSelectedIndices(
+      state.selectedRowRanges,
+      rowCount
+    );
+    if (rowIndices === null) {
+      return {
+        startRowIndex: state.selectedRowRanges[0].start,
+        endRowIndex: state.selectedRowRanges[0].end,
+        startColumnIndex: 0,
+        endColumnIndex: columnCount - 1,
+        tooLarge: true
+      };
+    }
+    if (!rowIndices.length || !columnCount) return null;
+    return {
+      startRowIndex: rowIndices[0],
+      endRowIndex: rowIndices[rowIndices.length - 1],
+      startColumnIndex: 0,
+      endColumnIndex: columnCount - 1,
+      rowIndices
+    };
+  }
   const columnIndex = host.leafColumns.findIndex(
     (column) => column.key === host.selection.columnKey
   );
@@ -25935,7 +27005,7 @@ function resolveImageSelection(host) {
       startRowIndex: state.selectedRowRange.start,
       endRowIndex: state.selectedRowRange.end,
       startColumnIndex: 0,
-      endColumnIndex: host.leafColumns.length - 1
+      endColumnIndex: columnCount - 1
     };
   if (host.selection.rowIndex != null && columnIndex >= 0)
     return {
@@ -25967,23 +27037,50 @@ function renderTableCopyImage(host, scope) {
   const range = scope === "selection" ? resolveImageSelection(host) : null;
   if (scope === "selection" && !range)
     throw new Error("\u8BF7\u5148\u9009\u4E2D\u9700\u8981\u590D\u5236\u7684\u5355\u5143\u683C\u533A\u57DF\u3002");
+  if (range?.tooLarge)
+    throw new Error("\u56FE\u7247\u533A\u57DF\u8FC7\u5927\uFF0C\u8BF7\u7F29\u5C0F\u9009\u533A\u6216\u9009\u62E9\u201C\u89C6\u53E3\u533A\u57DF\u201D\u3002");
   const startRow = range ? Math.max(Math.min(range.startRowIndex, range.endRowIndex), 0) : 0;
   const endRow = range ? Math.max(range.startRowIndex, range.endRowIndex) : current.baseRows.length - 1;
   const startColumn = range ? Math.max(Math.min(range.startColumnIndex, range.endColumnIndex), 0) : 0;
   const endColumn = range ? Math.max(range.startColumnIndex, range.endColumnIndex) : current.leafColumns.length - 1;
-  const columns = current.leafColumns.slice(startColumn, endColumn + 1);
+  if (range && ((range.rowIndices?.length ?? endRow - startRow + 1) > MAX_IMAGE_SIDE || (range.columnIndices?.length ?? endColumn - startColumn + 1) > MAX_IMAGE_SIDE)) {
+    throw new Error("\u56FE\u7247\u533A\u57DF\u8FC7\u5927\uFF0C\u8BF7\u7F29\u5C0F\u9009\u533A\u6216\u9009\u62E9\u201C\u89C6\u53E3\u533A\u57DF\u201D\u3002");
+  }
+  const selectedRowIndices = range?.rowIndices ?? (range ? Array.from(
+    { length: endRow - startRow + 1 },
+    (_, index) => startRow + index
+  ) : null);
+  const selectedColumnIndices = range?.columnIndices ?? (range ? Array.from(
+    { length: endColumn - startColumn + 1 },
+    (_, index) => startColumn + index
+  ) : null);
+  const columns = selectedColumnIndices ? selectedColumnIndices.map((index) => current.leafColumns[index]) : current.leafColumns;
   const width = columns.reduce((total, column) => total + column.width, 0);
-  const rowCount = range ? endRow - startRow + 1 : current.baseRows.length;
+  const rowCount = selectedRowIndices?.length ?? current.baseRows.length;
   const dpr = source.ownerDocument.defaultView?.devicePixelRatio || 1;
   const zoom = host.tableZoom || 1;
   assertTableImageSize(
     Math.ceil(width * zoom * dpr),
     Math.ceil(Math.max(rowCount, 1) * current.rowHeight * zoom * dpr)
   );
-  const rows = range ? current.displayRows.slice(startRow, endRow + 1) : current.baseRows;
+  const rows = selectedRowIndices ? selectedRowIndices.map((index) => current.displayRows[index]) : current.baseRows;
   const keys = new Set(columns.map((column) => column.key));
   if (!range) state?.groupColumnKeys.forEach((key) => keys.add(key));
   const widths = new Map(columns.map((column) => [column.key, column.width]));
+  const originalColumnIndices = new Map(
+    current.leafColumns.map((column, index) => [column.key, index])
+  );
+  const isCellSelected = (rowIndex, columnKey) => {
+    if (!range?.cellRanges) return true;
+    if (range.rowRanges?.some(
+      (rowRange) => rowIndex >= rowRange.start && rowIndex <= rowRange.end
+    ))
+      return true;
+    const columnIndex = originalColumnIndices.get(columnKey);
+    return columnIndex != null && range.cellRanges.some(
+      (cellRange) => rowIndex >= cellRange.startRowIndex && rowIndex <= cellRange.endRowIndex && columnIndex >= cellRange.startColumnIndex && columnIndex <= cellRange.endColumnIndex
+    );
+  };
   const cloneColumns2 = (items) => items.flatMap((column) => {
     const children = column.children ? cloneColumns2(column.children) : void 0;
     if (children ? !children.length : !keys.has(String(column.key)))
@@ -25996,8 +27093,21 @@ function renderTableCopyImage(host, scope) {
         children,
         fixed: void 0,
         width: widths.get(String(column.key)) ?? column.width,
-        onCell: onCell && range ? (value, record, index, context) => onCell(value, record, index + startRow, context) : onCell,
-        render: render && range ? (value, record, index, context) => render(value, record, index + startRow, context) : render
+        onCell: onCell && range ? (value, record, index, context) => onCell(
+          value,
+          record,
+          selectedRowIndices?.[index] ?? index + startRow,
+          context
+        ) : onCell,
+        render: range?.cellRanges && !children ? (value, record, index, context) => {
+          const sourceRowIndex = selectedRowIndices?.[index] ?? index + startRow;
+          return isCellSelected(sourceRowIndex, String(column.key)) ? render?.(value, record, sourceRowIndex, context) ?? null : "";
+        } : render && range ? (value, record, index, context) => render(
+          value,
+          record,
+          selectedRowIndices?.[index] ?? index + startRow,
+          context
+        ) : render
       }
     ];
   });
@@ -26086,7 +27196,7 @@ function renderTableCopyImage(host, scope) {
     fixedLeftBoundarySkips: [],
     getNestedTableHighlight: (params) => host.animationController.getNestedTableHighlight({
       ...params,
-      rowIndex: params.rowIndex + startRow
+      rowIndex: selectedRowIndices?.[params.rowIndex] ?? params.rowIndex + startRow
     })
   });
   return canvas;
@@ -26536,6 +27646,7 @@ function buildHeaderDataIndexOptions(rows, columns) {
 
 // src/features/overlay/context-menu-builder.ts
 function createListTableContextMenuActions(params) {
+  const getExportColumns = () => params.getExportColumns?.() ?? params.getColumns();
   return {
     onCopyHeaderCell: (columnKey) => {
       params.hideMenu();
@@ -26591,50 +27702,82 @@ function createListTableContextMenuActions(params) {
     onExportJson: () => {
       params.hideMenu();
       params.startExportTask(
-        (fileName) => exportAllRowsJsonContent({
+        (fileName, settings) => exportAllRowsJsonContent({
           fileName,
           rows: params.getAllRows(),
-          columns: params.getColumns()
+          columns: getExportColumns(),
+          settings
         }),
         "\u6B63\u5728\u5BFC\u51FA JSON\u2026",
-        buildTableExportFileName("json")
+        buildTableExportFileName("json"),
+        {
+          columns: getListTableExportColumnChoices(
+            getExportColumns(),
+            params.getExportSortState?.()
+          ),
+          includeSummary: params.getExportSummaryEnabled?.() ?? false
+        }
       );
     },
     onExportCsv: () => {
       params.hideMenu();
       params.startExportTask(
-        (fileName) => exportAllRowsCsvContent({
+        (fileName, settings) => exportAllRowsCsvContent({
           fileName,
           rows: params.getAllRows(),
-          columns: params.getColumns()
+          columns: getExportColumns(),
+          settings
         }),
         "\u6B63\u5728\u5BFC\u51FA CSV\u2026",
-        buildTableExportFileName("csv")
+        buildTableExportFileName("csv"),
+        {
+          columns: getListTableExportColumnChoices(
+            getExportColumns(),
+            params.getExportSortState?.()
+          ),
+          includeSummary: params.getExportSummaryEnabled?.() ?? false
+        }
       );
     },
     onExportTxt: () => {
       params.hideMenu();
       params.startExportTask(
-        (fileName) => exportAllRowsTxtContent({
+        (fileName, settings) => exportAllRowsTxtContent({
           fileName,
           rows: params.getAllRows(),
-          columns: params.getColumns()
+          columns: getExportColumns(),
+          settings
         }),
         "\u6B63\u5728\u5BFC\u51FA TXT\u2026",
-        buildTableExportFileName("txt")
+        buildTableExportFileName("txt"),
+        {
+          columns: getListTableExportColumnChoices(
+            getExportColumns(),
+            params.getExportSortState?.()
+          ),
+          includeSummary: params.getExportSummaryEnabled?.() ?? false
+        }
       );
     },
     onExportXlsx: () => {
       params.hideMenu();
       params.startExportTask(
-        (fileName) => exportAllRowsXlsxContent({
+        (fileName, settings) => exportAllRowsXlsxContent({
           includeSummary: params.getExportSummaryEnabled?.() ?? false,
           fileName,
           rows: params.getAllRows(),
-          columns: params.getColumns()
+          columns: getExportColumns(),
+          settings
         }),
         "\u6B63\u5728\u5BFC\u51FA XLSX\u2026",
-        buildTableExportFileName("xlsx")
+        buildTableExportFileName("xlsx"),
+        {
+          columns: getListTableExportColumnChoices(
+            getExportColumns(),
+            params.getExportSortState?.()
+          ),
+          includeSummary: params.getExportSummaryEnabled?.() ?? false
+        }
       );
     },
     onFreezeRow: params.onFreezeRow,
@@ -26789,6 +27932,7 @@ function buildListTableContextMenuConfig(params) {
   const enabledFeatures = resolveEnabledContextMenuFeatures(contextMenu);
   const isTableSettingsArea = isHeaderArea || isExpandedArea;
   const isBodyArea = bodyRowIndex != null;
+  const canResetTable = isTableSettingsArea || isBodyArea;
   const isSelectionColumn = columnKey === ROW_SELECTION_COLUMN_KEY || columnKey === ROW_SELECTOR_COLUMN_KEY;
   const enableCopy = enabledFeatures.has("copy");
   const enableChart = enabledFeatures.has("chart");
@@ -26907,19 +28051,19 @@ function buildListTableContextMenuConfig(params) {
     onUnfreezeRow: enableFreeze && isBodyArea && frozenRowPosition != null ? () => {
       actions.onUnfreezeRow(bodyRowIndex);
     } : void 0,
-    onResetFilter: enableReset && isTableSettingsArea ? actions.onResetFilter : void 0,
-    onResetSort: enableReset && isTableSettingsArea ? actions.onResetSort : void 0,
+    onResetFilter: enableReset && canResetTable ? actions.onResetFilter : void 0,
+    onResetSort: enableReset && canResetTable ? actions.onResetSort : void 0,
     onSortAscend: canSortCurrentColumn && actions.onSortAscend ? () => actions.onSortAscend?.(columnKey) : void 0,
     onSortDescend: canSortCurrentColumn && actions.onSortDescend ? () => actions.onSortDescend?.(columnKey) : void 0,
     onClearSort: canSortCurrentColumn && actions.onClearSort ? () => actions.onClearSort?.(columnKey) : void 0,
     onFixLeft: enableFreeze && isHeaderArea && !isSelectionColumn && actions.onFixLeft ? () => actions.onFixLeft?.(columnKey) : void 0,
     onFixRight: enableFreeze && isHeaderArea && !isSelectionColumn && actions.onFixRight ? () => actions.onFixRight?.(columnKey) : void 0,
     onUnfix: enableFreeze && isHeaderArea && !isSelectionColumn && actions.onUnfix ? () => actions.onUnfix?.(columnKey) : void 0,
-    onResetHeader: enableReset && isTableSettingsArea ? actions.onResetHeader : void 0,
-    onResetGrouping: enableReset && isTableSettingsArea ? actions.onResetGrouping : void 0,
-    onResetSummary: enableReset && isTableSettingsArea ? actions.onResetSummary : void 0,
-    onResetAlignment: enableReset && isTableSettingsArea ? actions.onResetAlignment : void 0,
-    onResetDataFormat: enableReset && isTableSettingsArea ? actions.onResetDataFormat : void 0,
+    onResetHeader: enableReset && canResetTable ? actions.onResetHeader : void 0,
+    onResetGrouping: enableReset && canResetTable ? actions.onResetGrouping : void 0,
+    onResetSummary: enableReset && canResetTable ? actions.onResetSummary : void 0,
+    onResetAlignment: enableReset && canResetTable ? actions.onResetAlignment : void 0,
+    onResetDataFormat: enableReset && canResetTable ? actions.onResetDataFormat : void 0,
     onAutoFitCurrentColumn: enableColumnWidth && isHeaderArea && !isSelectionColumn && actions.onAutoFitCurrentColumn ? () => actions.onAutoFitCurrentColumn?.(columnKey) : void 0,
     onAutoFitAllColumns: enableColumnWidth && isTableSettingsArea && !isSelectionColumn && actions.onAutoFitAllColumns ? actions.onAutoFitAllColumns : void 0,
     onAutoFitFillContainer: enableColumnWidth && isTableSettingsArea && !isSelectionColumn && actions.onAutoFitFillContainer ? actions.onAutoFitFillContainer : void 0,
@@ -27160,6 +28304,8 @@ function showHeaderContextMenu(params) {
     onChangeSummaryShowTypePrefix,
     onChangeColumnSettingsCache,
     onChangeCachePreference,
+    onChangeScrollbar,
+    onResetScrollbar,
     summaryVisible,
     getSelectionRange,
     onCopySelection,
@@ -27173,6 +28319,40 @@ function showHeaderContextMenu(params) {
   const isExpandedArea = result.area === "expanded-row" || result.columnKey === "__expanded_row__";
   const isSelectionColumn = result.columnKey === ROW_SELECTION_COLUMN_KEY || result.columnKey === ROW_SELECTOR_COLUMN_KEY;
   const isChartCorner = isHeaderArea && result.columnKey === ROW_SELECTOR_COLUMN_KEY && resolveEnabledContextMenuFeatures(options.contextMenu).has("chart");
+  if (result.area === "horizontal-scrollbar" || result.area === "vertical-scrollbar") {
+    if (options.contextMenu === false) {
+      headerContextMenu.hide();
+      return false;
+    }
+    event.preventDefault();
+    filterPanel.hide();
+    fixedPopup.hide();
+    hideBodyTooltip();
+    headerContextMenu.show({
+      x: event.clientX,
+      y: event.clientY,
+      scrollbarArea: true,
+      scrollbarRowCount: getRows().length,
+      scrollbarColumnCount: params.scrollbarColumnCount ?? getColumns().length,
+      onScrollToPosition: params.onScrollToPosition,
+      onResetFilter,
+      onResetSort,
+      onResetHeader,
+      onResetGrouping,
+      onResetSummary,
+      onResetAlignment,
+      onResetDataFormat,
+      scrollbar: options.scrollbar,
+      onChangeScrollbar,
+      onResetScrollbar,
+      columnSettingsCacheAvailable: Boolean(options.storageKey),
+      cacheColumnSettings: options.cacheColumnSettings,
+      cachePreferences: options.cachePreferences,
+      onChangeCachePreference,
+      onClose
+    });
+    return true;
+  }
   if (!isHeaderArea && !isBodyArea && !groupingBarArea && !isExpandedArea || !result.columnKey && !groupingBarArea && !isExpandedArea || isHeaderArea && isSelectionColumn && !isChartCorner) {
     headerContextMenu.hide();
     return false;
@@ -27194,8 +28374,8 @@ function showHeaderContextMenu(params) {
     onSelectBodyRow?.(bodyRowIndex, contextColumnKey);
   }
   const frozenRowPosition = bodyRowIndex == null ? null : getFrozenRowPosition2(bodyRowIndex);
-  headerContextMenu.show(
-    buildListTableContextMenuConfig({
+  headerContextMenu.show({
+    ...buildListTableContextMenuConfig({
       storageKey: options.storageKey,
       cacheColumnSettings: options.cacheColumnSettings,
       cachePreferences: options.cachePreferences,
@@ -27227,9 +28407,11 @@ function showHeaderContextMenu(params) {
       columnCount: getColumns().length,
       actions: createListTableContextMenuActions({
         getExportSummaryEnabled: params.getExportSummaryEnabled,
+        getExportSortState: params.getExportSortState,
         getRows,
         getAllRows,
         getColumns,
+        getExportColumns: params.getExportColumns,
         getHeaderTree,
         hideMenu: () => {
           headerContextMenu.hide();
@@ -27281,8 +28463,15 @@ function showHeaderContextMenu(params) {
         onOpenSearch,
         onCopyCustomSelection
       })
-    })
-  );
+    }),
+    sortState: params.getExportSortState?.() ?? [],
+    scrollbarRowCount: getRows().length,
+    scrollbarColumnCount: params.scrollbarColumnCount ?? getColumns().length,
+    onScrollToPosition: params.onScrollToPosition,
+    scrollbar: options.scrollbar,
+    onChangeScrollbar,
+    onResetScrollbar
+  });
   return true;
 }
 function resolveContextMenuDensity(rowHeight) {
@@ -27310,7 +28499,9 @@ function createListTableChartData(params) {
     rowIndex,
     selectionRange,
     selectedRowRange,
-    selectedColumnRange
+    selectedColumnRange,
+    selectedColumnKeys,
+    getRowKey: getRowKey2
   } = params;
   const startRow = Math.max(
     selectionRange?.startRowIndex ?? selectedRowRange?.start ?? Math.max((rowIndex ?? 0) - 10, 0),
@@ -27323,7 +28514,7 @@ function createListTableChartData(params) {
   const selectedColumns = selectionRange ? columns.slice(
     Math.max(selectionRange.startColumnIndex, 0),
     selectionRange.endColumnIndex + 1
-  ) : selectedRowRange ? columns : selectedColumnRange ? columns.slice(
+  ) : selectedRowRange ? columns : selectedColumnKeys != null ? columns.filter((column) => selectedColumnKeys.includes(column.key)) : selectedColumnRange ? columns.slice(
     Math.max(selectedColumnRange.start, 0),
     selectedColumnRange.end + 1
   ) : columns.filter((column) => column.key === columnKey);
@@ -27362,7 +28553,8 @@ function createListTableChartData(params) {
   const labels = sampledRows.map(
     (_, index) => labelIndex >= 0 ? values[labelIndex]?.[index] || String(startRow + index + 1) : String(startRow + index + 1)
   );
-  return { labels, series: numericColumns };
+  const keys = getRowKey2 ? sampledRows.map((record, index) => getRowKey2(record, startRow + index)) : void 0;
+  return { labels, ...keys ? { keys } : {}, series: numericColumns };
 }
 function parseChartNumber(value) {
   const normalized = value.trim().replace(/[,，\s￥¥$]/g, "");
@@ -27375,6 +28567,9 @@ function parseChartNumber(value) {
 // src/features/tooltip/tooltip-feature.ts
 function getHeaderActionTooltipText(result, sortState) {
   const area = result.area;
+  if (result.debugNodeType === "header-edit-icon" || result.debugNodeType === "nested-table-header-edit-icon") {
+    return "\u5F53\u524D\u5217\u53EF\u7F16\u8F91";
+  }
   if (area !== "sort-trigger" && area !== "filter-trigger" && area !== "fixed-trigger") {
     return null;
   }
@@ -28419,6 +29614,8 @@ var ListTableEventController = class {
     __publicField(this, "cellSelectionAutoScrollVelocity", { x: 0, y: 0 });
     __publicField(this, "cellSelectionAutoScrollTargetVelocity", { x: 0, y: 0 });
     __publicField(this, "continuousScrollTimer", null);
+    __publicField(this, "scrollbarButtonFeedbackTimer", null);
+    __publicField(this, "scrollbarPartFeedbackTimer", null);
     __publicField(this, "pendingEditableCellRowSelectionTimer", null);
     __publicField(this, "outsideClickDocument", null);
     __publicField(this, "outsideClickStarted", null);
@@ -28429,7 +29626,13 @@ var ListTableEventController = class {
     __publicField(this, "handleDocumentClick", (event) => {
       const startedOutside = this.outsideClickStarted ?? !this.isEventTargetInsideTable(event.target);
       this.outsideClickStarted = null;
-      if (!startedOutside || !this.host.selection.textSelection) return;
+      if (!startedOutside) return;
+      if (this.host.options.clearSelectionOnClick?.outside) {
+        this.clearTableHighlight();
+        this.host.render();
+        return;
+      }
+      if (!this.host.selection.textSelection) return;
       this.host.clearBodySelection();
       this.host.render();
     });
@@ -28469,11 +29672,19 @@ var ListTableEventController = class {
         rowCount: this.host.getDisplayData().length,
         columnKeys: this.host.leafColumns.filter((column) => !isSystemColumnKey(column.key)).map((column) => column.key)
       };
-      const target = direction ? resolveAdjacentCellSelection({ ...navigationParams, direction }) : resolveTabCellSelection({
+      const target = direction ? resolveAdjacentCellSelection({
         ...navigationParams,
-        reverse: event.shiftKey
+        direction,
+        verticalWrap: this.host.options.keyboardNavigation?.verticalWrap
+      }) : resolveTabCellSelection({
+        ...navigationParams,
+        reverse: event.shiftKey,
+        tabWrap: this.host.options.keyboardNavigation?.tabWrap
       });
       if (!target) {
+        if (event.key === "Tab" && this.host.options.keyboardNavigation?.tabWrap === false) {
+          event.preventDefault();
+        }
         return;
       }
       event.preventDefault();
@@ -28585,6 +29796,9 @@ var ListTableEventController = class {
         result.area === "resize-handle" ? "col-resize" : result.cursor ?? ""
       );
       const nextHover = {
+        scrollbarRole: result.scrollbarRole,
+        pressedScrollbarButton: this.host.hover.pressedScrollbarButton,
+        pressedScrollbarPart: this.host.hover.pressedScrollbarPart,
         rowIndex: result.rowIndex ?? null,
         columnKey: result.columnKey ?? null,
         contentIndex: result.contentIndex,
@@ -28594,7 +29808,7 @@ var ListTableEventController = class {
         nestedColumnIndex: result.nestedColumnIndex,
         area: result.area
       };
-      const hoverChanged = this.host.hover.rowIndex !== nextHover.rowIndex || this.host.hover.columnKey !== nextHover.columnKey || this.host.hover.contentIndex !== nextHover.contentIndex || this.host.hover.nestedRowKey !== nextHover.nestedRowKey || this.host.hover.nestedRowIndex !== nextHover.nestedRowIndex || this.host.hover.nestedColumnDataIndex !== nextHover.nestedColumnDataIndex || this.host.hover.nestedColumnIndex !== nextHover.nestedColumnIndex || this.host.hover.area !== nextHover.area;
+      const hoverChanged = this.host.hover.rowIndex !== nextHover.rowIndex || this.host.hover.columnKey !== nextHover.columnKey || this.host.hover.contentIndex !== nextHover.contentIndex || this.host.hover.nestedRowKey !== nextHover.nestedRowKey || this.host.hover.nestedRowIndex !== nextHover.nestedRowIndex || this.host.hover.nestedColumnDataIndex !== nextHover.nestedColumnDataIndex || this.host.hover.nestedColumnIndex !== nextHover.nestedColumnIndex || this.host.hover.area !== nextHover.area || this.host.hover.scrollbarRole !== nextHover.scrollbarRole || this.host.hover.pressedScrollbarButton !== nextHover.pressedScrollbarButton || this.host.hover.pressedScrollbarPart !== nextHover.pressedScrollbarPart;
       const hitChanged = didHitResultChange(
         this.host.debugManager.getSnapshot()?.hitTest,
         result
@@ -28637,7 +29851,8 @@ var ListTableEventController = class {
         zoom: this.host.tableZoom
       });
       const result = this.host.resolvePointerHit(position.x, position.y);
-      if (this.startTextSelection(result, position.x, position.y)) {
+      const modifyingSelection = event.shiftKey || event.ctrlKey || event.metaKey;
+      if (!modifyingSelection && this.startTextSelection(result, position.x, position.y)) {
         return;
       }
       if (this.host.selection.textSelection) {
@@ -28669,6 +29884,28 @@ var ListTableEventController = class {
       if ((result.area === "body" || result.area === "body-content") && result.columnKey === ROW_SELECTOR_COLUMN_KEY && typeof result.rowIndex === "number") {
         event.preventDefault();
         this.clearNestedTableHighlight();
+        if (modifyingSelection) {
+          const mode = event.ctrlKey || event.metaKey ? isRowInHighlight(this.host.rangeHighlight, result.rowIndex) ? "remove" : "add" : "extend";
+          this.cellSelectionDrag = {
+            kind: "row",
+            startRowIndex: mode === "extend" ? this.host.rangeHighlight.selectedRowAnchorIndex ?? result.rowIndex : result.rowIndex,
+            startColumnIndex: -1,
+            pointerStartRowIndex: result.rowIndex,
+            pointerStartColumnIndex: -1,
+            mode,
+            baseRangeHighlight: this.host.rangeHighlight
+          };
+          this.cellSelectionDragged = false;
+          this.cellSelectionPointer = {
+            clientX: event.clientX,
+            clientY: event.clientY
+          };
+          this.host.canvasHost.bindWindowDragEvents(
+            this.handleWindowMouseMove,
+            this.handleWindowMouseUp
+          );
+          return;
+        }
         this.host.selection = {
           rowIndex: result.rowIndex,
           columnKey: ROW_SELECTOR_COLUMN_KEY
@@ -28679,7 +29916,11 @@ var ListTableEventController = class {
         this.cellSelectionDrag = {
           kind: "row",
           startRowIndex: result.rowIndex,
-          startColumnIndex: -1
+          startColumnIndex: -1,
+          pointerStartRowIndex: result.rowIndex,
+          pointerStartColumnIndex: -1,
+          mode: "replace",
+          baseRangeHighlight: this.host.rangeHighlight
         };
         this.cellSelectionDragged = false;
         this.cellSelectionPointer = {
@@ -28693,20 +29934,41 @@ var ListTableEventController = class {
         this.host.render(result);
         return;
       }
-      if (!this.host.options.rowDrag?.enabled && (result.area === "body" || result.area === "body-content") && typeof result.rowIndex === "number" && result.columnKey) {
+      if ((!this.host.options.rowDrag?.enabled || modifyingSelection) && (result.area === "body" || result.area === "body-content") && typeof result.rowIndex === "number" && result.columnKey) {
         const columnIndex = this.host.leafColumns.findIndex(
           (column) => column.key === result.columnKey
         );
         if (columnIndex >= 0) {
           const nestedSelectionCleared = this.clearNestedTableHighlight();
-          this.host.rangeHighlight = {
-            ...this.host.rangeHighlight,
-            selectedCellRange: null
-          };
+          if (!modifyingSelection) {
+            this.host.rangeHighlight = {
+              ...this.host.rangeHighlight,
+              selectedCellRange: null,
+              selectedCellRanges: null
+            };
+          }
+          const ctrlSelection = event.ctrlKey || event.metaKey;
+          const mode = ctrlSelection ? isCellInHighlight(
+            this.host.rangeHighlight,
+            result.rowIndex,
+            columnIndex
+          ) ? "remove" : "add" : event.shiftKey ? "extend" : "replace";
+          const cellAnchor = this.host.rangeHighlight.selectedCellAnchor;
+          const anchorColumnIndex = cellAnchor ? this.host.leafColumns.findIndex(
+            (column) => column.key === cellAnchor.columnKey
+          ) : -1;
+          const previousColumnIndex = this.host.leafColumns.findIndex(
+            (column) => column.key === this.host.selection.columnKey
+          );
           this.cellSelectionDrag = {
             kind: "cell",
-            startRowIndex: result.rowIndex,
-            startColumnIndex: columnIndex
+            startRowIndex: mode === "extend" ? cellAnchor?.rowIndex ?? this.host.selection.rowIndex ?? result.rowIndex : result.rowIndex,
+            startColumnIndex: mode === "extend" ? anchorColumnIndex >= 0 ? anchorColumnIndex : previousColumnIndex >= 0 ? previousColumnIndex : columnIndex : columnIndex,
+            pointerStartRowIndex: result.rowIndex,
+            pointerStartColumnIndex: columnIndex,
+            mode,
+            baseRangeHighlight: this.host.rangeHighlight,
+            preserveRowSelection: this.host.selection.columnKey === ROW_SELECTOR_COLUMN_KEY || this.host.rangeHighlight.selectedRowRanges != null
           };
           this.cellSelectionDragged = false;
           this.cellSelectionPointer = {
@@ -28720,6 +29982,7 @@ var ListTableEventController = class {
           if (nestedSelectionCleared) {
             this.host.render(result);
           }
+          if (modifyingSelection) return;
         }
       }
       if (result.area === "resize-handle" && result.columnKey) {
@@ -28810,11 +30073,39 @@ var ListTableEventController = class {
         result.scrollbarRole === "thumb" ? "grabbing" : "pointer"
       );
       if (result.scrollbarRole === "decrease-button") {
+        if (this.scrollbarButtonFeedbackTimer != null) {
+          window.clearTimeout(this.scrollbarButtonFeedbackTimer);
+          this.scrollbarButtonFeedbackTimer = null;
+        }
+        this.host.hover = {
+          ...this.host.hover,
+          area: result.area,
+          scrollbarRole: result.scrollbarRole,
+          pressedScrollbarButton: {
+            axis: result.area === "horizontal-scrollbar" ? "horizontal" : "vertical",
+            role: result.scrollbarRole
+          }
+        };
+        this.host.scheduleRender();
         this.stepScrollbar(result.area, -1, viewport);
         this.startContinuousScroll(result.area, -1, viewport);
         return;
       }
       if (result.scrollbarRole === "increase-button") {
+        if (this.scrollbarButtonFeedbackTimer != null) {
+          window.clearTimeout(this.scrollbarButtonFeedbackTimer);
+          this.scrollbarButtonFeedbackTimer = null;
+        }
+        this.host.hover = {
+          ...this.host.hover,
+          area: result.area,
+          scrollbarRole: result.scrollbarRole,
+          pressedScrollbarButton: {
+            axis: result.area === "horizontal-scrollbar" ? "horizontal" : "vertical",
+            role: result.scrollbarRole
+          }
+        };
+        this.host.scheduleRender();
         this.stepScrollbar(result.area, 1, viewport);
         this.startContinuousScroll(result.area, 1, viewport);
         return;
@@ -28826,9 +30117,15 @@ var ListTableEventController = class {
         }
         const { thumb, track } = horizontalScrollbar;
         if (result.scrollbarRole === "track") {
+          this.flashScrollbarPart("horizontal", "track");
           this.jumpScrollbar("horizontal", position.x, track, thumb, viewport);
           return;
         }
+        this.host.hover = {
+          ...this.host.hover,
+          pressedScrollbarPart: { axis: "horizontal", role: "thumb" }
+        };
+        this.host.scheduleRender();
         this.host.draggingScrollbar = {
           axis: "horizontal",
           pointerOffset: position.x - thumb.x,
@@ -28844,9 +30141,15 @@ var ListTableEventController = class {
         }
         const { thumb, track } = verticalScrollbar;
         if (result.scrollbarRole === "track") {
+          this.flashScrollbarPart("vertical", "track");
           this.jumpScrollbar("vertical", position.y, track, thumb, viewport);
           return;
         }
+        this.host.hover = {
+          ...this.host.hover,
+          pressedScrollbarPart: { axis: "vertical", role: "thumb" }
+        };
+        this.host.scheduleRender();
         this.host.draggingScrollbar = {
           axis: "vertical",
           pointerOffset: position.y - thumb.y,
@@ -28959,15 +30262,47 @@ var ListTableEventController = class {
         getRows: () => this.host.getDisplayData(),
         getAllRows: () => this.host.options.dataSource,
         getExportSummaryEnabled: () => Boolean(this.host.currentRenderSnapshot?.hasSummary),
+        getExportSortState: () => this.host.getSortState(),
+        getExportColumns: () => getListTableExportCandidateColumns(this.host.options.columns),
         onCopyImage: (scope) => this.copyImage(scope, event),
+        scrollbarColumnCount: this.host.leafColumns.filter(
+          (column) => !isSystemColumnKey(column.key)
+        ).length,
+        onScrollToPosition: (row, column) => {
+          const columns = this.host.leafColumns.filter(
+            (item) => !isSystemColumnKey(item.key)
+          );
+          const targetColumn = column == null ? null : columns[column - 1];
+          const colIndex = targetColumn ? this.host.leafColumns.findIndex(
+            (item) => item.key === targetColumn.key
+          ) : void 0;
+          this.host.scrollTo({
+            rowIndex: row == null ? void 0 : row - 1,
+            colIndex,
+            behavior: "smooth"
+          });
+        },
+        onChangeScrollbar: (value) => {
+          this.host.options.scrollbar = value;
+          this.host.options.ui?.onScrollbarChange?.(value);
+          this.host.persistColumnConfig();
+          this.host.render();
+        },
+        onResetScrollbar: () => {
+          this.host.options.scrollbar = void 0;
+          this.host.persistColumnConfig();
+          this.host.render();
+        },
         onCreateChart: () => createListTableChartData({
           rows: this.host.getDisplayData(),
           columns: this.host.leafColumns,
           columnKey: contextResult.columnKey ?? "",
-          rowIndex: typeof contextResult.rowIndex === "number" ? contextResult.rowIndex : null,
+          rowIndex: this.host.selection.rowIndex ?? (typeof contextResult.rowIndex === "number" ? contextResult.rowIndex : null),
           selectionRange: this.host.rangeHighlight.selectedCellRange,
           selectedRowRange: this.host.rangeHighlight.selectedRowRange,
-          selectedColumnRange: this.host.rangeHighlight.selectedColumnRange
+          selectedColumnRange: this.host.rangeHighlight.selectedColumnRange,
+          selectedColumnKeys: this.host.rangeHighlight.selectedColumnKeys,
+          getRowKey: this.host.options.rowKey != null ? (record, index) => getRowKey(this.host.options, record, index) : void 0
         }),
         onExportImage: (scope) => this.copyImage(scope, event, true),
         canCopySelectionImage: resolveImageSelection(this.host) != null,
@@ -28991,8 +30326,8 @@ var ListTableEventController = class {
         getColumns: () => this.host.leafColumns,
         getHeaderTree: () => this.host.headerTree,
         getFrozenRowPosition: (rowIndex) => this.host.getFrozenRowPosition(rowIndex),
-        startExportTask: (task, text, defaultFileName) => {
-          this.host.startExportTask(task, text, defaultFileName);
+        startExportTask: (task, text, defaultFileName, dialog) => {
+          this.host.startExportTask(task, text, defaultFileName, dialog);
         },
         contentDownload: this.host.resolveContentDownloadAction(hitContent),
         onSelectHeader: (columnKey, rect) => {
@@ -29001,18 +30336,22 @@ var ListTableEventController = class {
           this.host.selectHeader(columnKey, rect);
         },
         onSelectBodyRow: (rowIndex, columnKey) => {
-          const selectedCellRange = this.host.rangeHighlight.selectedCellRange;
           const columnIndex = this.host.leafColumns.findIndex(
             (column) => column.key === columnKey
           );
+          const isSelectedCell = columnIndex >= 0 && isCellInHighlight(this.host.rangeHighlight, rowIndex, columnIndex);
           this.host.selection = {
             rowIndex,
             columnKey
           };
           this.host.clearSelectedHeader();
-          if (!selectedCellRange || rowIndex < selectedCellRange.startRowIndex || rowIndex > selectedCellRange.endRowIndex || columnIndex < selectedCellRange.startColumnIndex || columnIndex > selectedCellRange.endColumnIndex) {
+          if (!isSelectedCell && !isRowInHighlight(this.host.rangeHighlight, rowIndex)) {
             this.host.rangeHighlight = resolveNextRowHighlightForContextMenu({
-              current: this.host.rangeHighlight,
+              current: {
+                ...this.host.rangeHighlight,
+                selectedCellRange: null,
+                selectedCellRanges: null
+              },
               rowIndex
             });
           }
@@ -29308,6 +30647,14 @@ var ListTableEventController = class {
       const result = event.shiftKey && rawResult.area === "column-collapse-trigger" ? this.host.resolvePointerHit(position.x, position.y, {
         excludeKinds: ["column-collapse-trigger"]
       }) : rawResult;
+      const toggleColumn = event.ctrlKey || event.metaKey;
+      const preserveAnimatedSortSelection = result.area === "sort-trigger" && this.host.leafColumns.some(
+        (column) => column.key === result.columnKey && typeof column.sorter === "object" && column.sorter.animation === true
+      );
+      const previousCell = {
+        rowIndex: this.host.selection.rowIndex,
+        columnKey: this.host.selection.columnKey
+      };
       if (result.area === "grouping-remove" && result.columnKey) {
         this.host.removeGroupingColumn?.(result.columnKey);
         this.host.suppressNextClick = true;
@@ -29330,6 +30677,11 @@ var ListTableEventController = class {
         this.host.suppressNextClick = false;
         return;
       }
+      if (result.area === "empty" && this.host.options.clearSelectionOnClick?.blankCanvas) {
+        this.clearTableHighlight();
+        this.host.render(result);
+        return;
+      }
       const isNestedTableHit = result.contentKey === "nested-table";
       if (isNestedTableHit) {
         this.clearParentTableHighlight();
@@ -29361,6 +30713,7 @@ var ListTableEventController = class {
           selectedRowRange: rowCount > 0 ? { start: 0, end: rowCount - 1 } : null,
           selectedColumnAnchorKey: this.host.leafColumns[0]?.key ?? null,
           selectedColumnRange: columnRangeEnd >= 0 ? { start: 0, end: columnRangeEnd } : null,
+          selectedColumnKeys: null,
           selectedCellRange: rowCount > 0 && columnCount > 0 ? {
             startRowIndex: 0,
             endRowIndex: rowCount - 1,
@@ -29385,6 +30738,7 @@ var ListTableEventController = class {
           selectedRowRange: rowCount > 0 ? { start: 0, end: rowCount - 1 } : null,
           selectedColumnAnchorKey: this.host.leafColumns[0]?.key ?? null,
           selectedColumnRange: columnCount > 0 ? { start: 0, end: columnCount - 1 } : null,
+          selectedColumnKeys: null,
           selectedCellRange: rowCount > 0 && columnCount > 0 ? {
             startRowIndex: 0,
             endRowIndex: rowCount - 1,
@@ -29405,7 +30759,48 @@ var ListTableEventController = class {
       if ((result.area === "body" || result.area === "body-content") && result.columnKey === ROW_SELECTOR_COLUMN_KEY && typeof result.rowIndex === "number") {
         this.host.clearSelectedHeader();
         this.host.summarySelected = false;
-        this.selectRowRange(result.rowIndex, result.rowIndex);
+        this.host.rangeHighlight = resolveRowHighlightForSelectorClick({
+          current: this.host.rangeHighlight,
+          rowIndex: result.rowIndex,
+          shiftKey: event.shiftKey,
+          ctrlKey: toggleColumn
+        });
+        if (!isRowInHighlight(this.host.rangeHighlight, result.rowIndex)) {
+          const hasSelectedRows = this.host.rangeHighlight.selectedRowRanges?.length || this.host.rangeHighlight.selectedRowRange;
+          this.host.selection = {
+            rowIndex: null,
+            columnKey: hasSelectedRows ? ROW_SELECTOR_COLUMN_KEY : null
+          };
+        }
+        this.host.render(result);
+        this.host.updateTooltip(result);
+        return;
+      }
+      if ((event.shiftKey || toggleColumn) && (result.area === "body" || result.area === "body-content") && typeof result.rowIndex === "number" && result.columnKey && !isSystemColumnKey(result.columnKey)) {
+        const columnIndex = this.host.leafColumns.findIndex(
+          (column) => column.key === result.columnKey
+        );
+        this.host.clearSelectedHeader();
+        this.host.rangeHighlight = resolveCellHighlightForClick({
+          current: this.host.rangeHighlight,
+          rowIndex: result.rowIndex,
+          columnKey: result.columnKey,
+          leafColumnKeys: this.host.leafColumns.map((column) => column.key),
+          previousCell: previousCell.rowIndex != null && previousCell.columnKey ? {
+            rowIndex: previousCell.rowIndex,
+            columnKey: previousCell.columnKey
+          } : null,
+          preserveRowSelection: previousCell.columnKey === ROW_SELECTOR_COLUMN_KEY || this.host.rangeHighlight.selectedRowRanges != null,
+          shiftKey: event.shiftKey,
+          ctrlKey: toggleColumn
+        });
+        if (columnIndex >= 0 && !isCellInHighlight(
+          this.host.rangeHighlight,
+          result.rowIndex,
+          columnIndex
+        )) {
+          this.host.selection = { rowIndex: null, columnKey: null };
+        }
         this.host.render(result);
         this.host.updateTooltip(result);
         return;
@@ -29417,13 +30812,20 @@ var ListTableEventController = class {
         }
       }
       this.host.summarySelected = result.area === "summary";
-      if ((result.area === "header" || result.area === "header-selection" || result.area === "sort-trigger" || result.area === "filter-trigger" || result.area === "fixed-trigger" || event.shiftKey && result.area === "column-collapse-trigger") && result.columnKey) {
+      if ((result.area === "header" || result.area === "header-selection" || result.area === "sort-trigger" && !preserveAnimatedSortSelection || result.area === "filter-trigger" || result.area === "fixed-trigger" || event.shiftKey && result.area === "column-collapse-trigger") && result.columnKey) {
         this.host.clearBodySelection();
-        this.host.resetRangeHighlightForHeaderSelection(event.shiftKey);
-        this.host.selectHeader(
-          result.columnKey,
-          result.area === "header" ? result.rect : null
+        this.host.resetRangeHighlightForHeaderSelection(
+          event.shiftKey,
+          toggleColumn
         );
+        if (toggleColumn) {
+          this.host.clearSelectedHeader();
+        } else {
+          this.host.selectHeader(
+            result.columnKey,
+            result.area === "header" ? result.rect : null
+          );
+        }
       }
       if (result.area === "summary") {
         if (!result.columnKey) {
@@ -29441,7 +30843,7 @@ var ListTableEventController = class {
         this.host.updateTooltip(result);
         return;
       }
-      const isHeaderRangeGesture = event.shiftKey && result.columnKey && (result.area === "header" || result.area === "sort-trigger" || result.area === "filter-trigger" || result.area === "fixed-trigger" || result.area === "column-collapse-trigger");
+      const isHeaderRangeGesture = (event.shiftKey || toggleColumn) && result.columnKey && (result.area === "header" || result.area === "sort-trigger" && !preserveAnimatedSortSelection || result.area === "filter-trigger" || result.area === "fixed-trigger" || result.area === "column-collapse-trigger");
       if ((result.area === "body" || result.area === "body-content") && typeof result.rowIndex === "number" && result.columnKey) {
         this.host.clearSelectedHeader();
         this.host.updateRangeHighlightForBodyInteraction({
@@ -29450,15 +30852,26 @@ var ListTableEventController = class {
           shiftKey: event.shiftKey,
           rowSpan: result.rowSpan
         });
+        if (!isSystemColumnKey(result.columnKey)) {
+          this.host.rangeHighlight = resolveCellHighlightForClick({
+            current: this.host.rangeHighlight,
+            rowIndex: result.rowIndex,
+            columnKey: result.columnKey,
+            leafColumnKeys: this.host.leafColumns.map((column) => column.key),
+            shiftKey: false,
+            ctrlKey: false
+          });
+        }
       }
-      if ((result.area === "header" || result.area === "sort-trigger" || result.area === "filter-trigger" || result.area === "fixed-trigger" || isHeaderRangeGesture) && result.columnKey) {
+      if ((result.area === "header" || result.area === "sort-trigger" && !preserveAnimatedSortSelection || result.area === "filter-trigger" || result.area === "fixed-trigger" || isHeaderRangeGesture) && result.columnKey) {
         this.host.rangeHighlight = {
           ...this.host.rangeHighlight,
           selectedCellRange: null
         };
         this.host.updateRangeHighlightForHeaderClick(
           result.columnKey,
-          event.shiftKey
+          event.shiftKey,
+          toggleColumn
         );
       }
       if (isHeaderRangeGesture) {
@@ -29794,12 +31207,24 @@ var ListTableEventController = class {
         } else if (!activated && this.host.draggingReorder.columnKey) {
           const columnKey = this.host.draggingReorder.columnKey;
           this.host.clearBodySelection();
-          this.host.resetRangeHighlightForHeaderSelection(event.shiftKey);
-          this.host.selectHeader(
+          const toggleColumn = event.ctrlKey || event.metaKey;
+          this.host.resetRangeHighlightForHeaderSelection(
+            event.shiftKey,
+            toggleColumn
+          );
+          if (toggleColumn) {
+            this.host.clearSelectedHeader();
+          } else {
+            this.host.selectHeader(
+              columnKey,
+              this.host.draggingReorder.selectedHeaderRect
+            );
+          }
+          this.host.updateRangeHighlightForHeaderClick(
             columnKey,
-            this.host.draggingReorder.selectedHeaderRect
+            event.shiftKey,
+            toggleColumn
           );
-          this.host.updateRangeHighlightForHeaderClick(columnKey, event.shiftKey);
           this.host.suppressNextClick = true;
           this.host.render();
         }
@@ -30026,6 +31451,14 @@ var ListTableEventController = class {
     this.host.render();
   }
   destroy() {
+    if (this.scrollbarButtonFeedbackTimer != null) {
+      window.clearTimeout(this.scrollbarButtonFeedbackTimer);
+      this.scrollbarButtonFeedbackTimer = null;
+    }
+    if (this.scrollbarPartFeedbackTimer != null) {
+      window.clearTimeout(this.scrollbarPartFeedbackTimer);
+      this.scrollbarPartFeedbackTimer = null;
+    }
     this.cancelPendingEditableCellRowSelection();
     this.stopContinuousScroll();
     this.stopTextSelectionAutoScroll();
@@ -30155,10 +31588,11 @@ var ListTableEventController = class {
       getRows: () => resolveNestedTableDisplayRows(content, getNestedState()),
       getAllRows: () => content.dataSource,
       getExportSummaryEnabled: () => getNestedState()?.summaryVisible === true,
+      getExportSortState: () => getNestedState()?.sortState ?? [],
       getColumns: () => columns,
       getHeaderTree: () => headerTree,
       hideMenu,
-      startExportTask: (task, text, defaultFileName) => this.host.startExportTask(task, text, defaultFileName),
+      startExportTask: (task, text, defaultFileName, dialog) => this.host.startExportTask(task, text, defaultFileName, dialog),
       onFreezeRow: () => {
       },
       onUnfreezeRow: () => {
@@ -30629,6 +32063,11 @@ var ListTableEventController = class {
       searchMatch: this.host.rangeHighlight.searchMatch
     };
   }
+  /** 清除可视选区，但保留查找结果与业务行选择数据。 */
+  clearTableHighlight() {
+    this.clearParentTableHighlight();
+    this.clearNestedTableHighlight();
+  }
   /** 父表格进入选区交互时清理全部子表格选区。 */
   clearNestedTableHighlight() {
     this.activeNestedTableHit = null;
@@ -30636,9 +32075,31 @@ var ListTableEventController = class {
   }
   startContinuousScroll(area, direction, viewport) {
     this.stopContinuousScroll();
+    const axis = area === "horizontal-scrollbar" ? "horizontal" : "vertical";
+    const style = utils.resolveCanvasScrollbarAxis(this.host.options.scrollbar, axis);
+    const startedAt = Date.now();
+    let previousAt = startedAt;
     this.continuousScrollTimer = window.setInterval(() => {
-      this.stepScrollbar(area, direction, viewport);
-    }, 80);
+      const now2 = Date.now();
+      const elapsed = Math.max(now2 - previousAt, 0);
+      previousAt = now2;
+      const distance = utils.resolveCanvasScrollbarHoldSpeed(
+        now2 - startedAt,
+        style.maxScrollSpeed
+      ) * elapsed * direction / 1e3;
+      const base = this.host.animationController.getWheelScrollTarget() ?? this.host.scroll;
+      const next = {
+        ...base,
+        left: axis === "horizontal" ? Math.min(
+          Math.max(base.left + distance, 0),
+          viewport.maxScrollLeft
+        ) : base.left,
+        top: axis === "vertical" ? Math.min(Math.max(base.top + distance, 0), viewport.maxScrollTop) : base.top
+      };
+      if (next.left !== base.left || next.top !== base.top) {
+        this.host.animationController.startWheelScrollSmoothing(next);
+      }
+    }, 32);
     this.host.canvasHost.bindWindowDragEvents(
       this.handleWindowMouseMove,
       this.handleWindowMouseUp
@@ -30651,22 +32112,19 @@ var ListTableEventController = class {
     }
   }
   stepScrollbar(area, direction, viewport) {
+    const base = this.host.animationController.getWheelScrollTarget() ?? this.host.scroll;
     const nextScroll = stepScrollbarScroll({
-      current: this.host.scroll,
+      current: base,
       area,
       direction,
       viewport,
       rowHeight: this.host.currentRenderSnapshot?.rowHeight ?? DEFAULT_ROW_HEIGHT,
       horizontalStep: HORIZONTAL_SCROLL_STEP
     });
-    if (!this.host.applyUserScroll(nextScroll)) {
+    if (nextScroll.left === base.left && nextScroll.top === base.top) {
       return;
     }
-    this.host.markScrollbarActive();
-    this.host.scheduleRender();
-    if (area === "vertical-scrollbar") {
-      this.host.maybeLoadNextScrollPage();
-    }
+    this.host.animationController.startWheelScrollSmoothing(nextScroll);
   }
   jumpScrollbar(axis, pointerValue, track, thumb, viewport) {
     const nextScroll = jumpScrollbarScroll({
@@ -30687,6 +32145,22 @@ var ListTableEventController = class {
     }
   }
   finishWindowDragCleanup(options) {
+    if (this.host.hover.pressedScrollbarButton) {
+      this.scrollbarButtonFeedbackTimer = window.setTimeout(() => {
+        this.scrollbarButtonFeedbackTimer = null;
+        this.host.hover = {
+          ...this.host.hover,
+          pressedScrollbarButton: void 0
+        };
+        this.host.scheduleRender();
+      }, 140);
+    }
+    if (this.host.hover.pressedScrollbarPart?.role === "thumb") {
+      this.host.hover = {
+        ...this.host.hover,
+        pressedScrollbarPart: void 0
+      };
+    }
     this.host.draggingScrollbar = null;
     this.host.draggingResize = null;
     this.host.draggingReorder = null;
@@ -30700,6 +32174,24 @@ var ListTableEventController = class {
     this.host.markScrollbarActive();
     this.host.render();
   }
+  flashScrollbarPart(axis, role) {
+    if (this.scrollbarPartFeedbackTimer != null) {
+      window.clearTimeout(this.scrollbarPartFeedbackTimer);
+    }
+    this.host.hover = {
+      ...this.host.hover,
+      pressedScrollbarPart: { axis, role }
+    };
+    this.host.scheduleRender();
+    this.scrollbarPartFeedbackTimer = window.setTimeout(() => {
+      this.scrollbarPartFeedbackTimer = null;
+      this.host.hover = {
+        ...this.host.hover,
+        pressedScrollbarPart: void 0
+      };
+      this.host.scheduleRender();
+    }, 140);
+  }
   startTextSelection(result, pointerX, pointerY) {
     if (result.area !== "body-content" && result.area !== "header" && result.area !== "summary" || !result.columnKey || !result.textSelectionText || !result.textSelectionFont || !result.textSelectionFragmentKey || !result.rect) {
       return false;
@@ -31047,16 +32539,46 @@ var ListTableEventController = class {
       return false;
     }
     if (drag.kind === "row") {
+      if (drag.mode !== "replace" && !this.cellSelectionDragged && result.rowIndex === drag.pointerStartRowIndex || drag.lastRowIndex === result.rowIndex) {
+        return false;
+      }
       const nextRange2 = {
         start: Math.min(drag.startRowIndex, result.rowIndex),
         end: Math.max(drag.startRowIndex, result.rowIndex)
       };
       const currentRange2 = this.host.rangeHighlight.selectedRowRange;
-      if (currentRange2?.start === nextRange2.start && currentRange2.end === nextRange2.end) {
+      if (drag.mode === "replace" && currentRange2?.start === nextRange2.start && currentRange2.end === nextRange2.end) {
         return false;
       }
-      this.cellSelectionDragged = this.cellSelectionDragged || result.rowIndex !== drag.startRowIndex;
-      this.selectRowRange(drag.startRowIndex, result.rowIndex);
+      this.cellSelectionDragged = this.cellSelectionDragged || result.rowIndex !== drag.pointerStartRowIndex;
+      drag.lastRowIndex = result.rowIndex;
+      if (drag.mode === "replace") {
+        this.selectRowRange(drag.startRowIndex, result.rowIndex);
+      } else if (drag.mode === "extend") {
+        this.host.rangeHighlight = resolveRowHighlightForSelectorClick({
+          current: {
+            ...drag.baseRangeHighlight,
+            selectedRowAnchorIndex: drag.startRowIndex
+          },
+          rowIndex: result.rowIndex,
+          shiftKey: true,
+          ctrlKey: false
+        });
+      } else {
+        this.host.rangeHighlight = resolveRowHighlightForDrag({
+          current: drag.baseRangeHighlight,
+          startRowIndex: drag.startRowIndex,
+          endRowIndex: result.rowIndex,
+          remove: drag.mode === "remove"
+        });
+      }
+      if (drag.mode !== "replace") {
+        this.host.clearSelectedHeader();
+        this.host.selection = {
+          rowIndex: drag.mode === "remove" ? null : result.rowIndex,
+          columnKey: ROW_SELECTOR_COLUMN_KEY
+        };
+      }
       if (options?.scheduleRender !== false) {
         this.host.scheduleRender(result);
       }
@@ -31068,7 +32590,7 @@ var ListTableEventController = class {
     if (columnIndex < 0) {
       return false;
     }
-    if (result.rowIndex === drag.startRowIndex && columnIndex === drag.startColumnIndex) {
+    if (!this.cellSelectionDragged && result.rowIndex === drag.pointerStartRowIndex && columnIndex === drag.pointerStartColumnIndex || drag.lastRowIndex === result.rowIndex && drag.lastColumnIndex === columnIndex) {
       return false;
     }
     const nextRange = {
@@ -31078,14 +32600,53 @@ var ListTableEventController = class {
       endColumnIndex: Math.max(drag.startColumnIndex, columnIndex)
     };
     const currentRange = this.host.rangeHighlight.selectedCellRange;
-    if (currentRange?.startRowIndex === nextRange.startRowIndex && currentRange.endRowIndex === nextRange.endRowIndex && currentRange.startColumnIndex === nextRange.startColumnIndex && currentRange.endColumnIndex === nextRange.endColumnIndex) {
+    if (drag.mode === "replace" && currentRange?.startRowIndex === nextRange.startRowIndex && currentRange.endRowIndex === nextRange.endRowIndex && currentRange.startColumnIndex === nextRange.startColumnIndex && currentRange.endColumnIndex === nextRange.endColumnIndex) {
       return false;
     }
     this.cellSelectionDragged = true;
-    this.host.rangeHighlight = {
-      ...this.host.rangeHighlight,
-      selectedCellRange: nextRange
-    };
+    drag.lastRowIndex = result.rowIndex;
+    drag.lastColumnIndex = columnIndex;
+    if (drag.mode === "replace") {
+      this.host.rangeHighlight = {
+        ...this.host.rangeHighlight,
+        selectedCellRange: nextRange,
+        selectedCellRanges: null,
+        selectedCellAnchor: {
+          rowIndex: drag.startRowIndex,
+          columnKey: this.host.leafColumns[drag.startColumnIndex]?.key ?? result.columnKey
+        }
+      };
+    } else if (drag.mode === "extend") {
+      this.host.rangeHighlight = resolveCellHighlightForClick({
+        current: {
+          ...drag.baseRangeHighlight,
+          selectedCellAnchor: {
+            rowIndex: drag.startRowIndex,
+            columnKey: this.host.leafColumns[drag.startColumnIndex]?.key ?? result.columnKey
+          }
+        },
+        rowIndex: result.rowIndex,
+        columnKey: result.columnKey,
+        leafColumnKeys: this.host.leafColumns.map((column) => column.key),
+        shiftKey: true,
+        ctrlKey: false
+      });
+    } else {
+      this.host.rangeHighlight = resolveCellHighlightForDrag({
+        current: drag.baseRangeHighlight,
+        startRowIndex: drag.startRowIndex,
+        endRowIndex: result.rowIndex,
+        startColumnIndex: drag.startColumnIndex,
+        endColumnIndex: columnIndex,
+        columnKey: this.host.leafColumns[drag.startColumnIndex]?.key ?? result.columnKey,
+        remove: drag.mode === "remove",
+        preserveRowSelection: drag.preserveRowSelection === true
+      });
+    }
+    if (drag.mode !== "replace") {
+      this.host.clearSelectedHeader();
+      this.host.selection = drag.mode === "remove" ? { rowIndex: null, columnKey: null } : { rowIndex: result.rowIndex, columnKey: result.columnKey };
+    }
     if (options?.scheduleRender !== false) {
       this.host.scheduleRender(result);
     }
@@ -31169,9 +32730,13 @@ var ListTableEventController = class {
         start: Math.min(startRowIndex, endRowIndex),
         end: Math.max(startRowIndex, endRowIndex)
       },
+      selectedRowRanges: null,
       selectedColumnAnchorKey: null,
       selectedColumnRange: null,
-      selectedCellRange: null
+      selectedColumnKeys: null,
+      selectedCellRange: null,
+      selectedCellRanges: null,
+      selectedCellAnchor: null
     };
   }
 };
@@ -31490,6 +33055,7 @@ function createListTableEventHost(core) {
     // 可见行在百万行窗口化后只包含当前视口；事件层需要完整的查询结果，
     // 否则自动列宽等基于全局 dataRowIndex 的逻辑会在深滚动时丢失采样行。
     getDisplayData: () => core.queryController.getDisplayData(),
+    getSortState: () => core.storeFacade.sortState,
     getSummaryValueMap: () => core.summaryController.getSummaryValueMap(),
     getSummaryValuesAsync: (snapshot) => core.summaryController.getSummaryValuesAsync(snapshot),
     scrollTo: (options) => core.scrollTo(options),
@@ -31507,11 +33073,12 @@ function createListTableEventHost(core) {
     clearBodySelection: () => core.selectionController.clearBodySelection(),
     clearSelectedHeader: () => core.selectionController.clearSelectedHeader(),
     selectHeader: (columnKey, rect) => core.selectionController.selectHeader(columnKey, rect),
-    resetRangeHighlightForHeaderSelection: (shiftKey) => core.selectionController.resetRangeHighlightForHeaderSelection(shiftKey),
+    resetRangeHighlightForHeaderSelection: (shiftKey, ctrlKey) => core.selectionController.resetRangeHighlightForHeaderSelection(shiftKey, ctrlKey),
     updateRangeHighlightForBodyInteraction: (params) => core.selectionController.updateRangeHighlightForBodyInteraction(params),
-    updateRangeHighlightForHeaderClick: (columnKey, shiftKey) => core.selectionController.updateRangeHighlightForHeaderClick(
+    updateRangeHighlightForHeaderClick: (columnKey, shiftKey, ctrlKey) => core.selectionController.updateRangeHighlightForHeaderClick(
       columnKey,
-      shiftKey
+      shiftKey,
+      ctrlKey
     ),
     updateRangeHighlightForHeaderContextMenu: (columnKey) => core.selectionController.updateRangeHighlightForHeaderContextMenu(
       columnKey
@@ -31554,7 +33121,7 @@ function createListTableEventHost(core) {
       return snapshot?.columnSegments ?? core.columnSegments;
     },
     persistColumnConfig: () => core.persistenceController.persistColumnConfig(),
-    startExportTask: (task, text, defaultFileName) => {
+    startExportTask: (task, text, defaultFileName, dialog) => {
       const configured = core.options.exportOptions?.fileName?.trim();
       const extension = defaultFileName?.match(/\.(xlsx|csv|txt|json)$/i)?.[0];
       const fileName = configured && extension ? configured.replace(/\.(xlsx|csv|txt|json)$/i, "") + extension : defaultFileName;
@@ -31562,7 +33129,9 @@ function createListTableEventHost(core) {
         task,
         text,
         void 0,
-        fileName
+        fileName,
+        void 0,
+        dialog
       );
     },
     resolveContentDownloadAction: (content) => core.contentActionController.resolveContentDownloadAction(
@@ -31657,6 +33226,7 @@ var ListTableHeaderActionController = class {
     if (this.options.isEditing() || this.options.getLeafColumns().find((column) => column.key === columnKey)?.allowSort === false) {
       return;
     }
+    this.options.captureSortAnimation?.(columnKey);
     this.options.prepareLocalQuery("sort");
     this.options.setSortState(
       toggleSortingState(
@@ -31674,6 +33244,7 @@ var ListTableHeaderActionController = class {
     if (this.options.isEditing() || this.options.getLeafColumns().find((column) => column.key === columnKey)?.allowSort === false) {
       return;
     }
+    this.options.captureSortAnimation?.(columnKey);
     this.options.prepareLocalQuery("sort");
     this.options.setSortState(
       setSortingOrder(
@@ -31844,6 +33415,7 @@ var ListTableHeaderActionController = class {
     if (this.options.isEditing()) {
       return;
     }
+    this.options.captureSortAnimation?.();
     this.options.prepareLocalQuery("sort");
     const next = resolveResetSortAction(this.options.getFilterState());
     this.options.setSortState(next.sortState);
@@ -31881,6 +33453,7 @@ var ListTableHeaderActionController = class {
     if (!resolved) {
       return;
     }
+    this.options.overlayController.preserveHeaderContextMenuForColumnVisibility();
     this.options.setSelectedHeaderState(
       resolved.selectedHeaderKey,
       resolved.selectedHeaderRect
@@ -31905,6 +33478,9 @@ var ListTableHeaderActionController = class {
       buildHeaderSettingsItems(columns)
     );
     this.options.requestRender();
+    if (draft.key && draft.sortOrder !== void 0 && (this.options.getSortState().find((entry) => entry.key === draft.key)?.order ?? null) !== draft.sortOrder) {
+      this.setSortOrder(draft.key, draft.sortOrder);
+    }
     return null;
   }
   deleteHeaderColumn(columnKey) {
@@ -31996,6 +33572,7 @@ var ListTableOverlayController = class {
     __publicField(this, "componentPortal");
     __publicField(this, "getContentZoom");
     __publicField(this, "runtime");
+    __publicField(this, "preserveColumnVisibilityMenu", false);
     __publicField(this, "tooltipAdapter");
     __publicField(this, "filterPanelAdapter");
     __publicField(this, "fixedPopupAdapter");
@@ -32133,6 +33710,7 @@ var ListTableOverlayController = class {
     return this.componentPortal.fixedPopup.isVisible();
   }
   showHeaderContextMenu(config) {
+    this.preserveColumnVisibilityMenu = false;
     this.runtime.headerContextMenuVisible = true;
     this.runtime.headerContextMenuConfig = config;
     const options = this.getOptions();
@@ -32142,6 +33720,7 @@ var ListTableOverlayController = class {
     }
   }
   hideHeaderContextMenu() {
+    this.preserveColumnVisibilityMenu = false;
     this.runtime.headerContextMenuVisible = false;
     this.runtime.headerContextMenuConfig = null;
     this.getOptions().ui?.onHeaderContextMenuRequest?.(null);
@@ -32153,6 +33732,15 @@ var ListTableOverlayController = class {
     }
     return this.componentPortal.headerContextMenu.isVisible();
   }
+  /** 连续修改列显隐时，保留菜单直到用户显式关闭。 */
+  preserveHeaderContextMenuForColumnVisibility() {
+    if (this.runtime.headerContextMenuVisible) {
+      this.preserveColumnVisibilityMenu = true;
+    }
+  }
+  shouldPreserveHeaderContextMenuOnOptionsUpdate() {
+    return this.runtime.headerContextMenuVisible && this.preserveColumnVisibilityMenu;
+  }
   updateHeaderContextMenuColumns(columns) {
     const options = this.getOptions();
     if (options.ui?.onHeaderContextMenuRequest && this.runtime.headerContextMenuConfig) {
@@ -32373,7 +33961,7 @@ function applyStoredColumnConfig(columns, storedColumns, cacheColumnSettings = t
   applyToColumns(columns);
   return columnWidthsChanged;
 }
-function buildStoredColumnConfig(columns, sortState, filterState, zoom, summaryRowHeight, density, cacheColumnSettings = true, cachePreferences) {
+function buildStoredColumnConfig(columns, sortState, filterState, zoom, summaryRowHeight, density, cacheColumnSettings = true, cachePreferences, scrollbar) {
   const result = {};
   const columnOrder = [];
   const collectColumns = (cols, parentKey) => {
@@ -32430,6 +34018,7 @@ function buildStoredColumnConfig(columns, sortState, filterState, zoom, summaryR
     {
       columns: result,
       cacheColumnSettings,
+      ...scrollbar ? { scrollbar } : null,
       ...cacheColumnSettings ? { columnOrder } : null,
       sort: sortState.map((item) => ({ ...item })),
       filters: filterState,
@@ -32469,6 +34058,7 @@ function filterStoredColumnConfig(stored, preferences = {}) {
   if (preferences.summary === false) delete result.summaryRowHeight;
   if (preferences.density === false) delete result.density;
   if (preferences.zoom === false) delete result.zoom;
+  if (preferences.scrollbar === false) delete result.scrollbar;
   return result;
 }
 
@@ -32483,7 +34073,8 @@ function persistListTableColumnConfig(params) {
     summaryRowHeight,
     density,
     cacheColumnSettings,
-    cachePreferences
+    cachePreferences,
+    scrollbar
   } = params;
   if (!storageKey) {
     return;
@@ -32499,7 +34090,8 @@ function persistListTableColumnConfig(params) {
       summaryRowHeight,
       density,
       cacheColumnSettings,
-      cachePreferences
+      cachePreferences,
+      scrollbar
     )
   );
 }
@@ -32568,6 +34160,7 @@ async function loadListTableStoredConfig(params) {
     stored.columnOrder
   );
   return {
+    scrollbar: stored.scrollbar,
     cacheColumnSettings,
     cachePreferences,
     sortState: cachePreferences.sort !== false && Array.isArray(stored.sort) ? stored.sort.filter(
@@ -32652,6 +34245,10 @@ var ListTablePersistenceController = class {
       this.options.canvasHost.setContentZoom(nextZoom);
     }
     let currentOptions = this.options.getOptions();
+    if (stored.scrollbar) {
+      currentOptions = { ...currentOptions, scrollbar: stored.scrollbar };
+      currentOptions.ui?.onScrollbarChange?.(stored.scrollbar);
+    }
     if (stored.cachePreferences) {
       currentOptions = {
         ...currentOptions,
@@ -32696,10 +34293,16 @@ var ListTablePersistenceController = class {
       }
     }
     this.options.refreshRuntimeColumns();
+    currentOptions.ui?.onColumnSettingsChange?.(
+      cloneColumns(currentOptions.columns)
+    );
   }
   persistColumnConfig() {
     this.invalidate();
     const tableOptions = this.options.getOptions();
+    tableOptions.ui?.onColumnSettingsChange?.(
+      cloneColumns(tableOptions.columns)
+    );
     this.restoredStorageKey = tableOptions.storageKey;
     this.hasRestoredPreferences = true;
     this.pendingWrite = Promise.resolve(
@@ -32707,6 +34310,7 @@ var ListTablePersistenceController = class {
         storageKey: tableOptions.storageKey,
         cacheColumnSettings: tableOptions.cacheColumnSettings,
         cachePreferences: tableOptions.cachePreferences,
+        scrollbar: tableOptions.scrollbar,
         columns: tableOptions.columns,
         sortState: this.options.getSortState(),
         filterState: this.options.getFilterState(),
@@ -32941,6 +34545,7 @@ var ListTableQueryController = class {
         this.invalidateDataCache();
         this.options.hideLoading();
         this.emitQueryChangeWithResolvedRows(action, baseRows);
+        if (action === "sort") this.options.onSortResolved?.();
         this.options.requestRender();
       }).catch(handleFailure);
     };
@@ -34465,6 +36070,7 @@ var ListTableSelectionController = class {
     __publicField(this, "selectedHeaderKey", null);
     __publicField(this, "selectedHeaderRect", null);
     __publicField(this, "summarySelected", false);
+    __publicField(this, "pendingSortSelection", null);
     this.options = options;
   }
   getSelectedHeaderKey() {
@@ -34488,20 +36094,62 @@ var ListTableSelectionController = class {
     this.selectedHeaderRect = null;
   }
   clearBodySelection() {
+    this.pendingSortSelection = null;
     this.options.setSelection({
       rowIndex: null,
       columnKey: null
     });
   }
+  /** 排序前按稳定行标识记录活动行，避免行号被新排序复用。 */
+  captureSortSelection(rows) {
+    const options = this.options.getOptions();
+    const rowIndex = this.options.getSelection().rowIndex;
+    const record = rowIndex == null ? void 0 : rows[rowIndex];
+    this.pendingSortSelection = options.rowKey && record !== void 0 && rowIndex != null ? { rowKey: getRowKey(options, record, rowIndex), rowIndex } : null;
+  }
+  /** 排序完成后将活动行及其单行选区映射到新行号。 */
+  reconcileSortSelection(rows) {
+    const pending = this.pendingSortSelection;
+    this.pendingSortSelection = null;
+    if (!pending) return;
+    const options = this.options.getOptions();
+    const sameIndexRecord = rows[pending.rowIndex];
+    const nextIndex = sameIndexRecord !== void 0 && getRowKey(options, sameIndexRecord, pending.rowIndex) === pending.rowKey ? pending.rowIndex : rows.findIndex(
+      (record, index) => getRowKey(options, record, index) === pending.rowKey
+    );
+    const selection = this.options.getSelection();
+    if (selection.rowIndex !== pending.rowIndex) return;
+    if (nextIndex === pending.rowIndex) return;
+    this.options.setSelection({
+      ...selection,
+      rowIndex: nextIndex >= 0 ? nextIndex : null,
+      columnKey: nextIndex >= 0 ? selection.columnKey : null
+    });
+    const range = this.options.getRangeHighlight();
+    const singleRowRange = range.selectedRowRange?.start === pending.rowIndex && range.selectedRowRange.end === pending.rowIndex;
+    const singleCellRange = range.selectedCellRange?.startRowIndex === pending.rowIndex && range.selectedCellRange.endRowIndex === pending.rowIndex;
+    this.options.setRangeHighlight({
+      ...range,
+      selectedRowAnchorIndex: range.selectedRowAnchorIndex === pending.rowIndex ? nextIndex >= 0 ? nextIndex : null : range.selectedRowAnchorIndex,
+      selectedRowRange: singleRowRange ? nextIndex >= 0 ? { start: nextIndex, end: nextIndex } : null : range.selectedRowRange,
+      selectedCellAnchor: range.selectedCellAnchor?.rowIndex === pending.rowIndex ? nextIndex >= 0 ? { ...range.selectedCellAnchor, rowIndex: nextIndex } : null : range.selectedCellAnchor,
+      selectedCellRange: singleCellRange ? nextIndex >= 0 ? {
+        ...range.selectedCellRange,
+        startRowIndex: nextIndex,
+        endRowIndex: nextIndex
+      } : null : range.selectedCellRange
+    });
+  }
   setSelectedHeaderState(selectedHeaderKey, selectedHeaderRect) {
     this.selectedHeaderKey = selectedHeaderKey;
     this.selectedHeaderRect = selectedHeaderRect;
   }
-  resetRangeHighlightForHeaderSelection(shiftKey) {
+  resetRangeHighlightForHeaderSelection(shiftKey, ctrlKey = false) {
     this.options.setRangeHighlight(
       resolveRangeHighlightForHeaderSelection({
         current: this.options.getRangeHighlight(),
-        shiftKey
+        shiftKey,
+        ctrlKey
       })
     );
   }
@@ -34569,7 +36217,7 @@ var ListTableSelectionController = class {
       })
     );
   }
-  updateRangeHighlightForHeaderClick(columnKey, shiftKey) {
+  updateRangeHighlightForHeaderClick(columnKey, shiftKey, ctrlKey = false) {
     const leafColumns = this.options.getLeafColumns();
     const targetRange = findHeaderLeafRange({
       columnKey,
@@ -34586,7 +36234,8 @@ var ListTableSelectionController = class {
         leafColumnKeys: leafColumns.map((column) => column.key),
         rangeStartIndex: targetRange.start,
         rangeEndIndex: targetRange.end,
-        shiftKey
+        shiftKey,
+        ctrlKey
       })
     );
   }
@@ -34630,7 +36279,8 @@ var ListTableSelectionController = class {
     this.options.setRangeHighlight({
       ...current,
       selectedColumnAnchorKey: null,
-      selectedColumnRange: null
+      selectedColumnRange: null,
+      selectedColumnKeys: null
     });
   }
   destroy() {
@@ -34968,6 +36618,44 @@ function createDefaultSummaryScheduler() {
   };
 }
 
+// src/engine/sort-animation.ts
+function hasAnimatedSortColumn(columns, sortState) {
+  if (!sortState.length) return false;
+  const activeKeys = new Set(sortState.map((item) => item.key));
+  const visit = (items) => items.some(
+    (column) => activeKeys.has(resolveColumnKey(column)) && typeof column.sorter === "object" && column.sorter.animation === true || (column.children?.length ? visit(column.children) : false)
+  );
+  return visit(columns);
+}
+function shouldAnimateSortedDataUpdate(params) {
+  const { previous, next, sortState, expandedRowsChanged } = params;
+  return Boolean(
+    !expandedRowsChanged && next.rowKey && previous.rowKey && previous.rowHeight !== "auto" && next.rowHeight !== "auto" && next.rowHeight === previous.rowHeight && next.dataSource !== previous.dataSource && hasAnimatedSortColumn(next.columns, sortState)
+  );
+}
+
+// src/features/grouping/default-grouping.ts
+function resolveDefaultGroupingColumnKeys(columns) {
+  const candidates = [];
+  const visit = (items) => {
+    items.forEach((column) => {
+      if (column.children?.length) {
+        visit(column.children);
+        return;
+      }
+      if (!column.grouping) return;
+      const order = typeof column.grouping === "object" && Number.isFinite(column.grouping.order) ? column.grouping.order : Number.POSITIVE_INFINITY;
+      candidates.push({
+        key: column.key ?? String(column.dataIndex),
+        order,
+        index: candidates.length
+      });
+    });
+  };
+  visit(columns);
+  return candidates.sort((left, right) => left.order - right.order || left.index - right.index).map((item) => item.key);
+}
+
 // src/engine/controller-assembly.ts
 function assembleListTableCoreControllers(core, options) {
   const getCanvasHostElement = () => core.domHost.getNodes()?.canvasHostElement ?? null;
@@ -35091,14 +36779,24 @@ function assembleListTableCoreControllers(core, options) {
       ...core.storeFacade.rangeHighlight,
       selectedColumnAnchorKey: null,
       selectedColumnRange: null,
+      selectedColumnKeys: null,
       selectedCellRange: null
     };
   };
   core.syncGroupingBar = syncGroupingBar;
   core.syncGroupingFromOptions = () => {
     const previousColumnKeys = core.groupColumnKeys;
+    const nextDefaultKeys = resolveDefaultGroupingColumnKeys(
+      core.options.columns
+    );
+    const defaultsChanged = nextDefaultKeys.length !== core.defaultGroupColumnKeys.length || nextDefaultKeys.some(
+      (key, index) => key !== core.defaultGroupColumnKeys[index]
+    );
+    core.defaultGroupColumnKeys = nextDefaultKeys;
     if (core.options.grouping?.visible !== void 0) {
       core.groupBarVisible = core.options.grouping.visible;
+    } else if (defaultsChanged) {
+      core.groupBarVisible = nextDefaultKeys.length > 0;
     }
     if (core.options.grouping?.columnKeys !== void 0) {
       const validKeys = new Set(
@@ -35109,6 +36807,8 @@ function assembleListTableCoreControllers(core, options) {
       core.groupColumnKeys = core.options.grouping.columnKeys.filter(
         (key, index, keys) => validKeys.has(key) && keys.indexOf(key) === index
       );
+    } else if (defaultsChanged) {
+      core.groupColumnKeys = nextDefaultKeys;
     }
     if (previousColumnKeys.length !== core.groupColumnKeys.length || previousColumnKeys.some(
       (key, index) => key !== core.groupColumnKeys[index]
@@ -35189,7 +36889,8 @@ function assembleListTableCoreControllers(core, options) {
     getQueryRuntimeState,
     showLoading: (text) => core.overlayController.showLoading(text),
     hideLoading: () => core.overlayController.hideLoading(),
-    requestRender: () => render()
+    requestRender: () => render(),
+    onSortResolved: () => core.animationController.markSortRowsReady()
   });
   core.summaryController = new ListTableSummaryController({
     getOptions: () => core.options,
@@ -35344,6 +37045,18 @@ function assembleListTableCoreControllers(core, options) {
     persistColumnConfig: () => core.persistenceController.persistColumnConfig(),
     emitQueryChange,
     prepareLocalQuery,
+    captureSortAnimation: (columnKey) => {
+      const currentSort = core.storeFacade.sortState;
+      const nextSort = columnKey ? [...currentSort, { key: columnKey, order: "ascend" }] : currentSort;
+      if (!core.options.rowKey || core.options.rowHeight === "auto" || !hasAnimatedSortColumn(core.options.columns, nextSort)) {
+        core.animationController.setPendingSortRowPositions(null);
+        return;
+      }
+      core.selectionController.captureSortSelection(getDisplayData());
+      core.animationController.setPendingSortRowPositions(
+        captureRenderedVisibleRowPositions(getCurrentRenderSnapshot())
+      );
+    },
     applyFilterQueryAsync,
     applySortQueryAsync,
     refreshRuntimeColumns,
@@ -35359,6 +37072,7 @@ function assembleListTableCoreControllers(core, options) {
   });
   core.contentActionController = new ListTableContentActionController({
     getSummaryVisible: () => Boolean(getCurrentRenderSnapshot()?.hasSummary),
+    getSortState: () => core.storeFacade.sortState,
     getOptions: () => core.options,
     getLeafColumns: () => core.leafColumns,
     overlayController: core.overlayController,
@@ -35503,6 +37217,9 @@ function assembleListTableCoreControllers(core, options) {
         expandedRowKeys: core.storeFacade.expandedRowKeys
       });
       core.animationController.reconcileCollapseAnimations(snapshot);
+      if (core.animationController.reconcileSortAnimations(snapshot)) {
+        core.selectionController.reconcileSortSelection(snapshot.displayRows);
+      }
     },
     getPublishAccessors: () => ({
       nestedTableLayoutRevision: core.animationController.getNestedTableLayoutRevision(),
@@ -35671,8 +37388,13 @@ function assembleListTableCoreControllers(core, options) {
   core.draggingResize = null;
   core.draggingReorder = null;
   core.suppressNextClick = false;
-  core.groupBarVisible = options.grouping?.visible ?? false;
-  core.groupColumnKeys = [...options.grouping?.columnKeys ?? []];
+  core.defaultGroupColumnKeys = resolveDefaultGroupingColumnKeys(
+    options.columns
+  );
+  core.groupBarVisible = options.grouping?.visible ?? core.defaultGroupColumnKeys.length > 0;
+  core.groupColumnKeys = [
+    ...options.grouping?.columnKeys ?? core.defaultGroupColumnKeys
+  ];
   core.tableZoom = 1;
 }
 function collectGroupingColumnItems(columns) {
@@ -35787,6 +37509,7 @@ var ListTableCore = class {
    * @param options 新配置。
    */
   updateOptions(options) {
+    const preserveContextMenu = options.dataSource !== this.options.dataSource || this.overlayController.shouldPreserveHeaderContextMenuOnOptionsUpdate();
     this.persistenceController.invalidate();
     if (options.storageKey === this.options.storageKey) {
       options = {
@@ -35798,6 +37521,8 @@ var ListTableCore = class {
     options = resolveListTableStyleOptions(options);
     this.animationController.stopCarouselScroll();
     const host = this.asAssemblyHost();
+    const previousLeafColumns = host.leafColumns;
+    const previousSegments = host.columnSegments;
     const shouldResetColumnConfig = shouldPersistIncomingColumnConfig(
       this.options.columnConfigResetRevision,
       options.columnConfigResetRevision
@@ -35826,15 +37551,37 @@ var ListTableCore = class {
     }
     applyInitialColumnVisibility(options.columns);
     ensureColumnKeysInPlace(options.columns);
-    if (options.expandable?.expandedRowKeys !== void 0 && !areSameRowKeySet(
+    const expandedRowsChanged = options.expandable?.expandedRowKeys !== void 0 && !areSameRowKeySet(
       this.storeFacade.expandedRowKeys,
       options.expandable.expandedRowKeys
-    )) {
+    );
+    if (expandedRowsChanged) {
       this.animationController.setPendingCollapseRowPositions(
         captureRenderedVisibleRowPositions(
           this.renderController.getCurrentRenderSnapshot()
         )
       );
+    } else if (shouldAnimateSortedDataUpdate({
+      previous: this.options,
+      next: options,
+      sortState: this.storeFacade.sortState,
+      expandedRowsChanged
+    })) {
+      if (this.animationController.hasPendingSortRows()) {
+        this.animationController.markSortRowsReady();
+      } else {
+        this.selectionController.captureSortSelection(
+          this.queryController.getDisplayData()
+        );
+        this.animationController.setPendingSortRowPositions(
+          captureRenderedVisibleRowPositions(
+            this.renderController.getCurrentRenderSnapshot()
+          ),
+          true
+        );
+      }
+    } else if (options.dataSource !== this.options.dataSource) {
+      this.animationController.markSortRowsReady();
     }
     this.queryController.reset();
     this.options = options;
@@ -35852,7 +37599,10 @@ var ListTableCore = class {
     });
     this.debugManager = new DebugManager(options.debug);
     host.renderer?.updateDebugOptions(options.debug ?? {});
-    this.hideFloatingOverlays({ includeLoading: true });
+    this.hideFloatingOverlays({
+      includeLoading: true,
+      preserveContextMenu
+    });
     this.refreshRuntimeColumns();
     if (shouldPersistColumnConfig) {
       this.persistenceController.persistColumnConfig();
@@ -35860,6 +37610,12 @@ var ListTableCore = class {
       this.persistenceController.loadStoredConfig({ restoreQueryState: false });
     }
     this.renderController.render();
+    if (shouldPersistColumnConfig && haveVisibleLeafColumnsChanged(previousLeafColumns, host.leafColumns)) {
+      host.rowActionController.startColumnVisibilityAnimation({
+        previousLeafColumns,
+        previousSegments
+      });
+    }
     host.tableId = options.tableId?.trim() ? options.tableId : host.tableId;
     host.rowDragController.syncRegistration();
   }
@@ -35897,6 +37653,14 @@ var ListTableCore = class {
   resetSorter() {
     this.headerActionController.resetSort();
   }
+  /** 获取当前排序状态，供外部设置面板回显。 */
+  getSortState() {
+    return [...this.storeFacade.sortState];
+  }
+  /** 使用与表头一致的排序逻辑设置指定列。 */
+  setSortOrder(columnKey, order) {
+    this.headerActionController.setSortOrder(columnKey, order);
+  }
   /**
    * 重置筛选状态。
    */
@@ -36002,14 +37766,15 @@ var ListTableCore = class {
     return this;
   }
   hideFloatingOverlays(params) {
-    this.componentPortal.hideFloatingLayers();
     if (params?.includeLoading) {
       this.overlayController.hideLoading();
     }
     this.overlayController.hideTooltip();
     this.overlayController.hideFilterPanel();
     this.overlayController.hideFixedPopup();
-    this.overlayController.hideHeaderContextMenu();
+    if (!params?.preserveContextMenu) {
+      this.overlayController.hideHeaderContextMenu();
+    }
   }
   refreshRuntimeColumns() {
     this.storeFacade.runtimeColumns = buildRuntimeColumnsMap({
@@ -36091,6 +37856,14 @@ var ListTable = class {
   resetSorter() {
     this.core?.resetSorter();
   }
+  /** 获取当前排序状态。 */
+  getSortState() {
+    return this.core?.getSortState() ?? [];
+  }
+  /** 设置指定列的排序方式。 */
+  setSortOrder(columnKey, order) {
+    this.core?.setSortOrder(columnKey, order);
+  }
   /**
    * 重置筛选状态。
    */