fix(api): use bcrypt directly instead of passlib for compatibility

web/node_modules/element-plus/lib/components/table/src/table-header/event-helper.d.ts

@@ -0,0 +1,17 @@
+import { EmitFn } from "../../../../utils/vue/typescript.js";
+import { TableColumnCtx } from "../table-column/defaults.js";
+import { TableHeaderProps } from "./index.js";
+import { DefaultRow, TableSortOrder } from "../table/defaults.js";
+
+//#region ../../packages/components/table/src/table-header/event-helper.d.ts
+declare function useEvent<T extends DefaultRow>(props: TableHeaderProps<T>, emit: EmitFn<string[]>): {
+  handleHeaderClick: (event: Event, column: TableColumnCtx<T>) => void;
+  handleHeaderContextMenu: (event: Event, column: TableColumnCtx<T>) => void;
+  handleMouseDown: (event: MouseEvent, column: TableColumnCtx<T>) => void;
+  handleMouseMove: (event: MouseEvent, column: TableColumnCtx<T>) => void;
+  handleMouseOut: () => void;
+  handleSortClick: (event: Event, column: TableColumnCtx<T>, givenOrder?: TableSortOrder | boolean) => void;
+  handleFilterClick: (event: Event) => void;
+};
+//#endregion
+export { useEvent as default };

web/node_modules/element-plus/lib/components/table/src/table-header/event-helper.js

@@ -0,0 +1,163 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../../../_virtual/_rolldown/runtime.js");
+const require_types = require("../../../../utils/types.js");
+const require_style = require("../../../../utils/dom/style.js");
+const require_tokens = require("../tokens.js");
+let lodash_unified = require("lodash-unified");
+let vue = require("vue");
+let _vueuse_core = require("@vueuse/core");
+//#region ../../packages/components/table/src/table-header/event-helper.ts
+function useEvent(props, emit) {
+	const instance = (0, vue.getCurrentInstance)();
+	const parent = (0, vue.inject)(require_tokens.TABLE_INJECTION_KEY);
+	const handleFilterClick = (event) => {
+		event.stopPropagation();
+	};
+	const handleHeaderClick = (event, column) => {
+		if (!column.filters && column.sortable) handleSortClick(event, column, false);
+		else if (column.filterable && !column.sortable) handleFilterClick(event);
+		parent?.emit("header-click", column, event);
+	};
+	const handleHeaderContextMenu = (event, column) => {
+		parent?.emit("header-contextmenu", column, event);
+	};
+	const draggingColumn = (0, vue.ref)(null);
+	const dragging = (0, vue.ref)(false);
+	const dragState = (0, vue.ref)();
+	const handleMouseDown = (event, column) => {
+		if (!_vueuse_core.isClient) return;
+		if (column.children && column.children.length > 0) return;
+		/* istanbul ignore if */
+		if (draggingColumn.value && props.border && draggingColumn.value.id === column.id) {
+			dragging.value = true;
+			const table = parent;
+			emit("set-drag-visible", true);
+			const tableLeft = (table?.vnode.el)?.getBoundingClientRect().left;
+			const columnEl = instance?.vnode?.el?.querySelector(`th.${column.id}`);
+			const columnRect = columnEl.getBoundingClientRect();
+			const minLeft = columnRect.left - tableLeft + 30;
+			require_style.addClass(columnEl, "noclick");
+			dragState.value = {
+				startMouseLeft: event.clientX,
+				startLeft: columnRect.right - tableLeft,
+				startColumnLeft: columnRect.left - tableLeft,
+				tableLeft
+			};
+			const resizeProxy = table?.refs.resizeProxy;
+			resizeProxy.style.left = `${dragState.value.startLeft}px`;
+			document.onselectstart = function() {
+				return false;
+			};
+			document.ondragstart = function() {
+				return false;
+			};
+			const handleMouseMove = (event) => {
+				const deltaLeft = event.clientX - dragState.value.startMouseLeft;
+				const proxyLeft = dragState.value.startLeft + deltaLeft;
+				resizeProxy.style.left = `${Math.max(minLeft, proxyLeft)}px`;
+			};
+			const handleMouseUp = () => {
+				if (dragging.value) {
+					const { startColumnLeft, startLeft } = dragState.value;
+					column.width = column.realWidth = Number.parseInt(resizeProxy.style.left, 10) - startColumnLeft;
+					table?.emit("header-dragend", column.width, startLeft - startColumnLeft, column, event);
+					requestAnimationFrame(() => {
+						props.store.scheduleLayout(false, true);
+					});
+					document.body.style.cursor = "";
+					dragging.value = false;
+					draggingColumn.value = null;
+					dragState.value = void 0;
+					emit("set-drag-visible", false);
+				}
+				document.removeEventListener("mousemove", handleMouseMove);
+				document.removeEventListener("mouseup", handleMouseUp);
+				document.onselectstart = null;
+				document.ondragstart = null;
+				setTimeout(() => {
+					require_style.removeClass(columnEl, "noclick");
+				}, 0);
+			};
+			document.addEventListener("mousemove", handleMouseMove);
+			document.addEventListener("mouseup", handleMouseUp);
+		}
+	};
+	const handleMouseMove = (event, column) => {
+		if (!props.border || column.children && column.children.length > 0) return;
+		const el = event.target;
+		const target = require_types.isElement(el) ? el.closest("th") : null;
+		if (!target) return;
+		const isSortable = require_style.hasClass(target, "is-sortable");
+		if (isSortable) {
+			const cursor = dragging.value ? "col-resize" : "";
+			target.style.cursor = cursor;
+			const caret = target.querySelector(".caret-wrapper");
+			if (caret) caret.style.cursor = cursor;
+		}
+		if (!column.resizable || dragging.value) {
+			draggingColumn.value = null;
+			return;
+		}
+		const rect = target.getBoundingClientRect();
+		const isLastTh = target.parentNode?.lastElementChild === target;
+		const allowDrag = props.allowDragLastColumn || !isLastTh;
+		const isResizeHandleActive = rect.width > 12 && rect.right - event.clientX < 8 && allowDrag;
+		const cursor = isResizeHandleActive ? "col-resize" : "";
+		document.body.style.cursor = cursor;
+		draggingColumn.value = isResizeHandleActive ? column : null;
+		if (isSortable) target.style.cursor = cursor;
+	};
+	const handleMouseOut = () => {
+		if (!_vueuse_core.isClient || dragging.value) return;
+		document.body.style.cursor = "";
+	};
+	const toggleOrder = ({ order, sortOrders }) => {
+		if (order === "") return sortOrders[0];
+		const index = sortOrders.indexOf(order || null);
+		return sortOrders[index > sortOrders.length - 2 ? 0 : index + 1];
+	};
+	const handleSortClick = (event, column, givenOrder) => {
+		event.stopPropagation();
+		const order = column.order === givenOrder ? null : givenOrder || toggleOrder(column);
+		const target = event.target?.closest("th");
+		if (target) {
+			if (require_style.hasClass(target, "noclick")) {
+				require_style.removeClass(target, "noclick");
+				return;
+			}
+		}
+		if (!column.sortable) return;
+		const clickTarget = event.currentTarget;
+		if (["ascending", "descending"].some((str) => require_style.hasClass(clickTarget, str) && !column.sortOrders.includes(str))) return;
+		const states = props.store.states;
+		let sortProp = states.sortProp.value;
+		let sortOrder;
+		const sortingColumn = states.sortingColumn.value;
+		if (sortingColumn !== column || sortingColumn === column && (0, lodash_unified.isNull)(sortingColumn.order)) {
+			if (sortingColumn) sortingColumn.order = null;
+			states.sortingColumn.value = column;
+			sortProp = column.property;
+		}
+		if (!order) sortOrder = column.order = null;
+		else sortOrder = column.order = order;
+		states.sortProp.value = sortProp;
+		states.sortOrder.value = sortOrder;
+		parent?.store.commit("changeSortCondition");
+	};
+	return {
+		handleHeaderClick,
+		handleHeaderContextMenu,
+		handleMouseDown,
+		handleMouseMove,
+		handleMouseOut,
+		handleSortClick,
+		handleFilterClick
+	};
+}
+//#endregion
+exports.default = useEvent;
+
+//# sourceMappingURL=event-helper.js.map

web/node_modules/element-plus/lib/components/table/src/table-header/index.d.ts

@@ -0,0 +1,214 @@
+import { Translator } from "../../../../hooks/use-locale/index.js";
+import { CheckboxProps, CheckboxValueType } from "../../../checkbox/src/checkbox.js";
+import _default$1 from "../../../checkbox/src/checkbox-button.vue.js";
+import _default$2 from "../../../checkbox/src/checkbox-group.vue.js";
+import { TableColumnCtx } from "../table-column/defaults.js";
+import TableLayout from "../table-layout.js";
+import { DefaultRow, Sort, TableSortOrder } from "../table/defaults.js";
+import { Store } from "../store/index.js";
+import * as _$vue from "vue";
+import { ComponentInternalInstance, PropType, Ref } from "vue";
+
+//#region ../../packages/components/table/src/table-header/index.d.ts
+interface TableHeader extends ComponentInternalInstance {
+  state: {
+    onColumnsChange: (layout: TableLayout<any>) => void;
+    onScrollableChange: (layout: TableLayout<any>) => void;
+  };
+  filterPanels: Ref<DefaultRow>;
+}
+interface TableHeaderProps<T extends DefaultRow> {
+  fixed: string;
+  store: Store<T>;
+  border: boolean;
+  defaultSort: Sort;
+  allowDragLastColumn: boolean;
+}
+declare const _default: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+  fixed: {
+    type: StringConstructor;
+    default: string;
+  };
+  store: {
+    required: true;
+    type: PropType<TableHeaderProps<any>["store"]>;
+  };
+  border: BooleanConstructor;
+  defaultSort: {
+    type: PropType<TableHeaderProps<any>["defaultSort"]>;
+    default: () => {
+      prop: string;
+      order: string;
+    };
+  };
+  appendFilterPanelTo: {
+    type: StringConstructor;
+  };
+  allowDragLastColumn: {
+    type: BooleanConstructor;
+  };
+}>, {
+  ns: {
+    namespace: _$vue.ComputedRef<string>;
+    b: (blockSuffix?: string) => string;
+    e: (element?: string) => string;
+    m: (modifier?: string) => string;
+    be: (blockSuffix?: string, element?: string) => string;
+    em: (element?: string, modifier?: string) => string;
+    bm: (blockSuffix?: string, modifier?: string) => string;
+    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+    is: {
+      (name: string, state: boolean | undefined): string;
+      (name: string): string;
+    };
+    cssVar: (object: Record<string, string>) => Record<string, string>;
+    cssVarName: (name: string) => string;
+    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+    cssVarBlockName: (name: string) => string;
+  };
+  t: Translator;
+  filterPanels: Ref<{}, {}>;
+  onColumnsChange: (layout: TableLayout<DefaultRow>) => void;
+  onScrollableChange: (layout: TableLayout<DefaultRow>) => void;
+  columnRows: _$vue.ComputedRef<TableColumnCtx<any>[][]>;
+  getHeaderRowClass: (rowIndex: number) => string;
+  getHeaderRowStyle: (rowIndex: number) => any;
+  getHeaderCellClass: (rowIndex: number, columnIndex: number, row: any, column: TableColumnCtx<any>) => string;
+  getHeaderCellStyle: (rowIndex: number, columnIndex: number, row: any, column: TableColumnCtx<any>) => _$vue.CSSProperties;
+  handleHeaderClick: (event: Event, column: TableColumnCtx<any>) => void;
+  handleHeaderContextMenu: (event: Event, column: TableColumnCtx<any>) => void;
+  handleMouseDown: (event: MouseEvent, column: TableColumnCtx<any>) => void;
+  handleMouseMove: (event: MouseEvent, column: TableColumnCtx<any>) => void;
+  handleMouseOut: () => void;
+  handleSortClick: (event: Event, column: TableColumnCtx<any>, givenOrder?: TableSortOrder | boolean) => void;
+  handleFilterClick: (event: Event) => void;
+  isGroup: _$vue.ComputedRef<boolean>;
+  toggleAllSelection: (event: Event) => void;
+  saveIndexSelection: _$vue.Reactive<Map<any, any>>;
+  isTableLayoutAuto: boolean;
+  theadRef: Ref<any, any>;
+  updateFixedColumnStyle: () => void;
+}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+  fixed: {
+    type: StringConstructor;
+    default: string;
+  };
+  store: {
+    required: true;
+    type: PropType<TableHeaderProps<any>["store"]>;
+  };
+  border: BooleanConstructor;
+  defaultSort: {
+    type: PropType<TableHeaderProps<any>["defaultSort"]>;
+    default: () => {
+      prop: string;
+      order: string;
+    };
+  };
+  appendFilterPanelTo: {
+    type: StringConstructor;
+  };
+  allowDragLastColumn: {
+    type: BooleanConstructor;
+  };
+}>> & Readonly<{}>, {
+  fixed: string;
+  border: boolean;
+  defaultSort: Sort;
+  allowDragLastColumn: boolean;
+}, {}, {
+  ElCheckbox: {
+    new (...args: any[]): _$vue.CreateComponentPublicInstanceWithMixins<Readonly<CheckboxProps> & Readonly<{
+      "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+      onChange?: ((val: CheckboxValueType) => any) | undefined;
+    }>, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+      change: (val: CheckboxValueType) => void;
+      "update:modelValue": (val: CheckboxValueType) => void;
+    }, _$vue.PublicProps, {
+      name: string;
+      label: string | boolean | number | object;
+      disabled: boolean;
+      modelValue: number | string | boolean;
+      id: string;
+      validateEvent: boolean;
+      value: string | boolean | number | object;
+      trueValue: string | number;
+      falseValue: string | number;
+      trueLabel: string | number;
+      falseLabel: string | number;
+    }, false, {}, {}, _$vue.GlobalComponents, _$vue.GlobalDirectives, string, {}, any, _$vue.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<CheckboxProps> & Readonly<{
+      "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+      onChange?: ((val: CheckboxValueType) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+      name: string;
+      label: string | boolean | number | object;
+      disabled: boolean;
+      modelValue: number | string | boolean;
+      id: string;
+      validateEvent: boolean;
+      value: string | boolean | number | object;
+      trueValue: string | number;
+      falseValue: string | number;
+      trueLabel: string | number;
+      falseLabel: string | number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & _$vue.ComponentOptionsBase<Readonly<CheckboxProps> & Readonly<{
+    "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+    onChange?: ((val: CheckboxValueType) => any) | undefined;
+  }>, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+    change: (val: CheckboxValueType) => void;
+    "update:modelValue": (val: CheckboxValueType) => void;
+  }, string, {
+    name: string;
+    label: string | boolean | number | object;
+    disabled: boolean;
+    modelValue: number | string | boolean;
+    id: string;
+    validateEvent: boolean;
+    value: string | boolean | number | object;
+    trueValue: string | number;
+    falseValue: string | number;
+    trueLabel: string | number;
+    falseLabel: string | number;
+  }, {}, string, {}, _$vue.GlobalComponents, _$vue.GlobalDirectives, string, _$vue.ComponentProvideOptions> & _$vue.VNodeProps & _$vue.AllowedComponentProps & _$vue.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  }) & _$vue.ObjectPlugin & {
+    setPropsDefaults: (defaults: {
+      readonly modelValue?: string | number | boolean | (() => string | number | boolean) | undefined;
+      readonly label?: string | number | boolean | (() => string | number | boolean | object) | undefined;
+      readonly value?: string | number | boolean | (() => string | number | boolean | object) | undefined;
+      readonly indeterminate?: boolean | (() => boolean) | undefined;
+      readonly disabled?: boolean | (() => boolean) | undefined;
+      readonly checked?: boolean | (() => boolean) | undefined;
+      readonly name?: string | (() => string) | undefined;
+      readonly trueValue?: string | number | (() => string | number) | undefined;
+      readonly falseValue?: string | number | (() => string | number) | undefined;
+      readonly trueLabel?: string | number | (() => string | number) | undefined;
+      readonly falseLabel?: string | number | (() => string | number) | undefined;
+      readonly id?: string | (() => string) | undefined;
+      readonly border?: boolean | (() => boolean) | undefined;
+      readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+      readonly tabindex?: string | number | (() => string | number) | undefined;
+      readonly validateEvent?: boolean | (() => boolean) | undefined;
+      readonly ariaLabel?: string | (() => string) | undefined;
+      readonly ariaControls?: string | (() => string) | undefined;
+    }) => void;
+  } & {
+    CheckboxButton: typeof _default$1;
+    CheckboxGroup: typeof _default$2;
+  };
+}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { TableHeader, TableHeaderProps, _default as default };

web/node_modules/element-plus/lib/components/table/src/table-header/index.js

@@ -0,0 +1,181 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../../../_virtual/_rolldown/runtime.js");
+const require_index = require("../../../../hooks/use-locale/index.js");
+const require_index$1 = require("../../../../hooks/use-namespace/index.js");
+const require_index$2 = require("../../../checkbox/index.js");
+const require_filter_panel = require("../filter-panel.js");
+const require_layout_observer = require("../layout-observer.js");
+const require_tokens = require("../tokens.js");
+const require_event_helper = require("./event-helper.js");
+const require_style_helper = require("./style.helper.js");
+const require_utils_helper = require("./utils-helper.js");
+let vue = require("vue");
+//#region ../../packages/components/table/src/table-header/index.ts
+var table_header_default = (0, vue.defineComponent)({
+	name: "ElTableHeader",
+	components: { ElCheckbox: require_index$2.ElCheckbox },
+	props: {
+		fixed: {
+			type: String,
+			default: ""
+		},
+		store: {
+			required: true,
+			type: Object
+		},
+		border: Boolean,
+		defaultSort: {
+			type: Object,
+			default: () => {
+				return {
+					prop: "",
+					order: ""
+				};
+			}
+		},
+		appendFilterPanelTo: { type: String },
+		allowDragLastColumn: { type: Boolean }
+	},
+	setup(props, { emit }) {
+		const instance = (0, vue.getCurrentInstance)();
+		const parent = (0, vue.inject)(require_tokens.TABLE_INJECTION_KEY);
+		const ns = require_index$1.useNamespace("table");
+		const filterPanels = (0, vue.ref)({});
+		const { onColumnsChange, onScrollableChange } = require_layout_observer.default(parent);
+		const isTableLayoutAuto = parent?.props.tableLayout === "auto";
+		const saveIndexSelection = (0, vue.reactive)(/* @__PURE__ */ new Map());
+		const theadRef = (0, vue.ref)();
+		let delayId;
+		const updateFixedColumnStyle = () => {
+			delayId = setTimeout(() => {
+				if (saveIndexSelection.size > 0) {
+					saveIndexSelection.forEach((column, key) => {
+						const el = theadRef.value.querySelector(`.${key.replace(/\s/g, ".")}`);
+						if (el) column.width = el.getBoundingClientRect().width || column.width;
+					});
+					saveIndexSelection.clear();
+				}
+			});
+		};
+		(0, vue.watch)(saveIndexSelection, updateFixedColumnStyle);
+		(0, vue.onBeforeUnmount)(() => {
+			if (delayId) {
+				clearTimeout(delayId);
+				delayId = void 0;
+			}
+		});
+		(0, vue.onMounted)(async () => {
+			await (0, vue.nextTick)();
+			await (0, vue.nextTick)();
+			const { prop, order } = props.defaultSort;
+			parent?.store.commit("sort", {
+				prop,
+				order,
+				init: true
+			});
+			updateFixedColumnStyle();
+		});
+		const { handleHeaderClick, handleHeaderContextMenu, handleMouseDown, handleMouseMove, handleMouseOut, handleSortClick, handleFilterClick } = require_event_helper.default(props, emit);
+		const { getHeaderRowStyle, getHeaderRowClass, getHeaderCellStyle, getHeaderCellClass } = require_style_helper.default(props);
+		const { isGroup, toggleAllSelection, columnRows } = require_utils_helper.default(props);
+		const { t } = require_index.useLocale();
+		instance.state = {
+			onColumnsChange,
+			onScrollableChange
+		};
+		instance.filterPanels = filterPanels;
+		return {
+			ns,
+			t,
+			filterPanels,
+			onColumnsChange,
+			onScrollableChange,
+			columnRows,
+			getHeaderRowClass,
+			getHeaderRowStyle,
+			getHeaderCellClass,
+			getHeaderCellStyle,
+			handleHeaderClick,
+			handleHeaderContextMenu,
+			handleMouseDown,
+			handleMouseMove,
+			handleMouseOut,
+			handleSortClick,
+			handleFilterClick,
+			isGroup,
+			toggleAllSelection,
+			saveIndexSelection,
+			isTableLayoutAuto,
+			theadRef,
+			updateFixedColumnStyle
+		};
+	},
+	render() {
+		const { ns, t, isGroup, columnRows, getHeaderCellStyle, getHeaderCellClass, getHeaderRowClass, getHeaderRowStyle, handleHeaderClick, handleHeaderContextMenu, handleMouseDown, handleMouseMove, handleSortClick, handleMouseOut, store, $parent, saveIndexSelection, isTableLayoutAuto } = this;
+		let rowSpan = 1;
+		return (0, vue.h)("thead", {
+			ref: "theadRef",
+			class: ns.is("group", isGroup)
+		}, columnRows.map((subColumns, rowIndex) => (0, vue.h)("tr", {
+			class: getHeaderRowClass(rowIndex),
+			key: rowIndex,
+			style: getHeaderRowStyle(rowIndex)
+		}, subColumns.map((column, cellIndex) => {
+			if (column.rowSpan > rowSpan) rowSpan = column.rowSpan;
+			const _class = getHeaderCellClass(rowIndex, cellIndex, subColumns, column);
+			if (isTableLayoutAuto && column.fixed) saveIndexSelection.set(_class, column);
+			return (0, vue.h)("th", {
+				class: _class,
+				colspan: column.colSpan,
+				key: `${column.id}-thead`,
+				rowspan: column.rowSpan,
+				scope: column.colSpan > 1 ? "colgroup" : "col",
+				ariaSort: column.sortable ? column.order : void 0,
+				style: getHeaderCellStyle(rowIndex, cellIndex, subColumns, column),
+				onClick: ($event) => {
+					if ($event.currentTarget?.classList.contains("noclick")) return;
+					handleHeaderClick($event, column);
+				},
+				onContextmenu: ($event) => handleHeaderContextMenu($event, column),
+				onMousedown: ($event) => handleMouseDown($event, column),
+				onMousemove: ($event) => handleMouseMove($event, column),
+				onMouseout: handleMouseOut
+			}, [(0, vue.h)("div", { class: ["cell", column.filteredValue && column.filteredValue.length > 0 ? "highlight" : ""] }, [
+				column.renderHeader ? column.renderHeader({
+					column,
+					$index: cellIndex,
+					store,
+					_self: $parent
+				}) : column.label,
+				column.sortable && (0, vue.h)("button", {
+					type: "button",
+					class: "caret-wrapper",
+					"aria-label": t("el.table.sortLabel", { column: column.label || "" }),
+					onClick: ($event) => handleSortClick($event, column)
+				}, [(0, vue.h)("i", {
+					onClick: ($event) => handleSortClick($event, column, "ascending"),
+					class: "sort-caret ascending"
+				}), (0, vue.h)("i", {
+					onClick: ($event) => handleSortClick($event, column, "descending"),
+					class: "sort-caret descending"
+				})]),
+				column.filterable && (0, vue.h)(require_filter_panel.default, {
+					store,
+					placement: column.filterPlacement || "bottom-start",
+					appendTo: $parent?.appendFilterPanelTo,
+					column,
+					upDataColumn: (key, value) => {
+						column[key] = value;
+					}
+				}, { "filter-icon": () => column.renderFilterIcon ? column.renderFilterIcon({ filterOpened: column.filterOpened }) : null })
+			])]);
+		}))));
+	}
+});
+//#endregion
+exports.default = table_header_default;
+
+//# sourceMappingURL=index.js.map

web/node_modules/element-plus/lib/components/table/src/table-header/style.helper.d.ts

@@ -0,0 +1,14 @@
+import { TableColumnCtx } from "../table-column/defaults.js";
+import { TableHeaderProps } from "./index.js";
+import { DefaultRow } from "../table/defaults.js";
+import * as _$vue from "vue";
+
+//#region ../../packages/components/table/src/table-header/style.helper.d.ts
+declare function useStyle<T extends DefaultRow>(props: TableHeaderProps<T>): {
+  getHeaderRowStyle: (rowIndex: number) => any;
+  getHeaderRowClass: (rowIndex: number) => string;
+  getHeaderCellStyle: (rowIndex: number, columnIndex: number, row: T, column: TableColumnCtx<T>) => _$vue.CSSProperties;
+  getHeaderCellClass: (rowIndex: number, columnIndex: number, row: T, column: TableColumnCtx<T>) => string;
+};
+//#endregion
+export { useStyle as default };

web/node_modules/element-plus/lib/components/table/src/table-header/style.helper.js

@@ -0,0 +1,73 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../../../_virtual/_rolldown/runtime.js");
+const require_index = require("../../../../hooks/use-namespace/index.js");
+const require_util = require("../util.js");
+const require_tokens = require("../tokens.js");
+let vue = require("vue");
+let _vue_shared = require("@vue/shared");
+//#region ../../packages/components/table/src/table-header/style.helper.ts
+function useStyle(props) {
+	const parent = (0, vue.inject)(require_tokens.TABLE_INJECTION_KEY);
+	const ns = require_index.useNamespace("table");
+	const getHeaderRowStyle = (rowIndex) => {
+		const headerRowStyle = parent?.props.headerRowStyle;
+		if ((0, _vue_shared.isFunction)(headerRowStyle)) return headerRowStyle.call(null, { rowIndex });
+		return headerRowStyle;
+	};
+	const getHeaderRowClass = (rowIndex) => {
+		const classes = [];
+		const headerRowClassName = parent?.props.headerRowClassName;
+		if ((0, _vue_shared.isString)(headerRowClassName)) classes.push(headerRowClassName);
+		else if ((0, _vue_shared.isFunction)(headerRowClassName)) classes.push(headerRowClassName.call(null, { rowIndex }));
+		return classes.join(" ");
+	};
+	const getHeaderCellStyle = (rowIndex, columnIndex, row, column) => {
+		let headerCellStyles = parent?.props.headerCellStyle ?? {};
+		if ((0, _vue_shared.isFunction)(headerCellStyles)) headerCellStyles = headerCellStyles.call(null, {
+			rowIndex,
+			columnIndex,
+			row,
+			column
+		});
+		const fixedStyle = require_util.getFixedColumnOffset(columnIndex, column.fixed, props.store, row);
+		require_util.ensurePosition(fixedStyle, "left");
+		require_util.ensurePosition(fixedStyle, "right");
+		return Object.assign({}, headerCellStyles, fixedStyle);
+	};
+	const getHeaderCellClass = (rowIndex, columnIndex, row, column) => {
+		const fixedClasses = require_util.getFixedColumnsClass(ns.b(), columnIndex, column.fixed, props.store, row);
+		const classes = [
+			column.id,
+			column.order,
+			column.headerAlign,
+			column.className,
+			column.labelClassName,
+			...fixedClasses
+		];
+		if (!column.children) classes.push("is-leaf");
+		if (column.sortable) classes.push("is-sortable");
+		const headerCellClassName = parent?.props.headerCellClassName;
+		if ((0, _vue_shared.isString)(headerCellClassName)) classes.push(headerCellClassName);
+		else if ((0, _vue_shared.isFunction)(headerCellClassName)) classes.push(headerCellClassName.call(null, {
+			rowIndex,
+			columnIndex,
+			row,
+			column
+		}));
+		classes.push(ns.e("cell"));
+		return classes.filter((className) => Boolean(className)).join(" ");
+	};
+	return {
+		getHeaderRowStyle,
+		getHeaderRowClass,
+		getHeaderCellStyle,
+		getHeaderCellClass
+	};
+}
+//#endregion
+exports.default = useStyle;
+
+//# sourceMappingURL=style.helper.js.map

web/node_modules/element-plus/lib/components/table/src/table-header/style.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.helper.js","names":["TABLE_INJECTION_KEY","useNamespace","getFixedColumnOffset","getFixedColumnsClass"],"sources":["../../../../../../../packages/components/table/src/table-header/style.helper.ts"],"sourcesContent":["import { inject } from 'vue'\nimport { useNamespace } from '@element-plus/hooks'\nimport { isFunction, isString } from '@element-plus/utils'\nimport {\n  ensurePosition,\n  getFixedColumnOffset,\n  getFixedColumnsClass,\n} from '../util'\nimport { TABLE_INJECTION_KEY } from '../tokens'\n\nimport type { TableColumnCtx } from '../table-column/defaults'\nimport type { DefaultRow } from '../table/defaults'\nimport type { TableHeaderProps } from '.'\n\nfunction useStyle<T extends DefaultRow>(props: TableHeaderProps<T>) {\n  const parent = inject(TABLE_INJECTION_KEY)\n  const ns = useNamespace('table')\n\n  const getHeaderRowStyle = (rowIndex: number) => {\n    const headerRowStyle = parent?.props.headerRowStyle\n    if (isFunction(headerRowStyle)) {\n      return headerRowStyle.call(null, { rowIndex })\n    }\n    return headerRowStyle\n  }\n\n  const getHeaderRowClass = (rowIndex: number): string => {\n    const classes: string[] = []\n    const headerRowClassName = parent?.props.headerRowClassName\n    if (isString(headerRowClassName)) {\n      classes.push(headerRowClassName)\n    } else if (isFunction(headerRowClassName)) {\n      classes.push(headerRowClassName.call(null, { rowIndex }))\n    }\n\n    return classes.join(' ')\n  }\n\n  const getHeaderCellStyle = (\n    rowIndex: number,\n    columnIndex: number,\n    row: T,\n    column: TableColumnCtx<T>\n  ) => {\n    let headerCellStyles = parent?.props.headerCellStyle ?? {}\n    if (isFunction(headerCellStyles)) {\n      headerCellStyles = headerCellStyles.call(null, {\n        rowIndex,\n        columnIndex,\n        row,\n        column,\n      })\n    }\n    const fixedStyle = getFixedColumnOffset<T>(\n      columnIndex,\n      column.fixed,\n      props.store,\n      row as unknown as TableColumnCtx<T>[]\n    )\n    ensurePosition(fixedStyle, 'left')\n    ensurePosition(fixedStyle, 'right')\n    return Object.assign({}, headerCellStyles, fixedStyle)\n  }\n\n  const getHeaderCellClass = (\n    rowIndex: number,\n    columnIndex: number,\n    row: T,\n    column: TableColumnCtx<T>\n  ) => {\n    const fixedClasses = getFixedColumnsClass<T>(\n      ns.b(),\n      columnIndex,\n      column.fixed,\n      props.store,\n      row as unknown as TableColumnCtx<T>[]\n    )\n    const classes = [\n      column.id,\n      column.order,\n      column.headerAlign,\n      column.className,\n      column.labelClassName,\n      ...fixedClasses,\n    ]\n\n    if (!column.children) {\n      classes.push('is-leaf')\n    }\n\n    if (column.sortable) {\n      classes.push('is-sortable')\n    }\n\n    const headerCellClassName = parent?.props.headerCellClassName\n    if (isString(headerCellClassName)) {\n      classes.push(headerCellClassName)\n    } else if (isFunction(headerCellClassName)) {\n      classes.push(\n        headerCellClassName.call(null, {\n          rowIndex,\n          columnIndex,\n          row,\n          column,\n        })\n      )\n    }\n\n    classes.push(ns.e('cell'))\n\n    return classes.filter((className) => Boolean(className)).join(' ')\n  }\n\n  return {\n    getHeaderRowStyle,\n    getHeaderRowClass,\n    getHeaderCellStyle,\n    getHeaderCellClass,\n  }\n}\n\nexport default useStyle\n"],"mappings":";;;;;;;;;;;AAcA,SAAS,SAA+B,OAA4B;CAClE,MAAM,UAAA,GAAA,IAAA,QAAgBA,eAAAA,oBAAoB;CAC1C,MAAM,KAAKC,cAAAA,aAAa,QAAQ;CAEhC,MAAM,qBAAqB,aAAqB;EAC9C,MAAM,iBAAiB,QAAQ,MAAM;EACrC,KAAA,GAAA,YAAA,YAAe,eAAe,EAC5B,OAAO,eAAe,KAAK,MAAM,EAAE,UAAU,CAAC;EAEhD,OAAO;;CAGT,MAAM,qBAAqB,aAA6B;EACtD,MAAM,UAAoB,EAAE;EAC5B,MAAM,qBAAqB,QAAQ,MAAM;EACzC,KAAA,GAAA,YAAA,UAAa,mBAAmB,EAC9B,QAAQ,KAAK,mBAAmB;OAC3B,KAAA,GAAA,YAAA,YAAe,mBAAmB,EACvC,QAAQ,KAAK,mBAAmB,KAAK,MAAM,EAAE,UAAU,CAAC,CAAC;EAG3D,OAAO,QAAQ,KAAK,IAAI;;CAG1B,MAAM,sBACJ,UACA,aACA,KACA,WACG;EACH,IAAI,mBAAmB,QAAQ,MAAM,mBAAmB,EAAE;EAC1D,KAAA,GAAA,YAAA,YAAe,iBAAiB,EAC9B,mBAAmB,iBAAiB,KAAK,MAAM;GAC7C;GACA;GACA;GACA;GACD,CAAC;EAEJ,MAAM,aAAaC,aAAAA,qBACjB,aACA,OAAO,OACP,MAAM,OACN,IACD;EACD,aAAA,eAAe,YAAY,OAAO;EAClC,aAAA,eAAe,YAAY,QAAQ;EACnC,OAAO,OAAO,OAAO,EAAE,EAAE,kBAAkB,WAAW;;CAGxD,MAAM,sBACJ,UACA,aACA,KACA,WACG;EACH,MAAM,eAAeC,aAAAA,qBACnB,GAAG,GAAG,EACN,aACA,OAAO,OACP,MAAM,OACN,IACD;EACD,MAAM,UAAU;GACd,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GACP,GAAG;GACJ;EAED,IAAI,CAAC,OAAO,UACV,QAAQ,KAAK,UAAU;EAGzB,IAAI,OAAO,UACT,QAAQ,KAAK,cAAc;EAG7B,MAAM,sBAAsB,QAAQ,MAAM;EAC1C,KAAA,GAAA,YAAA,UAAa,oBAAoB,EAC/B,QAAQ,KAAK,oBAAoB;OAC5B,KAAA,GAAA,YAAA,YAAe,oBAAoB,EACxC,QAAQ,KACN,oBAAoB,KAAK,MAAM;GAC7B;GACA;GACA;GACA;GACD,CAAC,CACH;EAGH,QAAQ,KAAK,GAAG,EAAE,OAAO,CAAC;EAE1B,OAAO,QAAQ,QAAQ,cAAc,QAAQ,UAAU,CAAC,CAAC,KAAK,IAAI;;CAGpE,OAAO;EACL;EACA;EACA;EACA;EACD"}

web/node_modules/element-plus/lib/components/table/src/table-header/utils-helper.d.ts

@@ -0,0 +1,14 @@
+import { TableColumnCtx } from "../table-column/defaults.js";
+import { TableHeaderProps } from "./index.js";
+import { DefaultRow } from "../table/defaults.js";
+import * as _$vue from "vue";
+
+//#region ../../packages/components/table/src/table-header/utils-helper.d.ts
+declare const convertToRows: <T extends DefaultRow>(originColumns: TableColumnCtx<T>[]) => TableColumnCtx<T>[][];
+declare function useUtils<T extends DefaultRow>(props: TableHeaderProps<T>): {
+  isGroup: _$vue.ComputedRef<boolean>;
+  toggleAllSelection: (event: Event) => void;
+  columnRows: _$vue.ComputedRef<TableColumnCtx<T>[][]>;
+};
+//#endregion
+export { convertToRows, useUtils as default };

web/node_modules/element-plus/lib/components/table/src/table-header/utils-helper.js

@@ -0,0 +1,75 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../../../_virtual/_rolldown/runtime.js");
+const require_tokens = require("../tokens.js");
+let vue = require("vue");
+//#region ../../packages/components/table/src/table-header/utils-helper.ts
+const getAllColumns = (columns) => {
+	const result = [];
+	columns.forEach((column) => {
+		if (column.children) {
+			result.push(column);
+			result.push.apply(result, getAllColumns(column.children));
+		} else result.push(column);
+	});
+	return result;
+};
+const convertToRows = (originColumns) => {
+	let maxLevel = 1;
+	const traverse = (column, parent) => {
+		if (parent) {
+			column.level = parent.level + 1;
+			if (maxLevel < column.level) maxLevel = column.level;
+		}
+		if (column.children) {
+			let colSpan = 0;
+			column.children.forEach((subColumn) => {
+				traverse(subColumn, column);
+				colSpan += subColumn.colSpan;
+			});
+			column.colSpan = colSpan;
+		} else column.colSpan = 1;
+	};
+	originColumns.forEach((column) => {
+		column.level = 1;
+		traverse(column, void 0);
+	});
+	const rows = [];
+	for (let i = 0; i < maxLevel; i++) rows.push([]);
+	getAllColumns(originColumns).forEach((column) => {
+		if (!column.children) column.rowSpan = maxLevel - column.level + 1;
+		else {
+			column.rowSpan = 1;
+			column.children.forEach((col) => col.isSubColumn = true);
+		}
+		rows[column.level - 1].push(column);
+	});
+	return rows;
+};
+function useUtils(props) {
+	const parent = (0, vue.inject)(require_tokens.TABLE_INJECTION_KEY);
+	const columnRows = (0, vue.computed)(() => {
+		return convertToRows(props.store.states.originColumns.value);
+	});
+	const isGroup = (0, vue.computed)(() => {
+		const result = columnRows.value.length > 1;
+		if (result && parent) parent.state.isGroup.value = true;
+		return result;
+	});
+	const toggleAllSelection = (event) => {
+		event.stopPropagation();
+		parent?.store.commit("toggleAllSelection");
+	};
+	return {
+		isGroup,
+		toggleAllSelection,
+		columnRows
+	};
+}
+//#endregion
+exports.convertToRows = convertToRows;
+exports.default = useUtils;
+
+//# sourceMappingURL=utils-helper.js.map

web/node_modules/element-plus/lib/components/table/src/table-header/utils-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-helper.js","names":["TABLE_INJECTION_KEY"],"sources":["../../../../../../../packages/components/table/src/table-header/utils-helper.ts"],"sourcesContent":["import { computed, inject } from 'vue'\nimport { TABLE_INJECTION_KEY } from '../tokens'\n\nimport type { DefaultRow } from '../table/defaults'\nimport type { TableColumnCtx } from '../table-column/defaults'\nimport type { TableHeaderProps } from '.'\n\nconst getAllColumns = <T extends DefaultRow>(\n  columns: TableColumnCtx<T>[]\n): TableColumnCtx<T>[] => {\n  const result: TableColumnCtx<T>[] = []\n  columns.forEach((column) => {\n    if (column.children) {\n      result.push(column)\n      // eslint-disable-next-line prefer-spread\n      result.push.apply(result, getAllColumns(column.children))\n    } else {\n      result.push(column)\n    }\n  })\n  return result\n}\n\nexport const convertToRows = <T extends DefaultRow>(\n  originColumns: TableColumnCtx<T>[]\n): TableColumnCtx<T>[][] => {\n  let maxLevel = 1\n  const traverse = (column: TableColumnCtx<T>, parent?: TableColumnCtx<T>) => {\n    if (parent) {\n      column.level = parent.level + 1\n      if (maxLevel < column.level) {\n        maxLevel = column.level\n      }\n    }\n    if (column.children) {\n      let colSpan = 0\n      column.children.forEach((subColumn) => {\n        traverse(subColumn, column)\n        colSpan += subColumn.colSpan\n      })\n      column.colSpan = colSpan\n    } else {\n      column.colSpan = 1\n    }\n  }\n\n  originColumns.forEach((column) => {\n    column.level = 1\n    traverse(column, undefined)\n  })\n\n  const rows: TableColumnCtx<T>[][] = []\n  for (let i = 0; i < maxLevel; i++) {\n    rows.push([])\n  }\n\n  const allColumns: TableColumnCtx<T>[] = getAllColumns(originColumns)\n\n  allColumns.forEach((column) => {\n    if (!column.children) {\n      column.rowSpan = maxLevel - column.level + 1\n    } else {\n      column.rowSpan = 1\n      column.children.forEach((col) => (col.isSubColumn = true))\n    }\n    rows[column.level - 1].push(column)\n  })\n\n  return rows\n}\n\nfunction useUtils<T extends DefaultRow>(props: TableHeaderProps<T>) {\n  const parent = inject(TABLE_INJECTION_KEY)\n  const columnRows = computed(() => {\n    return convertToRows(props.store.states.originColumns.value)\n  })\n  const isGroup = computed(() => {\n    const result = columnRows.value.length > 1\n    if (result && parent) {\n      parent.state.isGroup.value = true\n    }\n    return result\n  })\n  const toggleAllSelection = (event: Event) => {\n    event.stopPropagation()\n    parent?.store.commit('toggleAllSelection')\n  }\n  return {\n    isGroup,\n    toggleAllSelection,\n    columnRows,\n  }\n}\n\nexport default useUtils\n"],"mappings":";;;;;;;;AAOA,MAAM,iBACJ,YACwB;CACxB,MAAM,SAA8B,EAAE;CACtC,QAAQ,SAAS,WAAW;EAC1B,IAAI,OAAO,UAAU;GACnB,OAAO,KAAK,OAAO;GAEnB,OAAO,KAAK,MAAM,QAAQ,cAAc,OAAO,SAAS,CAAC;SAEzD,OAAO,KAAK,OAAO;GAErB;CACF,OAAO;;AAGT,MAAa,iBACX,kBAC0B;CAC1B,IAAI,WAAW;CACf,MAAM,YAAY,QAA2B,WAA+B;EAC1E,IAAI,QAAQ;GACV,OAAO,QAAQ,OAAO,QAAQ;GAC9B,IAAI,WAAW,OAAO,OACpB,WAAW,OAAO;;EAGtB,IAAI,OAAO,UAAU;GACnB,IAAI,UAAU;GACd,OAAO,SAAS,SAAS,cAAc;IACrC,SAAS,WAAW,OAAO;IAC3B,WAAW,UAAU;KACrB;GACF,OAAO,UAAU;SAEjB,OAAO,UAAU;;CAIrB,cAAc,SAAS,WAAW;EAChC,OAAO,QAAQ;EACf,SAAS,QAAQ,KAAA,EAAU;GAC3B;CAEF,MAAM,OAA8B,EAAE;CACtC,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,KAC5B,KAAK,KAAK,EAAE,CAAC;CAKf,cAFsD,cAE5C,CAAC,SAAS,WAAW;EAC7B,IAAI,CAAC,OAAO,UACV,OAAO,UAAU,WAAW,OAAO,QAAQ;OACtC;GACL,OAAO,UAAU;GACjB,OAAO,SAAS,SAAS,QAAS,IAAI,cAAc,KAAM;;EAE5D,KAAK,OAAO,QAAQ,GAAG,KAAK,OAAO;GACnC;CAEF,OAAO;;AAGT,SAAS,SAA+B,OAA4B;CAClE,MAAM,UAAA,GAAA,IAAA,QAAgBA,eAAAA,oBAAoB;CAC1C,MAAM,cAAA,GAAA,IAAA,gBAA4B;EAChC,OAAO,cAAc,MAAM,MAAM,OAAO,cAAc,MAAM;GAC5D;CACF,MAAM,WAAA,GAAA,IAAA,gBAAyB;EAC7B,MAAM,SAAS,WAAW,MAAM,SAAS;EACzC,IAAI,UAAU,QACZ,OAAO,MAAM,QAAQ,QAAQ;EAE/B,OAAO;GACP;CACF,MAAM,sBAAsB,UAAiB;EAC3C,MAAM,iBAAiB;EACvB,QAAQ,MAAM,OAAO,qBAAqB;;CAE5C,OAAO;EACL;EACA;EACA;EACD"}