完全跑通1.0版本

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/index.d.ts

@@ -0,0 +1,8 @@
+import { Alignment } from "../../../virtual-list/src/types.js";
+import { ScrollPos, useScrollbar } from "./use-scrollbar.js";
+import { UseColumnsReturn, useColumns } from "./use-columns.js";
+import { UseRowReturn, useRow } from "./use-row.js";
+import { UseDataReturn, useData } from "./use-data.js";
+import { UseStyleReturn, useStyles } from "./use-styles.js";
+import { useAutoResize } from "./use-auto-resize.js";
+export { ScrollPos, Alignment as ScrollStrategy, UseColumnsReturn, UseDataReturn, UseRowReturn, UseStyleReturn, useAutoResize, useColumns, useData, useRow, useScrollbar, useStyles };

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/index.js

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_use_columns = require("./use-columns.js");
+const require_use_scrollbar = require("./use-scrollbar.js");
+const require_use_row = require("./use-row.js");
+const require_use_data = require("./use-data.js");
+const require_use_styles = require("./use-styles.js");
+const require_use_auto_resize = require("./use-auto-resize.js");
+exports.useAutoResize = require_use_auto_resize.useAutoResize;
+exports.useColumns = require_use_columns.useColumns;
+exports.useData = require_use_data.useData;
+exports.useRow = require_use_row.useRow;
+exports.useScrollbar = require_use_scrollbar.useScrollbar;
+exports.useStyles = require_use_styles.useStyles;

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-auto-resize.d.ts

@@ -0,0 +1,11 @@
+import { AutoResizerProps } from "../auto-resizer.js";
+import * as _$vue from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-auto-resize.d.ts
+declare const useAutoResize: (props: AutoResizerProps) => {
+  sizer: _$vue.Ref<HTMLElement | undefined, HTMLElement | undefined>;
+  width: _$vue.Ref<number, number>;
+  height: _$vue.Ref<number, number>;
+};
+//#endregion
+export { useAutoResize };

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-auto-resize.js

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../../_virtual/_rolldown/runtime.js");
+let _vueuse_core = require("@vueuse/core");
+let vue = require("vue");
+//#region ../../packages/components/table-v2/src/composables/use-auto-resize.ts
+const useAutoResize = (props) => {
+	const sizer = (0, vue.ref)();
+	const width$ = (0, vue.ref)(0);
+	const height$ = (0, vue.ref)(0);
+	let resizerStopper;
+	(0, vue.onMounted)(() => {
+		resizerStopper = (0, _vueuse_core.useResizeObserver)(sizer, ([entry]) => {
+			const { width, height } = entry.contentRect;
+			const { paddingLeft, paddingRight, paddingTop, paddingBottom } = getComputedStyle(entry.target);
+			const left = Number.parseInt(paddingLeft) || 0;
+			const right = Number.parseInt(paddingRight) || 0;
+			const top = Number.parseInt(paddingTop) || 0;
+			const bottom = Number.parseInt(paddingBottom) || 0;
+			width$.value = width - left - right;
+			height$.value = height - top - bottom;
+		}).stop;
+	});
+	(0, vue.onBeforeUnmount)(() => {
+		resizerStopper?.();
+	});
+	(0, vue.watch)([width$, height$], ([width, height]) => {
+		props.onResize?.({
+			width,
+			height
+		});
+	});
+	return {
+		sizer,
+		width: width$,
+		height: height$
+	};
+};
+//#endregion
+exports.useAutoResize = useAutoResize;
+
+//# sourceMappingURL=use-auto-resize.js.map

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-auto-resize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-auto-resize.js","names":[],"sources":["../../../../../../../packages/components/table-v2/src/composables/use-auto-resize.ts"],"sourcesContent":["import { onBeforeUnmount, onMounted, ref, watch } from 'vue'\nimport { useResizeObserver } from '@vueuse/core'\n\nimport type { AutoResizerProps } from '../auto-resizer'\n\nconst useAutoResize = (props: AutoResizerProps) => {\n  const sizer = ref<HTMLElement>()\n  const width$ = ref(0)\n  const height$ = ref(0)\n\n  let resizerStopper: ReturnType<typeof useResizeObserver>['stop']\n  onMounted(() => {\n    resizerStopper = useResizeObserver(sizer, ([entry]) => {\n      const { width, height } = entry.contentRect\n      const { paddingLeft, paddingRight, paddingTop, paddingBottom } =\n        getComputedStyle(entry.target)\n\n      const left = Number.parseInt(paddingLeft) || 0\n      const right = Number.parseInt(paddingRight) || 0\n      const top = Number.parseInt(paddingTop) || 0\n      const bottom = Number.parseInt(paddingBottom) || 0\n\n      width$.value = width - left - right\n      height$.value = height - top - bottom\n    }).stop\n  })\n\n  onBeforeUnmount(() => {\n    resizerStopper?.()\n  })\n\n  watch([width$, height$], ([width, height]) => {\n    props.onResize?.({\n      width,\n      height,\n    })\n  })\n\n  return {\n    sizer,\n    width: width$,\n    height: height$,\n  }\n}\n\nexport { useAutoResize }\n"],"mappings":";;;;;AAKA,MAAM,iBAAiB,UAA4B;CACjD,MAAM,SAAA,GAAA,IAAA,MAA0B;CAChC,MAAM,UAAA,GAAA,IAAA,KAAa,EAAE;CACrB,MAAM,WAAA,GAAA,IAAA,KAAc,EAAE;CAEtB,IAAI;CACJ,CAAA,GAAA,IAAA,iBAAgB;EACd,kBAAA,GAAA,aAAA,mBAAmC,QAAQ,CAAC,WAAW;GACrD,MAAM,EAAE,OAAO,WAAW,MAAM;GAChC,MAAM,EAAE,aAAa,cAAc,YAAY,kBAC7C,iBAAiB,MAAM,OAAO;GAEhC,MAAM,OAAO,OAAO,SAAS,YAAY,IAAI;GAC7C,MAAM,QAAQ,OAAO,SAAS,aAAa,IAAI;GAC/C,MAAM,MAAM,OAAO,SAAS,WAAW,IAAI;GAC3C,MAAM,SAAS,OAAO,SAAS,cAAc,IAAI;GAEjD,OAAO,QAAQ,QAAQ,OAAO;GAC9B,QAAQ,QAAQ,SAAS,MAAM;IAC/B,CAAC;GACH;CAEF,CAAA,GAAA,IAAA,uBAAsB;EACpB,kBAAkB;GAClB;CAEF,CAAA,GAAA,IAAA,OAAM,CAAC,QAAQ,QAAQ,GAAG,CAAC,OAAO,YAAY;EAC5C,MAAM,WAAW;GACf;GACA;GACD,CAAC;GACF;CAEF,OAAO;EACL;EACA,OAAO;EACP,QAAQ;EACT"}

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-columns.d.ts

@@ -0,0 +1,132 @@
+import { Alignment, AnyColumns, CellRenderer, ClassNameGetter, Column, FixedDirection, HeaderCellRenderer, HeaderClassGetter, KeyType } from "../types.js";
+import { TableV2Props } from "../table.js";
+import * as _$vue from "vue";
+import { CSSProperties, Ref } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-columns.d.ts
+declare function useColumns(props: TableV2Props, columns: Ref<AnyColumns>, fixed: Ref<boolean>): {
+  columns: _$vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  columnsStyles: _$vue.ComputedRef<Record<KeyType, CSSProperties>>;
+  columnsTotalWidth: _$vue.ComputedRef<number>;
+  fixedColumnsOnLeft: _$vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  fixedColumnsOnRight: _$vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  hasFixedColumns: _$vue.ComputedRef<number>;
+  mainColumns: _$vue.ComputedRef<AnyColumns>;
+  normalColumns: _$vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  visibleColumns: _$vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  getColumn: (key: KeyType) => {
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  } | undefined;
+  getColumnStyle: (key: KeyType) => CSSProperties;
+  updateColumnWidth: (column: Column<any>, width: number) => void;
+  onColumnSorted: (e: MouseEvent) => void;
+};
+type UseColumnsReturn = ReturnType<typeof useColumns>;
+//#endregion
+export { UseColumnsReturn, useColumns };

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-columns.js

@@ -0,0 +1,92 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../../_virtual/_rolldown/runtime.js");
+const require_constants = require("../constants.js");
+const require_private = require("../private.js");
+const require_utils = require("./utils.js");
+let vue = require("vue");
+let _vue_shared = require("@vue/shared");
+//#region ../../packages/components/table-v2/src/composables/use-columns.ts
+function useColumns(props, columns, fixed) {
+	const _columns = (0, vue.computed)(() => (0, vue.unref)(columns).map((column, index) => ({
+		...column,
+		key: column.key ?? column.dataKey ?? index
+	})));
+	const visibleColumns = (0, vue.computed)(() => {
+		return (0, vue.unref)(_columns).filter((column) => !column.hidden);
+	});
+	const fixedColumnsOnLeft = (0, vue.computed)(() => (0, vue.unref)(visibleColumns).filter((column) => column.fixed === "left" || column.fixed === true));
+	const fixedColumnsOnRight = (0, vue.computed)(() => (0, vue.unref)(visibleColumns).filter((column) => column.fixed === "right"));
+	const normalColumns = (0, vue.computed)(() => (0, vue.unref)(visibleColumns).filter((column) => !column.fixed));
+	const mainColumns = (0, vue.computed)(() => {
+		const ret = [];
+		(0, vue.unref)(fixedColumnsOnLeft).forEach((column) => {
+			ret.push({
+				...column,
+				placeholderSign: require_private.placeholderSign
+			});
+		});
+		(0, vue.unref)(normalColumns).forEach((column) => {
+			ret.push(column);
+		});
+		(0, vue.unref)(fixedColumnsOnRight).forEach((column) => {
+			ret.push({
+				...column,
+				placeholderSign: require_private.placeholderSign
+			});
+		});
+		return ret;
+	});
+	const hasFixedColumns = (0, vue.computed)(() => {
+		return (0, vue.unref)(fixedColumnsOnLeft).length || (0, vue.unref)(fixedColumnsOnRight).length;
+	});
+	const columnsStyles = (0, vue.computed)(() => {
+		return (0, vue.unref)(_columns).reduce((style, column) => {
+			style[column.key] = require_utils.calcColumnStyle(column, (0, vue.unref)(fixed), props.fixed);
+			return style;
+		}, {});
+	});
+	const columnsTotalWidth = (0, vue.computed)(() => {
+		return (0, vue.unref)(visibleColumns).reduce((width, column) => width + column.width, 0);
+	});
+	const getColumn = (key) => {
+		return (0, vue.unref)(_columns).find((column) => column.key === key);
+	};
+	const getColumnStyle = (key) => {
+		return (0, vue.unref)(columnsStyles)[key];
+	};
+	const updateColumnWidth = (column, width) => {
+		column.width = width;
+	};
+	function onColumnSorted(e) {
+		const { key } = e.currentTarget.dataset;
+		if (!key) return;
+		const { sortState, sortBy } = props;
+		let order = "asc";
+		if ((0, _vue_shared.isObject)(sortState)) order = require_constants.oppositeOrderMap[sortState[key]];
+		else order = require_constants.oppositeOrderMap[sortBy.order];
+		props.onColumnSort?.({
+			column: getColumn(key),
+			key,
+			order
+		});
+	}
+	return {
+		columns: _columns,
+		columnsStyles,
+		columnsTotalWidth,
+		fixedColumnsOnLeft,
+		fixedColumnsOnRight,
+		hasFixedColumns,
+		mainColumns,
+		normalColumns,
+		visibleColumns,
+		getColumn,
+		getColumnStyle,
+		updateColumnWidth,
+		onColumnSorted
+	};
+}
+//#endregion
+exports.useColumns = useColumns;
+
+//# sourceMappingURL=use-columns.js.map

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-data.d.ts

@@ -0,0 +1,22 @@
+import { KeyType } from "../types.js";
+import { TableV2Props } from "../table.js";
+import { UseRowReturn } from "./use-row.js";
+import * as _$vue from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-data.d.ts
+type UseDataProps = {
+  expandedRowKeys: UseRowReturn['expandedRowKeys'];
+  lastRenderedRowIndex: UseRowReturn['lastRenderedRowIndex'];
+  resetAfterIndex: UseRowReturn['resetAfterIndex'];
+};
+declare const useData: (props: TableV2Props, {
+  expandedRowKeys,
+  lastRenderedRowIndex,
+  resetAfterIndex
+}: UseDataProps) => {
+  data: _$vue.ComputedRef<any[]>;
+  depthMap: _$vue.Ref<Record<KeyType, number>, Record<KeyType, number>>;
+};
+type UseDataReturn = ReturnType<typeof useData>;
+//#endregion
+export { UseDataReturn, useData };

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-data.js

@@ -0,0 +1,47 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../../_virtual/_rolldown/runtime.js");
+let vue = require("vue");
+let _vue_shared = require("@vue/shared");
+//#region ../../packages/components/table-v2/src/composables/use-data.ts
+const useData = (props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }) => {
+	const depthMap = (0, vue.ref)({});
+	const flattenedData = (0, vue.computed)(() => {
+		const depths = {};
+		const { data, rowKey } = props;
+		const _expandedRowKeys = (0, vue.unref)(expandedRowKeys);
+		if (!_expandedRowKeys || !_expandedRowKeys.length) return data;
+		const array = [];
+		const keysSet = /* @__PURE__ */ new Set();
+		_expandedRowKeys.forEach((x) => keysSet.add(x));
+		let copy = data.slice();
+		copy.forEach((x) => depths[x[rowKey]] = 0);
+		while (copy.length > 0) {
+			const item = copy.shift();
+			array.push(item);
+			if (keysSet.has(item[rowKey]) && (0, _vue_shared.isArray)(item.children) && item.children.length > 0) {
+				copy = [...item.children, ...copy];
+				item.children.forEach((child) => depths[child[rowKey]] = depths[item[rowKey]] + 1);
+			}
+		}
+		depthMap.value = depths;
+		return array;
+	});
+	const data = (0, vue.computed)(() => {
+		const { data, expandColumnKey } = props;
+		return expandColumnKey ? (0, vue.unref)(flattenedData) : data;
+	});
+	(0, vue.watch)(data, (val, prev) => {
+		if (val !== prev) {
+			lastRenderedRowIndex.value = -1;
+			resetAfterIndex(0, true);
+		}
+	});
+	return {
+		data,
+		depthMap
+	};
+};
+//#endregion
+exports.useData = useData;
+
+//# sourceMappingURL=use-data.js.map

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data.js","names":[],"sources":["../../../../../../../packages/components/table-v2/src/composables/use-data.ts"],"sourcesContent":["import { computed, ref, unref, watch } from 'vue'\nimport { isArray } from '@element-plus/utils'\n\nimport type { TableV2Props } from '../table'\nimport type { KeyType } from '../types'\nimport type { UseRowReturn } from './use-row'\n\ntype UseDataProps = {\n  expandedRowKeys: UseRowReturn['expandedRowKeys']\n  lastRenderedRowIndex: UseRowReturn['lastRenderedRowIndex']\n  resetAfterIndex: UseRowReturn['resetAfterIndex']\n}\n\nexport const useData = (\n  props: TableV2Props,\n  { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }: UseDataProps\n) => {\n  const depthMap = ref<Record<KeyType, number>>({})\n\n  const flattenedData = computed(() => {\n    const depths: Record<KeyType, number> = {}\n    const { data, rowKey } = props\n\n    const _expandedRowKeys = unref(expandedRowKeys)\n\n    if (!_expandedRowKeys || !_expandedRowKeys.length) return data\n\n    const array: any[] = []\n    const keysSet = new Set()\n    _expandedRowKeys.forEach((x) => keysSet.add(x))\n\n    let copy: any[] = data.slice()\n    copy.forEach((x) => (depths[x[rowKey]] = 0))\n    while (copy.length > 0) {\n      const item = copy.shift()!\n\n      array.push(item)\n      if (\n        keysSet.has(item[rowKey]) &&\n        isArray(item.children) &&\n        item.children.length > 0\n      ) {\n        copy = [...item.children, ...copy]\n        item.children.forEach(\n          (child: any) => (depths[child[rowKey]] = depths[item[rowKey]] + 1)\n        )\n      }\n    }\n\n    depthMap.value = depths\n    return array\n  })\n\n  const data = computed(() => {\n    const { data, expandColumnKey } = props\n    return expandColumnKey ? unref(flattenedData) : data\n  })\n\n  watch(data, (val, prev) => {\n    if (val !== prev) {\n      lastRenderedRowIndex.value = -1\n      resetAfterIndex(0, true)\n    }\n  })\n\n  return {\n    data,\n    depthMap,\n  }\n}\n\nexport type UseDataReturn = ReturnType<typeof useData>\n"],"mappings":";;;;;AAaA,MAAa,WACX,OACA,EAAE,iBAAiB,sBAAsB,sBACtC;CACH,MAAM,YAAA,GAAA,IAAA,KAAwC,EAAE,CAAC;CAEjD,MAAM,iBAAA,GAAA,IAAA,gBAA+B;EACnC,MAAM,SAAkC,EAAE;EAC1C,MAAM,EAAE,MAAM,WAAW;EAEzB,MAAM,oBAAA,GAAA,IAAA,OAAyB,gBAAgB;EAE/C,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,QAAQ,OAAO;EAE1D,MAAM,QAAe,EAAE;EACvB,MAAM,0BAAU,IAAI,KAAK;EACzB,iBAAiB,SAAS,MAAM,QAAQ,IAAI,EAAE,CAAC;EAE/C,IAAI,OAAc,KAAK,OAAO;EAC9B,KAAK,SAAS,MAAO,OAAO,EAAE,WAAW,EAAG;EAC5C,OAAO,KAAK,SAAS,GAAG;GACtB,MAAM,OAAO,KAAK,OAAO;GAEzB,MAAM,KAAK,KAAK;GAChB,IACE,QAAQ,IAAI,KAAK,QAAQ,KAAA,GAAA,YAAA,SACjB,KAAK,SAAS,IACtB,KAAK,SAAS,SAAS,GACvB;IACA,OAAO,CAAC,GAAG,KAAK,UAAU,GAAG,KAAK;IAClC,KAAK,SAAS,SACX,UAAgB,OAAO,MAAM,WAAW,OAAO,KAAK,WAAW,EACjE;;;EAIL,SAAS,QAAQ;EACjB,OAAO;GACP;CAEF,MAAM,QAAA,GAAA,IAAA,gBAAsB;EAC1B,MAAM,EAAE,MAAM,oBAAoB;EAClC,OAAO,mBAAA,GAAA,IAAA,OAAwB,cAAc,GAAG;GAChD;CAEF,CAAA,GAAA,IAAA,OAAM,OAAO,KAAK,SAAS;EACzB,IAAI,QAAQ,MAAM;GAChB,qBAAqB,QAAQ;GAC7B,gBAAgB,GAAG,KAAK;;GAE1B;CAEF,OAAO;EACL;EACA;EACD"}

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-row.d.ts

@@ -0,0 +1,54 @@
+import { UseNamespaceReturn } from "../../../../hooks/use-namespace/index.js";
+import { FixedDirection, KeyType } from "../types.js";
+import { onRowRenderedParams } from "../grid.js";
+import { TableV2Props } from "../table.js";
+import { TableGridInstance } from "../table-grid.js";
+import { RowExpandParams, RowHeightChangedParams, RowHoverParams } from "../row.js";
+import * as _$vue from "vue";
+import { ComponentInternalInstance, Ref, ShallowRef } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-row.d.ts
+type Heights = Record<KeyType, number>;
+type GridInstanceRef = Ref<TableGridInstance | undefined>;
+type UseRowProps = {
+  mainTableRef: GridInstanceRef;
+  leftTableRef: GridInstanceRef;
+  rightTableRef: GridInstanceRef;
+  tableInstance: ComponentInternalInstance;
+  ns: UseNamespaceReturn;
+  isScrolling: ShallowRef<boolean>;
+};
+declare const useRow: (props: TableV2Props, {
+  mainTableRef,
+  leftTableRef,
+  rightTableRef,
+  tableInstance,
+  ns,
+  isScrolling
+}: UseRowProps) => {
+  expandedRowKeys: Ref<KeyType[], KeyType[]>;
+  lastRenderedRowIndex: Ref<number, number>;
+  isDynamic: _$vue.ComputedRef<boolean>;
+  isResetting: ShallowRef<boolean, boolean>;
+  rowHeights: Ref<Heights, Heights>;
+  resetAfterIndex: (index: number, forceUpdate?: boolean) => void;
+  onRowExpanded: ({
+    expanded,
+    rowData,
+    rowIndex,
+    rowKey
+  }: RowExpandParams) => void;
+  onRowHovered: ({
+    hovered,
+    rowKey
+  }: RowHoverParams) => void;
+  onRowsRendered: (params: onRowRenderedParams) => void;
+  onRowHeightChange: ({
+    rowKey,
+    height,
+    rowIndex
+  }: RowHeightChangedParams, fixedDir: FixedDirection) => void;
+};
+type UseRowReturn = ReturnType<typeof useRow>;
+//#endregion
+export { UseRowReturn, useRow };

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-row.js

@@ -0,0 +1,114 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../../_virtual/_rolldown/runtime.js");
+const require_types = require("../../../../utils/types.js");
+require("../constants.js");
+let lodash_unified = require("lodash-unified");
+let vue = require("vue");
+//#region ../../packages/components/table-v2/src/composables/use-row.ts
+const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, tableInstance, ns, isScrolling }) => {
+	const vm = (0, vue.getCurrentInstance)();
+	const { emit } = vm;
+	const isResetting = (0, vue.shallowRef)(false);
+	const expandedRowKeys = (0, vue.ref)(props.defaultExpandedRowKeys || []);
+	const lastRenderedRowIndex = (0, vue.ref)(-1);
+	const resetIndex = (0, vue.shallowRef)(null);
+	const rowHeights = (0, vue.ref)({});
+	const pendingRowHeights = (0, vue.ref)({});
+	const leftTableHeights = (0, vue.shallowRef)({});
+	const mainTableHeights = (0, vue.shallowRef)({});
+	const rightTableHeights = (0, vue.shallowRef)({});
+	const isDynamic = (0, vue.computed)(() => require_types.isNumber(props.estimatedRowHeight));
+	function onRowsRendered(params) {
+		props.onRowsRendered?.(params);
+		if (params.rowCacheEnd > (0, vue.unref)(lastRenderedRowIndex)) lastRenderedRowIndex.value = params.rowCacheEnd;
+	}
+	function onRowHovered({ hovered, rowKey }) {
+		if (isScrolling.value) return;
+		tableInstance.vnode.el.querySelectorAll(`[rowkey="${String(rowKey)}"]`).forEach((row) => {
+			if (hovered) row.classList.add(ns.is("hovered"));
+			else row.classList.remove(ns.is("hovered"));
+		});
+	}
+	function onRowExpanded({ expanded, rowData, rowIndex, rowKey }) {
+		const _expandedRowKeys = [...(0, vue.unref)(expandedRowKeys)];
+		const currentKeyIndex = _expandedRowKeys.indexOf(rowKey);
+		if (expanded) {
+			if (currentKeyIndex === -1) _expandedRowKeys.push(rowKey);
+		} else if (currentKeyIndex > -1) _expandedRowKeys.splice(currentKeyIndex, 1);
+		expandedRowKeys.value = _expandedRowKeys;
+		emit("update:expandedRowKeys", _expandedRowKeys);
+		props.onRowExpand?.({
+			expanded,
+			rowData,
+			rowIndex,
+			rowKey
+		});
+		props.onExpandedRowsChange?.(_expandedRowKeys);
+		if (tableInstance.vnode.el.querySelector(`.${ns.is("hovered")}[rowkey="${String(rowKey)}"]`)) (0, vue.nextTick)(() => onRowHovered({
+			hovered: true,
+			rowKey
+		}));
+	}
+	const flushingRowHeights = (0, lodash_unified.debounce)(() => {
+		isResetting.value = true;
+		rowHeights.value = {
+			...(0, vue.unref)(rowHeights),
+			...(0, vue.unref)(pendingRowHeights)
+		};
+		resetAfterIndex((0, vue.unref)(resetIndex), false);
+		pendingRowHeights.value = {};
+		resetIndex.value = null;
+		mainTableRef.value?.forceUpdate();
+		leftTableRef.value?.forceUpdate();
+		rightTableRef.value?.forceUpdate();
+		vm.proxy?.$forceUpdate();
+		isResetting.value = false;
+	}, 0);
+	function resetAfterIndex(index, forceUpdate = false) {
+		if (!(0, vue.unref)(isDynamic)) return;
+		[
+			mainTableRef,
+			leftTableRef,
+			rightTableRef
+		].forEach((tableRef) => {
+			const table = (0, vue.unref)(tableRef);
+			if (table) table.resetAfterRowIndex(index, forceUpdate);
+		});
+	}
+	function resetHeights(rowKey, height, rowIdx) {
+		const resetIdx = (0, vue.unref)(resetIndex);
+		if (resetIdx === null) resetIndex.value = rowIdx;
+		else if (resetIdx > rowIdx) resetIndex.value = rowIdx;
+		pendingRowHeights.value[rowKey] = height;
+	}
+	function onRowHeightChange({ rowKey, height, rowIndex }, fixedDir) {
+		if (!fixedDir) mainTableHeights.value[rowKey] = height;
+		else if (fixedDir === "right") rightTableHeights.value[rowKey] = height;
+		else leftTableHeights.value[rowKey] = height;
+		const maximumHeight = Math.max(...[
+			leftTableHeights,
+			rightTableHeights,
+			mainTableHeights
+		].map((records) => records.value[rowKey] || 0));
+		if ((0, vue.unref)(rowHeights)[rowKey] !== maximumHeight) {
+			resetHeights(rowKey, maximumHeight, rowIndex);
+			flushingRowHeights();
+		}
+	}
+	return {
+		expandedRowKeys,
+		lastRenderedRowIndex,
+		isDynamic,
+		isResetting,
+		rowHeights,
+		resetAfterIndex,
+		onRowExpanded,
+		onRowHovered,
+		onRowsRendered,
+		onRowHeightChange
+	};
+};
+//#endregion
+exports.useRow = useRow;
+
+//# sourceMappingURL=use-row.js.map

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-scrollbar.d.ts

@@ -0,0 +1,41 @@
+import { Alignment } from "../../../virtual-list/src/types.js";
+import { TableV2Props } from "../table.js";
+import { TableGridInstance } from "../table-grid.js";
+import { Ref } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-scrollbar.d.ts
+type ScrollPos = {
+  scrollLeft: number;
+  scrollTop: number;
+};
+type GridInstanceRef = Ref<TableGridInstance | undefined>;
+type UseScrollBarProps = {
+  mainTableRef: GridInstanceRef;
+  leftTableRef: GridInstanceRef;
+  rightTableRef: GridInstanceRef;
+  onMaybeEndReached: () => void;
+};
+declare const useScrollbar: (props: TableV2Props, {
+  mainTableRef,
+  leftTableRef,
+  rightTableRef,
+  onMaybeEndReached
+}: UseScrollBarProps) => {
+  scrollPos: Ref<{
+    scrollLeft: number;
+    scrollTop: number;
+  }, ScrollPos | {
+    scrollLeft: number;
+    scrollTop: number;
+  }>;
+  scrollTo: (params: ScrollPos) => void;
+  scrollToLeft: (scrollLeft: number) => void;
+  scrollToTop: (scrollTop: number) => void;
+  scrollToRow: (row: number, strategy?: Alignment) => void;
+  onScroll: (params: ScrollPos) => void;
+  onVerticalScroll: ({
+    scrollTop
+  }: ScrollPos) => void;
+};
+//#endregion
+export { ScrollPos, type Alignment as ScrollStrategy, useScrollbar };

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-scrollbar.js

@@ -0,0 +1,55 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../../_virtual/_rolldown/runtime.js");
+let vue = require("vue");
+//#region ../../packages/components/table-v2/src/composables/use-scrollbar.ts
+const useScrollbar = (props, { mainTableRef, leftTableRef, rightTableRef, onMaybeEndReached }) => {
+	const scrollPos = (0, vue.ref)({
+		scrollLeft: 0,
+		scrollTop: 0
+	});
+	function doScroll(params) {
+		const { scrollTop } = params;
+		mainTableRef.value?.scrollTo(params);
+		leftTableRef.value?.scrollToTop(scrollTop);
+		rightTableRef.value?.scrollToTop(scrollTop);
+	}
+	function scrollTo(params) {
+		scrollPos.value = params;
+		doScroll(params);
+	}
+	function scrollToTop(scrollTop) {
+		scrollPos.value.scrollTop = scrollTop;
+		doScroll((0, vue.unref)(scrollPos));
+	}
+	function scrollToLeft(scrollLeft) {
+		scrollPos.value.scrollLeft = scrollLeft;
+		mainTableRef.value?.scrollTo?.((0, vue.unref)(scrollPos));
+	}
+	function onScroll(params) {
+		scrollTo(params);
+		props.onScroll?.(params);
+	}
+	function onVerticalScroll({ scrollTop }) {
+		const { scrollTop: currentScrollTop } = (0, vue.unref)(scrollPos);
+		if (scrollTop !== currentScrollTop) scrollToTop(scrollTop);
+	}
+	function scrollToRow(row, strategy = "auto") {
+		mainTableRef.value?.scrollToRow(row, strategy);
+	}
+	(0, vue.watch)(() => (0, vue.unref)(scrollPos).scrollTop, (cur, prev) => {
+		if (cur > prev) onMaybeEndReached();
+	});
+	return {
+		scrollPos,
+		scrollTo,
+		scrollToLeft,
+		scrollToTop,
+		scrollToRow,
+		onScroll,
+		onVerticalScroll
+	};
+};
+//#endregion
+exports.useScrollbar = useScrollbar;
+
+//# sourceMappingURL=use-scrollbar.js.map

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-scrollbar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scrollbar.js","names":[],"sources":["../../../../../../../packages/components/table-v2/src/composables/use-scrollbar.ts"],"sourcesContent":["import { ref, unref, watch } from 'vue'\n\nimport type { Ref } from 'vue'\nimport type { Alignment as ScrollStrategy } from '@element-plus/components/virtual-list'\nimport type { TableV2Props } from '../table'\nimport type { TableGridInstance } from '../table-grid'\n\nexport type ScrollPos = { scrollLeft: number; scrollTop: number }\ntype GridInstanceRef = Ref<TableGridInstance | undefined>\n\ntype UseScrollBarProps = {\n  mainTableRef: GridInstanceRef\n  leftTableRef: GridInstanceRef\n  rightTableRef: GridInstanceRef\n\n  onMaybeEndReached: () => void\n}\n\nexport type { ScrollStrategy }\n\nexport const useScrollbar = (\n  props: TableV2Props,\n  {\n    mainTableRef,\n    leftTableRef,\n    rightTableRef,\n    onMaybeEndReached,\n  }: UseScrollBarProps\n) => {\n  const scrollPos = ref<ScrollPos>({ scrollLeft: 0, scrollTop: 0 })\n\n  function doScroll(params: ScrollPos) {\n    const { scrollTop } = params\n\n    mainTableRef.value?.scrollTo(params)\n    leftTableRef.value?.scrollToTop(scrollTop)\n    rightTableRef.value?.scrollToTop(scrollTop)\n  }\n\n  // methods\n  function scrollTo(params: ScrollPos) {\n    scrollPos.value = params\n\n    doScroll(params)\n  }\n\n  function scrollToTop(scrollTop: number) {\n    scrollPos.value.scrollTop = scrollTop\n\n    doScroll(unref(scrollPos))\n  }\n\n  function scrollToLeft(scrollLeft: number) {\n    scrollPos.value.scrollLeft = scrollLeft\n\n    mainTableRef.value?.scrollTo?.(unref(scrollPos))\n  }\n\n  function onScroll(params: ScrollPos) {\n    scrollTo(params)\n    props.onScroll?.(params)\n  }\n\n  function onVerticalScroll({ scrollTop }: ScrollPos) {\n    const { scrollTop: currentScrollTop } = unref(scrollPos)\n    if (scrollTop !== currentScrollTop) scrollToTop(scrollTop)\n  }\n\n  function scrollToRow(row: number, strategy: ScrollStrategy = 'auto') {\n    mainTableRef.value?.scrollToRow(row, strategy)\n  }\n\n  // When scrollTop changes, maybe reaching the bottom\n  watch(\n    () => unref(scrollPos).scrollTop,\n    (cur, prev) => {\n      if (cur > prev) onMaybeEndReached()\n    }\n  )\n\n  return {\n    scrollPos,\n\n    scrollTo,\n    scrollToLeft,\n    scrollToTop,\n    scrollToRow,\n    onScroll,\n    onVerticalScroll,\n  }\n}\n"],"mappings":";;;;AAoBA,MAAa,gBACX,OACA,EACE,cACA,cACA,eACA,wBAEC;CACH,MAAM,aAAA,GAAA,IAAA,KAA2B;EAAE,YAAY;EAAG,WAAW;EAAG,CAAC;CAEjE,SAAS,SAAS,QAAmB;EACnC,MAAM,EAAE,cAAc;EAEtB,aAAa,OAAO,SAAS,OAAO;EACpC,aAAa,OAAO,YAAY,UAAU;EAC1C,cAAc,OAAO,YAAY,UAAU;;CAI7C,SAAS,SAAS,QAAmB;EACnC,UAAU,QAAQ;EAElB,SAAS,OAAO;;CAGlB,SAAS,YAAY,WAAmB;EACtC,UAAU,MAAM,YAAY;EAE5B,UAAA,GAAA,IAAA,OAAe,UAAU,CAAC;;CAG5B,SAAS,aAAa,YAAoB;EACxC,UAAU,MAAM,aAAa;EAE7B,aAAa,OAAO,YAAA,GAAA,IAAA,OAAiB,UAAU,CAAC;;CAGlD,SAAS,SAAS,QAAmB;EACnC,SAAS,OAAO;EAChB,MAAM,WAAW,OAAO;;CAG1B,SAAS,iBAAiB,EAAE,aAAwB;EAClD,MAAM,EAAE,WAAW,sBAAA,GAAA,IAAA,OAA2B,UAAU;EACxD,IAAI,cAAc,kBAAkB,YAAY,UAAU;;CAG5D,SAAS,YAAY,KAAa,WAA2B,QAAQ;EACnE,aAAa,OAAO,YAAY,KAAK,SAAS;;CAIhD,CAAA,GAAA,IAAA,cAAA,GAAA,IAAA,OACc,UAAU,CAAC,YACtB,KAAK,SAAS;EACb,IAAI,MAAM,MAAM,mBAAmB;GAEtC;CAED,OAAO;EACL;EAEA;EACA;EACA;EACA;EACA;EACA;EACD"}

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-styles.d.ts

@@ -0,0 +1,31 @@
+import { TableV2Props } from "../table.js";
+import { UseColumnsReturn } from "./use-columns.js";
+import { CSSProperties, ComputedRef } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-styles.d.ts
+type UseStyleProps = {
+  columnsTotalWidth: UseColumnsReturn['columnsTotalWidth'];
+  fixedColumnsOnLeft: UseColumnsReturn['fixedColumnsOnLeft'];
+  fixedColumnsOnRight: UseColumnsReturn['fixedColumnsOnRight'];
+  rowsHeight: ComputedRef<number>;
+};
+declare const useStyles: (props: TableV2Props, {
+  columnsTotalWidth,
+  rowsHeight,
+  fixedColumnsOnLeft,
+  fixedColumnsOnRight
+}: UseStyleProps) => {
+  bodyWidth: ComputedRef<number>;
+  fixedTableHeight: ComputedRef<number>;
+  mainTableHeight: ComputedRef<number>;
+  leftTableWidth: ComputedRef<number>;
+  rightTableWidth: ComputedRef<number>;
+  windowHeight: ComputedRef<number>;
+  footerHeight: ComputedRef<CSSProperties>;
+  emptyStyle: ComputedRef<CSSProperties>;
+  rootStyle: ComputedRef<CSSProperties>;
+  headerHeight: ComputedRef<number>;
+};
+type UseStyleReturn = ReturnType<typeof useStyles>;
+//#endregion
+export { UseStyleReturn, useStyles };

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/use-styles.js

@@ -0,0 +1,69 @@
+Object.defineProperty(exports, 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_utils = require("../utils.js");
+let vue = require("vue");
+//#region ../../packages/components/table-v2/src/composables/use-styles.ts
+const useStyles = (props, { columnsTotalWidth, rowsHeight, fixedColumnsOnLeft, fixedColumnsOnRight }) => {
+	const bodyWidth = (0, vue.computed)(() => {
+		const { fixed, width, vScrollbarSize } = props;
+		const ret = width - vScrollbarSize;
+		return fixed ? Math.max(Math.round((0, vue.unref)(columnsTotalWidth)), ret) : ret;
+	});
+	const mainTableHeight = (0, vue.computed)(() => {
+		const { height = 0, maxHeight = 0, footerHeight, hScrollbarSize } = props;
+		if (maxHeight > 0) {
+			const _fixedRowsHeight = (0, vue.unref)(fixedRowsHeight);
+			const _rowsHeight = (0, vue.unref)(rowsHeight);
+			const total = (0, vue.unref)(headerHeight) + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
+			return Math.min(total, maxHeight - footerHeight);
+		}
+		return height - footerHeight;
+	});
+	const fixedTableHeight = (0, vue.computed)(() => {
+		const { maxHeight } = props;
+		const tableHeight = (0, vue.unref)(mainTableHeight);
+		if (require_types.isNumber(maxHeight) && maxHeight > 0) return tableHeight;
+		const totalHeight = (0, vue.unref)(rowsHeight) + (0, vue.unref)(headerHeight) + (0, vue.unref)(fixedRowsHeight);
+		return Math.min(tableHeight, totalHeight);
+	});
+	const mapColumn = (column) => column.width;
+	const leftTableWidth = (0, vue.computed)(() => require_utils.sum((0, vue.unref)(fixedColumnsOnLeft).map(mapColumn)));
+	const rightTableWidth = (0, vue.computed)(() => require_utils.sum((0, vue.unref)(fixedColumnsOnRight).map(mapColumn)));
+	const headerHeight = (0, vue.computed)(() => require_utils.sum(props.headerHeight));
+	const fixedRowsHeight = (0, vue.computed)(() => {
+		return (props.fixedData?.length || 0) * props.rowHeight;
+	});
+	const windowHeight = (0, vue.computed)(() => {
+		return (0, vue.unref)(mainTableHeight) - (0, vue.unref)(headerHeight) - (0, vue.unref)(fixedRowsHeight);
+	});
+	const rootStyle = (0, vue.computed)(() => {
+		const { style = {}, height, width } = props;
+		return require_utils.enforceUnit({
+			...style,
+			height,
+			width
+		});
+	});
+	return {
+		bodyWidth,
+		fixedTableHeight,
+		mainTableHeight,
+		leftTableWidth,
+		rightTableWidth,
+		windowHeight,
+		footerHeight: (0, vue.computed)(() => require_utils.enforceUnit({ height: props.footerHeight })),
+		emptyStyle: (0, vue.computed)(() => ({
+			top: require_style.addUnit((0, vue.unref)(headerHeight)),
+			bottom: require_style.addUnit(props.footerHeight),
+			width: require_style.addUnit(props.width)
+		})),
+		rootStyle,
+		headerHeight
+	};
+};
+//#endregion
+exports.useStyles = useStyles;
+
+//# sourceMappingURL=use-styles.js.map

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/utils.d.ts

@@ -0,0 +1,7 @@
+import { AnyColumns } from "../types.js";
+import { CSSProperties } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/utils.d.ts
+declare const calcColumnStyle: (column: AnyColumns[number], fixedColumn: boolean, fixed: boolean) => CSSProperties;
+//#endregion
+export { calcColumnStyle };

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/utils.js

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region ../../packages/components/table-v2/src/composables/utils.ts
+const calcColumnStyle = (column, fixedColumn, fixed) => {
+	const flex = {
+		flexGrow: 0,
+		flexShrink: 0,
+		...fixed ? {} : {
+			flexGrow: column.flexGrow ?? 0,
+			flexShrink: column.flexShrink ?? 1
+		}
+	};
+	const style = {
+		...column.style ?? {},
+		...flex,
+		flexBasis: "auto",
+		width: column.width
+	};
+	if (!fixedColumn) {
+		if (column.maxWidth) style.maxWidth = column.maxWidth;
+		if (column.minWidth) style.minWidth = column.minWidth;
+	}
+	return style;
+};
+//#endregion
+exports.calcColumnStyle = calcColumnStyle;
+
+//# sourceMappingURL=utils.js.map

frontend/node_modules/element-plus/lib/components/table-v2/src/composables/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../../../../../packages/components/table-v2/src/composables/utils.ts"],"sourcesContent":["import type { CSSProperties } from 'vue'\nimport type { AnyColumns } from '../types'\n\nexport const calcColumnStyle = (\n  column: AnyColumns[number],\n  fixedColumn: boolean,\n  fixed: boolean\n): CSSProperties => {\n  const flex = {\n    flexGrow: 0,\n    flexShrink: 0,\n    ...(fixed\n      ? {}\n      : {\n          flexGrow: column.flexGrow ?? 0,\n          flexShrink: column.flexShrink ?? 1,\n        }),\n  }\n\n  const style = {\n    ...(column.style ?? {}),\n    ...flex,\n    flexBasis: 'auto',\n    width: column.width,\n  }\n\n  if (!fixedColumn) {\n    if (column.maxWidth) style.maxWidth = column.maxWidth\n    if (column.minWidth) style.minWidth = column.minWidth\n  }\n\n  return style\n}\n"],"mappings":";;AAGA,MAAa,mBACX,QACA,aACA,UACkB;CAClB,MAAM,OAAO;EACX,UAAU;EACV,YAAY;EACZ,GAAI,QACA,EAAE,GACF;GACE,UAAU,OAAO,YAAY;GAC7B,YAAY,OAAO,cAAc;GAClC;EACN;CAED,MAAM,QAAQ;EACZ,GAAI,OAAO,SAAS,EAAE;EACtB,GAAG;EACH,WAAW;EACX,OAAO,OAAO;EACf;CAED,IAAI,CAAC,aAAa;EAChB,IAAI,OAAO,UAAU,MAAM,WAAW,OAAO;EAC7C,IAAI,OAAO,UAAU,MAAM,WAAW,OAAO;;CAG/C,OAAO"}