agentworkshop 0.7.66 → 0.7.71

package/.output/server/chunks/build/menu-BXt-X0dt.mjs

@@ -0,0 +1,1952 @@
+import { aT as Icon, k as useConfigInject_default, A as devWarning_default, p as cloneElement, r as _objectSpread2, m as flattenChildren, o as _extends, P as PropTypes, q as classNames, x as genComponentStyleHook, ba as isValid, ag as KeyCode, S as isValidElement, G as objectType, bb as skipFlattenKey, l as getPropsSlot, bc as Set, s as getTransitionProps, y as merge, aq as TinyColor, W as initZoomMotion, aN as clearFix, K as resetComponent, ak as textEllipsis, b9 as resetIcon, a2 as genFocusOutline } from '../virtual/entry.mjs';
+import { v as vc_trigger_default, w as wrapperRaf } from './firstNotUndefined-8H5_qHUu.mjs';
+import { v as vc_overflow_default, i as initSlideMotion } from '../_/SearchOutlined.mjs';
+import { t as tooltip_default } from './tooltip-C2n2nNiQ.mjs';
+import { h as collapseMotion, s as setToArray, k as SetCache, n as arrayIncludes, l as cacheHas, g as genCollapseMotion } from './input-GtPuSEgt.mjs';
+import { createVNode, defineComponent, computed, shallowRef, inject, ref, watchEffect, watch, unref, Fragment, Teleport, getCurrentInstance, provide, toRaw, toRef, Transition, withDirectives, vShow } from 'vue';
+
+// This icon file is generated automatically.
+var EllipsisOutlined$1 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M176 511a56 56 0 10112 0 56 56 0 10-112 0zm280 0a56 56 0 10112 0 56 56 0 10-112 0zm280 0a56 56 0 10112 0 56 56 0 10-112 0z" } }] }, "name": "ellipsis", "theme": "outlined" };
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var EllipsisOutlined = function EllipsisOutlined(props, context) {
+  var p = _objectSpread({}, props, context.attrs);
+
+  return createVNode(Icon, _objectSpread({}, p, {
+    "icon": EllipsisOutlined$1
+  }), null);
+};
+
+EllipsisOutlined.displayName = 'EllipsisOutlined';
+EllipsisOutlined.inheritAttrs = false;
+
+//#region node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/noop.js
+/**
+* This method returns `undefined`.
+*
+* @static
+* @memberOf _
+* @since 2.3.0
+* @category Util
+* @example
+*
+* _.times(2, _.noop);
+* // => [undefined, undefined]
+*/
+function noop() {}
+//#endregion
+//#region node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_createSet.js
+/**
+* Creates a set object of `values`.
+*
+* @private
+* @param {Array} values The values to add to the set.
+* @returns {Object} Returns the new set.
+*/
+var createSet = !(Set && 1 / setToArray(new Set([, -0]))[1] == 1 / 0) ? noop : function(values) {
+	return new Set(values);
+};
+//#endregion
+//#region node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseUniq.js
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+/**
+* The base implementation of `_.uniqBy` without support for iteratee shorthands.
+*
+* @private
+* @param {Array} array The array to inspect.
+* @param {Function} [iteratee] The iteratee invoked per element.
+* @param {Function} [comparator] The comparator invoked per element.
+* @returns {Array} Returns the new duplicate free array.
+*/
+function baseUniq(array, iteratee, comparator) {
+	var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
+	if (length >= LARGE_ARRAY_SIZE) {
+		var set = createSet(array);
+		if (set) return setToArray(set);
+		isCommon = false;
+		includes = cacheHas;
+		seen = new SetCache();
+	} else seen = result;
+	outer: while (++index < length) {
+		var value = array[index], computed = value;
+		value = value !== 0 ? value : 0;
+		if (isCommon && computed === computed) {
+			var seenIndex = seen.length;
+			while (seenIndex--) if (seen[seenIndex] === computed) continue outer;
+			result.push(value);
+		} else if (!includes(seen, computed, comparator)) {
+			if (seen !== result) seen.push(computed);
+			result.push(value);
+		}
+	}
+	return result;
+}
+//#endregion
+//#region node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/uniq.js
+/**
+* Creates a duplicate-free version of an array, using
+* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+* for equality comparisons, in which only the first occurrence of each element
+* is kept. The order of result values is determined by the order they occur
+* in the array.
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Array
+* @param {Array} array The array to inspect.
+* @returns {Array} Returns the new duplicate free array.
+* @example
+*
+* _.uniq([2, 1, 2]);
+* // => [2, 1]
+*/
+function uniq(array) {
+	return array && array.length ? baseUniq(array) : [];
+}
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/vc-dropdown/placements.js
+var autoAdjustOverflow$1 = {
+	adjustX: 1,
+	adjustY: 1
+};
+var targetOffset = [0, 0];
+var placements$1 = {
+	topLeft: {
+		points: ["bl", "tl"],
+		overflow: autoAdjustOverflow$1,
+		offset: [0, -4],
+		targetOffset
+	},
+	topCenter: {
+		points: ["bc", "tc"],
+		overflow: autoAdjustOverflow$1,
+		offset: [0, -4],
+		targetOffset
+	},
+	topRight: {
+		points: ["br", "tr"],
+		overflow: autoAdjustOverflow$1,
+		offset: [0, -4],
+		targetOffset
+	},
+	bottomLeft: {
+		points: ["tl", "bl"],
+		overflow: autoAdjustOverflow$1,
+		offset: [0, 4],
+		targetOffset
+	},
+	bottomCenter: {
+		points: ["tc", "bc"],
+		overflow: autoAdjustOverflow$1,
+		offset: [0, 4],
+		targetOffset
+	},
+	bottomRight: {
+		points: ["tr", "br"],
+		overflow: autoAdjustOverflow$1,
+		offset: [0, 4],
+		targetOffset
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/vc-dropdown/Dropdown.js
+var __rest$1 = function(s, e) {
+	var t = {};
+	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+	}
+	return t;
+};
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/vc-dropdown/index.js
+var vc_dropdown_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	props: {
+		minOverlayWidthMatchTrigger: {
+			type: Boolean,
+			default: void 0
+		},
+		arrow: {
+			type: Boolean,
+			default: false
+		},
+		prefixCls: PropTypes.string.def("rc-dropdown"),
+		transitionName: String,
+		overlayClassName: PropTypes.string.def(""),
+		openClassName: String,
+		animation: PropTypes.any,
+		align: PropTypes.object,
+		overlayStyle: {
+			type: Object,
+			default: void 0
+		},
+		placement: PropTypes.string.def("bottomLeft"),
+		overlay: PropTypes.any,
+		trigger: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]).def("hover"),
+		alignPoint: {
+			type: Boolean,
+			default: void 0
+		},
+		showAction: PropTypes.array,
+		hideAction: PropTypes.array,
+		getPopupContainer: Function,
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		defaultVisible: {
+			type: Boolean,
+			default: false
+		},
+		mouseEnterDelay: PropTypes.number.def(.15),
+		mouseLeaveDelay: PropTypes.number.def(.1)
+	},
+	emits: ["visibleChange", "overlayClick"],
+	setup(props, _ref) {
+		let { slots, emit, expose } = _ref;
+		const triggerVisible = ref(!!props.visible);
+		watch(() => props.visible, (val) => {
+			if (val !== void 0) triggerVisible.value = val;
+		});
+		const triggerRef = ref();
+		expose({ triggerRef });
+		const onClick = (e) => {
+			if (props.visible === void 0) triggerVisible.value = false;
+			emit("overlayClick", e);
+		};
+		const onVisibleChange = (visible) => {
+			if (props.visible === void 0) triggerVisible.value = visible;
+			emit("visibleChange", visible);
+		};
+		const getMenuElement = () => {
+			var _a;
+			const overlayElement = (_a = slots.overlay) === null || _a === void 0 ? void 0 : _a.call(slots);
+			const extraOverlayProps = {
+				prefixCls: `${props.prefixCls}-menu`,
+				onClick
+			};
+			return createVNode(Fragment, { "key": skipFlattenKey }, [props.arrow && createVNode("div", { "class": `${props.prefixCls}-arrow` }, null), cloneElement(overlayElement, extraOverlayProps, false)]);
+		};
+		const minOverlayWidthMatchTrigger = computed(() => {
+			const { minOverlayWidthMatchTrigger: matchTrigger = !props.alignPoint } = props;
+			return matchTrigger;
+		});
+		const renderChildren = () => {
+			var _a;
+			const children = (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+			return triggerVisible.value && children ? cloneElement(children[0], { class: props.openClassName || `${props.prefixCls}-open` }, false) : children;
+		};
+		const triggerHideAction = computed(() => {
+			if (!props.hideAction && props.trigger.indexOf("contextmenu") !== -1) return ["click"];
+			return props.hideAction;
+		});
+		return () => {
+			const { prefixCls, arrow, showAction, overlayStyle, trigger, placement, align, getPopupContainer, transitionName, animation, overlayClassName } = props, otherProps = __rest$1(props, [
+				"prefixCls",
+				"arrow",
+				"showAction",
+				"overlayStyle",
+				"trigger",
+				"placement",
+				"align",
+				"getPopupContainer",
+				"transitionName",
+				"animation",
+				"overlayClassName"
+			]);
+			return createVNode(vc_trigger_default, _objectSpread2(_objectSpread2({}, otherProps), {}, {
+				"prefixCls": prefixCls,
+				"ref": triggerRef,
+				"popupClassName": classNames(overlayClassName, { [`${prefixCls}-show-arrow`]: arrow }),
+				"popupStyle": overlayStyle,
+				"builtinPlacements": placements$1,
+				"action": trigger,
+				"showAction": showAction,
+				"hideAction": triggerHideAction.value || [],
+				"popupPlacement": placement,
+				"popupAlign": align,
+				"popupTransitionName": transitionName,
+				"popupAnimation": animation,
+				"popupVisible": triggerVisible.value,
+				"stretch": minOverlayWidthMatchTrigger.value ? "minWidth" : "",
+				"onPopupVisibleChange": onVisibleChange,
+				"getPopupContainer": getPopupContainer
+			}), {
+				popup: getMenuElement,
+				default: renderChildren
+			});
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/OverrideContext.js
+var OverrideContextKey = Symbol("OverrideContextKey");
+var useInjectOverride = () => {
+	return inject(OverrideContextKey, void 0);
+};
+var useProvideOverride = (props) => {
+	var _a, _b, _c;
+	const { prefixCls, mode, selectable, validator, onClick, expandIcon } = useInjectOverride() || {};
+	provide(OverrideContextKey, {
+		prefixCls: computed(() => {
+			var _a, _b;
+			return (_b = (_a = props.prefixCls) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : prefixCls === null || prefixCls === void 0 ? void 0 : prefixCls.value;
+		}),
+		mode: computed(() => {
+			var _a, _b;
+			return (_b = (_a = props.mode) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : mode === null || mode === void 0 ? void 0 : mode.value;
+		}),
+		selectable: computed(() => {
+			var _a, _b;
+			return (_b = (_a = props.selectable) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : selectable === null || selectable === void 0 ? void 0 : selectable.value;
+		}),
+		validator: (_a = props.validator) !== null && _a !== void 0 ? _a : validator,
+		onClick: (_b = props.onClick) !== null && _b !== void 0 ? _b : onClick,
+		expandIcon: (_c = props.expandIcon) !== null && _c !== void 0 ? _c : expandIcon === null || expandIcon === void 0 ? void 0 : expandIcon.value
+	});
+};
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/_util/shallowequal.js
+function shallowEqual(objA, objB, compare, compareContext) {
+	let ret = void 0;
+	if (ret !== void 0) return !!ret;
+	if (objA === objB) return true;
+	if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) return false;
+	const keysA = Object.keys(objA);
+	const keysB = Object.keys(objB);
+	if (keysA.length !== keysB.length) return false;
+	const bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
+	for (let idx = 0; idx < keysA.length; idx++) {
+		const key = keysA[idx];
+		if (!bHasOwnProperty(key)) return false;
+		const valueA = objA[key];
+		const valueB = objB[key];
+		ret = void 0;
+		if (ret === false || ret === void 0 && valueA !== valueB) return false;
+	}
+	return true;
+}
+function shallowequal_default(value, other) {
+	return shallowEqual(toRaw(value), toRaw(other));
+}
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/hooks/useMenuContext.js
+var MenuContextKey = Symbol("menuContextKey");
+var useProvideMenu = (props) => {
+	provide(MenuContextKey, props);
+};
+var useInjectMenu = () => {
+	return inject(MenuContextKey);
+};
+var ForceRenderKey = Symbol("ForceRenderKey");
+var useProvideForceRender = (forceRender) => {
+	provide(ForceRenderKey, forceRender);
+};
+var useInjectForceRender = () => {
+	return inject(ForceRenderKey, false);
+};
+var MenuFirstLevelContextKey = Symbol("menuFirstLevelContextKey");
+var useProvideFirstLevel = (firstLevel) => {
+	provide(MenuFirstLevelContextKey, firstLevel);
+};
+var useInjectFirstLevel = () => {
+	return inject(MenuFirstLevelContextKey, true);
+};
+var MenuContextProvider = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "MenuContextProvider",
+	inheritAttrs: false,
+	props: {
+		mode: {
+			type: String,
+			default: void 0
+		},
+		overflowDisabled: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	setup(props, _ref) {
+		let { slots } = _ref;
+		const menuContext = useInjectMenu();
+		const newContext = _extends({}, menuContext);
+		if (props.mode !== void 0) newContext.mode = toRef(props, "mode");
+		if (props.overflowDisabled !== void 0) newContext.overflowDisabled = toRef(props, "overflowDisabled");
+		useProvideMenu(newContext);
+		return () => {
+			var _a;
+			return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/layout/injectionKey.js
+var SiderCollapsedKey = Symbol("siderCollapsed");
+var SiderHookProviderKey = Symbol("siderHookProvider");
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/hooks/useKeyPath.js
+var OVERFLOW_KEY = "$$__vc-menu-more__key";
+var KeyPathContext = Symbol("KeyPathContext");
+var useInjectKeyPath = () => {
+	return inject(KeyPathContext, {
+		parentEventKeys: computed(() => []),
+		parentKeys: computed(() => []),
+		parentInfo: {}
+	});
+};
+var useProvideKeyPath = (eventKey, key, menuInfo) => {
+	const { parentEventKeys, parentKeys } = useInjectKeyPath();
+	const eventKeys = computed(() => [...parentEventKeys.value, eventKey]);
+	const keys = computed(() => [...parentKeys.value, key]);
+	provide(KeyPathContext, {
+		parentEventKeys: eventKeys,
+		parentKeys: keys,
+		parentInfo: menuInfo
+	});
+	return keys;
+};
+var measure = Symbol("measure");
+var PathContext = defineComponent({
+	compatConfig: { MODE: 3 },
+	setup(_props, _ref) {
+		let { slots } = _ref;
+		provide(measure, true);
+		return () => {
+			var _a;
+			return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+		};
+	}
+});
+var useMeasure = () => {
+	return inject(measure, false);
+};
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/hooks/useDirectionStyle.js
+function useDirectionStyle(level) {
+	const { mode, rtl, inlineIndent } = useInjectMenu();
+	return computed(() => mode.value !== "inline" ? null : rtl.value ? { paddingRight: `${level.value * inlineIndent.value}px` } : { paddingLeft: `${level.value * inlineIndent.value}px` });
+}
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/MenuItem.js
+var indexGuid$1 = 0;
+var menuItemProps = () => ({
+	id: String,
+	role: String,
+	disabled: Boolean,
+	danger: Boolean,
+	title: {
+		type: [String, Boolean],
+		default: void 0
+	},
+	icon: PropTypes.any,
+	onMouseenter: Function,
+	onMouseleave: Function,
+	onClick: Function,
+	onKeydown: Function,
+	onFocus: Function,
+	originItemValue: objectType()
+});
+var MenuItem_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "AMenuItem",
+	inheritAttrs: false,
+	props: menuItemProps(),
+	slots: Object,
+	setup(props, _ref) {
+		let { slots, emit, attrs } = _ref;
+		const instance = getCurrentInstance();
+		const isMeasure = useMeasure();
+		const key = typeof instance.vnode.key === "symbol" ? String(instance.vnode.key) : instance.vnode.key;
+		devWarning_default(typeof instance.vnode.key !== "symbol", "MenuItem", `MenuItem \`:key="${String(key)}"\` not support Symbol type`);
+		const eventKey = `menu_item_${++indexGuid$1}_$$_${key}`;
+		const { parentEventKeys, parentKeys } = useInjectKeyPath();
+		const { prefixCls, activeKeys, disabled, changeActiveKeys, rtl, inlineCollapsed, siderCollapsed, onItemClick, selectedKeys, registerMenuInfo, unRegisterMenuInfo } = useInjectMenu();
+		const firstLevel = useInjectFirstLevel();
+		const isActive = shallowRef(false);
+		const keysPath = computed(() => {
+			return [...parentKeys.value, key];
+		});
+		registerMenuInfo(eventKey, {
+			eventKey,
+			key,
+			parentEventKeys,
+			parentKeys,
+			isLeaf: true
+		});
+		watch(activeKeys, () => {
+			isActive.value = !!activeKeys.value.find((val) => val === key);
+		}, { immediate: true });
+		const mergedDisabled = computed(() => disabled.value || props.disabled);
+		const selected = computed(() => selectedKeys.value.includes(key));
+		const classNames = computed(() => {
+			const itemCls = `${prefixCls.value}-item`;
+			return {
+				[`${itemCls}`]: true,
+				[`${itemCls}-danger`]: props.danger,
+				[`${itemCls}-active`]: isActive.value,
+				[`${itemCls}-selected`]: selected.value,
+				[`${itemCls}-disabled`]: mergedDisabled.value
+			};
+		});
+		const getEventInfo = (e) => {
+			return {
+				key,
+				eventKey,
+				keyPath: keysPath.value,
+				eventKeyPath: [...parentEventKeys.value, eventKey],
+				domEvent: e,
+				item: _extends(_extends({}, props), attrs)
+			};
+		};
+		const onInternalClick = (e) => {
+			if (mergedDisabled.value) return;
+			const info = getEventInfo(e);
+			emit("click", e);
+			onItemClick(info);
+		};
+		const onMouseEnter = (event) => {
+			if (!mergedDisabled.value) {
+				changeActiveKeys(keysPath.value);
+				emit("mouseenter", event);
+			}
+		};
+		const onMouseLeave = (event) => {
+			if (!mergedDisabled.value) {
+				changeActiveKeys([]);
+				emit("mouseleave", event);
+			}
+		};
+		const onInternalKeyDown = (e) => {
+			emit("keydown", e);
+			if (e.which === KeyCode.ENTER) {
+				const info = getEventInfo(e);
+				emit("click", e);
+				onItemClick(info);
+			}
+		};
+		/**
+		* Used for accessibility. Helper will focus element without key board.
+		* We should manually trigger an active
+		*/
+		const onInternalFocus = (e) => {
+			changeActiveKeys(keysPath.value);
+			emit("focus", e);
+		};
+		const renderItemChildren = (icon, children) => {
+			const wrapNode = createVNode("span", { "class": `${prefixCls.value}-title-content` }, [children]);
+			if (!icon || isValidElement(children) && children.type === "span") {
+				if (children && inlineCollapsed.value && firstLevel && typeof children === "string") return createVNode("div", { "class": `${prefixCls.value}-inline-collapsed-noicon` }, [children.charAt(0)]);
+			}
+			return wrapNode;
+		};
+		const directionStyle = useDirectionStyle(computed(() => keysPath.value.length));
+		return () => {
+			var _a, _b, _c, _d, _e;
+			if (isMeasure) return null;
+			const title = (_a = props.title) !== null && _a !== void 0 ? _a : (_b = slots.title) === null || _b === void 0 ? void 0 : _b.call(slots);
+			const children = flattenChildren((_c = slots.default) === null || _c === void 0 ? void 0 : _c.call(slots));
+			const childrenLength = children.length;
+			let tooltipTitle = title;
+			if (typeof title === "undefined") tooltipTitle = firstLevel && childrenLength ? children : "";
+			else if (title === false) tooltipTitle = "";
+			const tooltipProps = { title: tooltipTitle };
+			if (!siderCollapsed.value && !inlineCollapsed.value) {
+				tooltipProps.title = null;
+				tooltipProps.open = false;
+			}
+			const optionRoleProps = {};
+			if (props.role === "option") optionRoleProps["aria-selected"] = selected.value;
+			const icon = (_d = props.icon) !== null && _d !== void 0 ? _d : (_e = slots.icon) === null || _e === void 0 ? void 0 : _e.call(slots, props);
+			return createVNode(tooltip_default, _objectSpread2(_objectSpread2({}, tooltipProps), {}, {
+				"placement": rtl.value ? "left" : "right",
+				"overlayClassName": `${prefixCls.value}-inline-collapsed-tooltip`
+			}), { default: () => [createVNode(vc_overflow_default.Item, _objectSpread2(_objectSpread2(_objectSpread2({ "component": "li" }, attrs), {}, {
+				"id": props.id,
+				"style": _extends(_extends({}, attrs.style || {}), directionStyle.value),
+				"class": [classNames.value, {
+					[`${attrs.class}`]: !!attrs.class,
+					[`${prefixCls.value}-item-only-child`]: (icon ? childrenLength + 1 : childrenLength) === 1
+				}],
+				"role": props.role || "menuitem",
+				"tabindex": props.disabled ? null : -1,
+				"data-menu-id": key,
+				"aria-disabled": props.disabled
+			}, optionRoleProps), {}, {
+				"onMouseenter": onMouseEnter,
+				"onMouseleave": onMouseLeave,
+				"onClick": onInternalClick,
+				"onKeydown": onInternalKeyDown,
+				"onFocus": onInternalFocus,
+				"title": typeof title === "string" ? title : void 0
+			}), { default: () => [cloneElement(typeof icon === "function" ? icon(props.originItemValue) : icon, { class: `${prefixCls.value}-item-icon` }, false), renderItemChildren(icon, children)] })] });
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/placements.js
+var autoAdjustOverflow = {
+	adjustX: 1,
+	adjustY: 1
+};
+var placements = {
+	topLeft: {
+		points: ["bl", "tl"],
+		overflow: autoAdjustOverflow,
+		offset: [0, -7]
+	},
+	bottomLeft: {
+		points: ["tl", "bl"],
+		overflow: autoAdjustOverflow,
+		offset: [0, 7]
+	},
+	leftTop: {
+		points: ["tr", "tl"],
+		overflow: autoAdjustOverflow,
+		offset: [-4, 0]
+	},
+	rightTop: {
+		points: ["tl", "tr"],
+		overflow: autoAdjustOverflow,
+		offset: [4, 0]
+	}
+};
+var placementsRtl = {
+	topLeft: {
+		points: ["bl", "tl"],
+		overflow: autoAdjustOverflow,
+		offset: [0, -7]
+	},
+	bottomLeft: {
+		points: ["tl", "bl"],
+		overflow: autoAdjustOverflow,
+		offset: [0, 7]
+	},
+	rightTop: {
+		points: ["tr", "tl"],
+		overflow: autoAdjustOverflow,
+		offset: [-4, 0]
+	},
+	leftTop: {
+		points: ["tl", "tr"],
+		overflow: autoAdjustOverflow,
+		offset: [4, 0]
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/PopupTrigger.js
+var popupPlacementMap = {
+	horizontal: "bottomLeft",
+	vertical: "rightTop",
+	"vertical-left": "rightTop",
+	"vertical-right": "leftTop"
+};
+var PopupTrigger_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "PopupTrigger",
+	inheritAttrs: false,
+	props: {
+		prefixCls: String,
+		mode: String,
+		visible: Boolean,
+		popupClassName: String,
+		popupOffset: Array,
+		disabled: Boolean,
+		onVisibleChange: Function
+	},
+	slots: Object,
+	emits: ["visibleChange"],
+	setup(props, _ref) {
+		let { slots, emit } = _ref;
+		const innerVisible = shallowRef(false);
+		const { getPopupContainer, rtl, subMenuOpenDelay, subMenuCloseDelay, builtinPlacements, triggerSubMenuAction, forceSubMenuRender, motion, defaultMotions, rootClassName } = useInjectMenu();
+		const forceRender = useInjectForceRender();
+		const placement = computed(() => rtl.value ? _extends(_extends({}, placementsRtl), builtinPlacements.value) : _extends(_extends({}, placements), builtinPlacements.value));
+		const popupPlacement = computed(() => popupPlacementMap[props.mode]);
+		const visibleRef = shallowRef();
+		watch(() => props.visible, (visible) => {
+			wrapperRaf.cancel(visibleRef.value);
+			visibleRef.value = wrapperRaf(() => {
+				innerVisible.value = visible;
+			});
+		}, { immediate: true });
+		const onVisibleChange = (visible) => {
+			emit("visibleChange", visible);
+		};
+		const mergedMotion = computed(() => {
+			var _a, _b;
+			const m = motion.value || ((_a = defaultMotions.value) === null || _a === void 0 ? void 0 : _a[props.mode]) || ((_b = defaultMotions.value) === null || _b === void 0 ? void 0 : _b.other);
+			const res = typeof m === "function" ? m() : m;
+			return res ? getTransitionProps(res.name, { css: true }) : void 0;
+		});
+		return () => {
+			const { prefixCls, popupClassName, mode, popupOffset, disabled } = props;
+			return createVNode(vc_trigger_default, {
+				"prefixCls": prefixCls,
+				"popupClassName": classNames(`${prefixCls}-popup`, { [`${prefixCls}-rtl`]: rtl.value }, popupClassName, rootClassName.value),
+				"stretch": mode === "horizontal" ? "minWidth" : null,
+				"getPopupContainer": getPopupContainer.value,
+				"builtinPlacements": placement.value,
+				"popupPlacement": popupPlacement.value,
+				"popupVisible": innerVisible.value,
+				"popupAlign": popupOffset && { offset: popupOffset },
+				"action": disabled ? [] : [triggerSubMenuAction.value],
+				"mouseEnterDelay": subMenuOpenDelay.value,
+				"mouseLeaveDelay": subMenuCloseDelay.value,
+				"onPopupVisibleChange": onVisibleChange,
+				"forceRender": forceRender || forceSubMenuRender.value,
+				"popupAnimation": mergedMotion.value
+			}, {
+				popup: slots.popup,
+				default: slots.default
+			});
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/SubMenuList.js
+var InternalSubMenuList = (_props, _ref) => {
+	let { slots, attrs } = _ref;
+	var _a;
+	const { prefixCls, mode } = useInjectMenu();
+	return createVNode("ul", _objectSpread2(_objectSpread2({}, attrs), {}, {
+		"class": classNames(prefixCls.value, `${prefixCls.value}-sub`, `${prefixCls.value}-${mode.value === "inline" ? "inline" : "vertical"}`),
+		"data-menu-list": true
+	}), [(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)]);
+};
+InternalSubMenuList.displayName = "SubMenuList";
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/InlineSubMenuList.js
+var InlineSubMenuList_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "InlineSubMenuList",
+	inheritAttrs: false,
+	props: {
+		id: String,
+		open: Boolean,
+		keyPath: Array
+	},
+	setup(props, _ref) {
+		let { slots } = _ref;
+		const fixedMode = computed(() => "inline");
+		const { motion, mode, defaultMotions } = useInjectMenu();
+		const sameModeRef = computed(() => mode.value === fixedMode.value);
+		const destroy = ref(!sameModeRef.value);
+		const mergedOpen = computed(() => sameModeRef.value ? props.open : false);
+		watch(mode, () => {
+			if (sameModeRef.value) destroy.value = false;
+		}, { flush: "post" });
+		const mergedMotion = computed(() => {
+			var _a, _b;
+			const m = motion.value || ((_a = defaultMotions.value) === null || _a === void 0 ? void 0 : _a[fixedMode.value]) || ((_b = defaultMotions.value) === null || _b === void 0 ? void 0 : _b.other);
+			const res = typeof m === "function" ? m() : m;
+			return _extends(_extends({}, res), { appear: props.keyPath.length <= 1 });
+		});
+		return () => {
+			var _a;
+			if (destroy.value) return null;
+			return createVNode(MenuContextProvider, { "mode": fixedMode.value }, { default: () => [createVNode(Transition, mergedMotion.value, { default: () => [withDirectives(createVNode(InternalSubMenuList, { "id": props.id }, { default: () => [(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)] }), [[vShow, mergedOpen.value]])] })] });
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/SubMenu.js
+var indexGuid = 0;
+var subMenuProps = () => ({
+	icon: PropTypes.any,
+	title: PropTypes.any,
+	disabled: Boolean,
+	level: Number,
+	popupClassName: String,
+	popupOffset: Array,
+	internalPopupClose: Boolean,
+	eventKey: String,
+	expandIcon: Function,
+	theme: String,
+	onMouseenter: Function,
+	onMouseleave: Function,
+	onTitleClick: Function,
+	originItemValue: objectType()
+});
+var SubMenu_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "ASubMenu",
+	inheritAttrs: false,
+	props: subMenuProps(),
+	slots: Object,
+	setup(props, _ref) {
+		let { slots, attrs, emit } = _ref;
+		var _a, _b;
+		useProvideFirstLevel(false);
+		const isMeasure = useMeasure();
+		const instance = getCurrentInstance();
+		const vnodeKey = typeof instance.vnode.key === "symbol" ? String(instance.vnode.key) : instance.vnode.key;
+		devWarning_default(typeof instance.vnode.key !== "symbol", "SubMenu", `SubMenu \`:key="${String(vnodeKey)}"\` not support Symbol type`);
+		const key = isValid(vnodeKey) ? vnodeKey : `sub_menu_${++indexGuid}_$$_not_set_key`;
+		const eventKey = (_a = props.eventKey) !== null && _a !== void 0 ? _a : isValid(vnodeKey) ? `sub_menu_${++indexGuid}_$$_${vnodeKey}` : key;
+		const { parentEventKeys, parentInfo, parentKeys } = useInjectKeyPath();
+		const keysPath = computed(() => [...parentKeys.value, key]);
+		const menuInfo = {
+			eventKey,
+			key,
+			parentEventKeys,
+			childrenEventKeys: shallowRef([]),
+			parentKeys
+		};
+		(_b = parentInfo.childrenEventKeys) === null || _b === void 0 || _b.value.push(eventKey);
+		useProvideKeyPath(eventKey, key, menuInfo);
+		const { prefixCls, activeKeys, disabled: contextDisabled, changeActiveKeys, mode, inlineCollapsed, openKeys, overflowDisabled, onOpenChange, registerMenuInfo, unRegisterMenuInfo, selectedSubMenuKeys, expandIcon: menuExpandIcon, theme } = useInjectMenu();
+		const hasKey = vnodeKey !== void 0 && vnodeKey !== null;
+		const forceRender = !isMeasure && (useInjectForceRender() || !hasKey);
+		useProvideForceRender(forceRender);
+		if (isMeasure && hasKey || !isMeasure && !hasKey || forceRender) registerMenuInfo(eventKey, menuInfo);
+		const subMenuPrefixCls = computed(() => `${prefixCls.value}-submenu`);
+		const mergedDisabled = computed(() => contextDisabled.value || props.disabled);
+		const elementRef = shallowRef();
+		const popupRef = shallowRef();
+		const originOpen = computed(() => openKeys.value.includes(key));
+		const open = computed(() => !overflowDisabled.value && originOpen.value);
+		const childrenSelected = computed(() => {
+			return selectedSubMenuKeys.value.includes(key);
+		});
+		const isActive = shallowRef(false);
+		watch(activeKeys, () => {
+			isActive.value = !!activeKeys.value.find((val) => val === key);
+		}, { immediate: true });
+		const onInternalTitleClick = (e) => {
+			if (mergedDisabled.value) return;
+			emit("titleClick", e, key);
+			if (mode.value === "inline") onOpenChange(key, !originOpen.value);
+		};
+		const onMouseEnter = (event) => {
+			if (!mergedDisabled.value) {
+				changeActiveKeys(keysPath.value);
+				emit("mouseenter", event);
+			}
+		};
+		const onMouseLeave = (event) => {
+			if (!mergedDisabled.value) {
+				changeActiveKeys([]);
+				emit("mouseleave", event);
+			}
+		};
+		const directionStyle = useDirectionStyle(computed(() => keysPath.value.length));
+		const onPopupVisibleChange = (newVisible) => {
+			if (mode.value !== "inline") onOpenChange(key, newVisible);
+		};
+		/**
+		* Used for accessibility. Helper will focus element without key board.
+		* We should manually trigger an active
+		*/
+		const onInternalFocus = () => {
+			changeActiveKeys(keysPath.value);
+		};
+		const popupId = eventKey && `${eventKey}-popup`;
+		const popupClassName = computed(() => classNames(prefixCls.value, `${prefixCls.value}-${props.theme || theme.value}`, props.popupClassName));
+		const renderTitle = (title, icon) => {
+			if (!icon) return inlineCollapsed.value && !parentKeys.value.length && title && typeof title === "string" ? createVNode("div", { "class": `${prefixCls.value}-inline-collapsed-noicon` }, [title.charAt(0)]) : createVNode("span", { "class": `${prefixCls.value}-title-content` }, [title]);
+			const titleIsSpan = isValidElement(title) && title.type === "span";
+			return createVNode(Fragment, null, [cloneElement(typeof icon === "function" ? icon(props.originItemValue) : icon, { class: `${prefixCls.value}-item-icon` }, false), titleIsSpan ? title : createVNode("span", { "class": `${prefixCls.value}-title-content` }, [title])]);
+		};
+		const triggerModeRef = computed(() => {
+			return mode.value !== "inline" && keysPath.value.length > 1 ? "vertical" : mode.value;
+		});
+		const renderMode = computed(() => mode.value === "horizontal" ? "vertical" : mode.value);
+		const subMenuTriggerModeRef = computed(() => triggerModeRef.value === "horizontal" ? "vertical" : triggerModeRef.value);
+		const baseTitleNode = () => {
+			var _a, _b;
+			const subMenuPrefixClsValue = subMenuPrefixCls.value;
+			const icon = (_a = props.icon) !== null && _a !== void 0 ? _a : (_b = slots.icon) === null || _b === void 0 ? void 0 : _b.call(slots, props);
+			const expandIcon = props.expandIcon || slots.expandIcon || menuExpandIcon.value;
+			const title = renderTitle(getPropsSlot(slots, props, "title"), icon);
+			return createVNode("div", {
+				"style": directionStyle.value,
+				"class": `${subMenuPrefixClsValue}-title`,
+				"tabindex": mergedDisabled.value ? null : -1,
+				"ref": elementRef,
+				"title": typeof title === "string" ? title : null,
+				"data-menu-id": key,
+				"aria-expanded": open.value,
+				"aria-haspopup": true,
+				"aria-controls": popupId,
+				"aria-disabled": mergedDisabled.value,
+				"onClick": onInternalTitleClick,
+				"onFocus": onInternalFocus
+			}, [title, mode.value !== "horizontal" && expandIcon ? expandIcon(_extends(_extends({}, props), { isOpen: open.value })) : createVNode("i", { "class": `${subMenuPrefixClsValue}-arrow` }, null)]);
+		};
+		return () => {
+			var _a;
+			if (isMeasure) {
+				if (!hasKey) return null;
+				return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+			}
+			const subMenuPrefixClsValue = subMenuPrefixCls.value;
+			let titleNode = () => null;
+			if (!overflowDisabled.value && mode.value !== "inline") {
+				const popupOffset = mode.value === "horizontal" ? [0, 8] : [10, 0];
+				titleNode = () => createVNode(PopupTrigger_default, {
+					"mode": triggerModeRef.value,
+					"prefixCls": subMenuPrefixClsValue,
+					"visible": !props.internalPopupClose && open.value,
+					"popupClassName": popupClassName.value,
+					"popupOffset": props.popupOffset || popupOffset,
+					"disabled": mergedDisabled.value,
+					"onVisibleChange": onPopupVisibleChange
+				}, {
+					default: () => [baseTitleNode()],
+					popup: () => createVNode(MenuContextProvider, { "mode": subMenuTriggerModeRef.value }, { default: () => [createVNode(InternalSubMenuList, {
+						"id": popupId,
+						"ref": popupRef
+					}, { default: slots.default })] })
+				});
+			} else titleNode = () => createVNode(PopupTrigger_default, null, { default: baseTitleNode });
+			return createVNode(MenuContextProvider, { "mode": renderMode.value }, { default: () => [createVNode(vc_overflow_default.Item, _objectSpread2(_objectSpread2({ "component": "li" }, attrs), {}, {
+				"role": "none",
+				"class": classNames(subMenuPrefixClsValue, `${subMenuPrefixClsValue}-${mode.value}`, attrs.class, {
+					[`${subMenuPrefixClsValue}-open`]: open.value,
+					[`${subMenuPrefixClsValue}-active`]: isActive.value,
+					[`${subMenuPrefixClsValue}-selected`]: childrenSelected.value,
+					[`${subMenuPrefixClsValue}-disabled`]: mergedDisabled.value
+				}),
+				"onMouseenter": onMouseEnter,
+				"onMouseleave": onMouseLeave,
+				"data-submenu-id": key
+			}), { default: () => {
+				return createVNode(Fragment, null, [titleNode(), !overflowDisabled.value && createVNode(InlineSubMenuList_default, {
+					"id": popupId,
+					"open": open.value,
+					"keyPath": keysPath.value
+				}, { default: slots.default })]);
+			} })] });
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/ItemGroup.js
+var menuItemGroupProps = () => ({
+	title: PropTypes.any,
+	originItemValue: objectType()
+});
+var ItemGroup_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "AMenuItemGroup",
+	inheritAttrs: false,
+	props: menuItemGroupProps(),
+	slots: Object,
+	setup(props, _ref) {
+		let { slots, attrs } = _ref;
+		const { prefixCls } = useInjectMenu();
+		const groupPrefixCls = computed(() => `${prefixCls.value}-item-group`);
+		const isMeasure = useMeasure();
+		return () => {
+			var _a, _b;
+			if (isMeasure) return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+			return createVNode("li", _objectSpread2(_objectSpread2({}, attrs), {}, {
+				"onClick": (e) => e.stopPropagation(),
+				"class": groupPrefixCls.value
+			}), [createVNode("div", {
+				"title": typeof props.title === "string" ? props.title : void 0,
+				"class": `${groupPrefixCls.value}-title`
+			}, [getPropsSlot(slots, props, "title")]), createVNode("ul", { "class": `${groupPrefixCls.value}-list` }, [(_b = slots.default) === null || _b === void 0 ? void 0 : _b.call(slots)])]);
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/Divider.js
+var menuDividerProps = () => ({
+	prefixCls: String,
+	dashed: Boolean
+});
+var Divider_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "AMenuDivider",
+	props: menuDividerProps(),
+	setup(props) {
+		const { prefixCls } = useInjectMenu();
+		const cls = computed(() => {
+			return {
+				[`${prefixCls.value}-item-divider`]: true,
+				[`${prefixCls.value}-item-divider-dashed`]: !!props.dashed
+			};
+		});
+		return () => {
+			return createVNode("li", { "class": cls.value }, null);
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/hooks/useItems.js
+var __rest = function(s, e) {
+	var t = {};
+	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+	}
+	return t;
+};
+function convertItemsToNodes(list, store, parentMenuInfo) {
+	return (list || []).map((opt, index) => {
+		if (opt && typeof opt === "object") {
+			const _a = opt, { label, children, key, type } = _a, restProps = __rest(_a, [
+				"label",
+				"children",
+				"key",
+				"type"
+			]);
+			const mergedKey = key !== null && key !== void 0 ? key : `tmp-${index}`;
+			const parentKeys = parentMenuInfo ? parentMenuInfo.parentKeys.slice() : [];
+			const childrenEventKeys = [];
+			const menuInfo = {
+				eventKey: mergedKey,
+				key: mergedKey,
+				parentEventKeys: ref(parentKeys),
+				parentKeys: ref(parentKeys),
+				childrenEventKeys: ref(childrenEventKeys),
+				isLeaf: false
+			};
+			if (children || type === "group") {
+				if (type === "group") {
+					const childrenNodes = convertItemsToNodes(children, store, parentMenuInfo);
+					return createVNode(ItemGroup_default, _objectSpread2(_objectSpread2({ "key": mergedKey }, restProps), {}, {
+						"title": label,
+						"originItemValue": opt
+					}), { default: () => [childrenNodes] });
+				}
+				store.set(mergedKey, menuInfo);
+				if (parentMenuInfo) parentMenuInfo.childrenEventKeys.push(mergedKey);
+				const childrenNodes = convertItemsToNodes(children, store, {
+					childrenEventKeys,
+					parentKeys: [].concat(parentKeys, mergedKey)
+				});
+				return createVNode(SubMenu_default, _objectSpread2(_objectSpread2({ "key": mergedKey }, restProps), {}, {
+					"title": label,
+					"originItemValue": opt
+				}), { default: () => [childrenNodes] });
+			}
+			if (type === "divider") return createVNode(Divider_default, _objectSpread2({ "key": mergedKey }, restProps), null);
+			menuInfo.isLeaf = true;
+			store.set(mergedKey, menuInfo);
+			return createVNode(MenuItem_default, _objectSpread2(_objectSpread2({ "key": mergedKey }, restProps), {}, { "originItemValue": opt }), { default: () => [label] });
+		}
+		return null;
+	}).filter((opt) => opt);
+}
+/**
+* We simply convert `items` to VueNode for reuse origin component logic. But we need move all the
+* logic from component into this hooks when in v4
+*/
+function useItems(props) {
+	const itemsNodes = shallowRef([]);
+	const hasItmes = shallowRef(false);
+	const store = shallowRef(/* @__PURE__ */ new Map());
+	watch(() => props.items, () => {
+		const newStore = /* @__PURE__ */ new Map();
+		hasItmes.value = false;
+		if (props.items) {
+			hasItmes.value = true;
+			itemsNodes.value = convertItemsToNodes(props.items, newStore);
+		} else itemsNodes.value = void 0;
+		store.value = newStore;
+	}, {
+		immediate: true,
+		deep: true
+	});
+	return {
+		itemsNodes,
+		store,
+		hasItmes
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/style/horizontal.js
+var getHorizontalStyle = (token) => {
+	const { componentCls, motionDurationSlow, menuHorizontalHeight, colorSplit, lineWidth, lineType, menuItemPaddingInline } = token;
+	return { [`${componentCls}-horizontal`]: {
+		lineHeight: `${menuHorizontalHeight}px`,
+		border: 0,
+		borderBottom: `${lineWidth}px ${lineType} ${colorSplit}`,
+		boxShadow: "none",
+		"&::after": {
+			display: "block",
+			clear: "both",
+			height: 0,
+			content: "\"\\20\""
+		},
+		[`${componentCls}-item, ${componentCls}-submenu`]: {
+			position: "relative",
+			display: "inline-block",
+			verticalAlign: "bottom",
+			paddingInline: menuItemPaddingInline
+		},
+		[`> ${componentCls}-item:hover,
+        > ${componentCls}-item-active,
+        > ${componentCls}-submenu ${componentCls}-submenu-title:hover`]: { backgroundColor: "transparent" },
+		[`${componentCls}-item, ${componentCls}-submenu-title`]: { transition: [`border-color ${motionDurationSlow}`, `background ${motionDurationSlow}`].join(",") },
+		[`${componentCls}-submenu-arrow`]: { display: "none" }
+	} };
+};
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/style/rtl.js
+var getRTLStyle = (_ref) => {
+	let { componentCls, menuArrowOffset } = _ref;
+	return {
+		[`${componentCls}-rtl`]: { direction: "rtl" },
+		[`${componentCls}-submenu-rtl`]: { transformOrigin: "100% 0" },
+		[`${componentCls}-rtl${componentCls}-vertical,
+    ${componentCls}-submenu-rtl ${componentCls}-vertical`]: { [`${componentCls}-submenu-arrow`]: {
+			"&::before": { transform: `rotate(-45deg) translateY(-${menuArrowOffset})` },
+			"&::after": { transform: `rotate(45deg) translateY(${menuArrowOffset})` }
+		} }
+	};
+};
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/style/theme.js
+var accessibilityFocus = (token) => _extends({}, genFocusOutline(token));
+var getThemeStyle = (token, themeSuffix) => {
+	const { componentCls, colorItemText, colorItemTextSelected, colorGroupTitle, colorItemBg, colorSubItemBg, colorItemBgSelected, colorActiveBarHeight, colorActiveBarWidth, colorActiveBarBorderSize, motionDurationSlow, motionEaseInOut, motionEaseOut, menuItemPaddingInline, motionDurationMid, colorItemTextHover, lineType, colorSplit, colorItemTextDisabled, colorDangerItemText, colorDangerItemTextHover, colorDangerItemTextSelected, colorDangerItemBgActive, colorDangerItemBgSelected, colorItemBgHover, menuSubMenuBg, colorItemTextSelectedHorizontal, colorItemBgSelectedHorizontal } = token;
+	return { [`${componentCls}-${themeSuffix}`]: {
+		color: colorItemText,
+		background: colorItemBg,
+		[`&${componentCls}-root:focus-visible`]: _extends({}, accessibilityFocus(token)),
+		[`${componentCls}-item-group-title`]: { color: colorGroupTitle },
+		[`${componentCls}-submenu-selected`]: { [`> ${componentCls}-submenu-title`]: { color: colorItemTextSelected } },
+		[`${componentCls}-item-disabled, ${componentCls}-submenu-disabled`]: { color: `${colorItemTextDisabled} !important` },
+		[`${componentCls}-item:hover, ${componentCls}-submenu-title:hover`]: { [`&:not(${componentCls}-item-selected):not(${componentCls}-submenu-selected)`]: { color: colorItemTextHover } },
+		[`&:not(${componentCls}-horizontal)`]: {
+			[`${componentCls}-item:not(${componentCls}-item-selected)`]: {
+				"&:hover": { backgroundColor: colorItemBgHover },
+				"&:active": { backgroundColor: colorItemBgSelected }
+			},
+			[`${componentCls}-submenu-title`]: {
+				"&:hover": { backgroundColor: colorItemBgHover },
+				"&:active": { backgroundColor: colorItemBgSelected }
+			}
+		},
+		[`${componentCls}-item-danger`]: {
+			color: colorDangerItemText,
+			[`&${componentCls}-item:hover`]: { [`&:not(${componentCls}-item-selected):not(${componentCls}-submenu-selected)`]: { color: colorDangerItemTextHover } },
+			[`&${componentCls}-item:active`]: { background: colorDangerItemBgActive }
+		},
+		[`${componentCls}-item a`]: { "&, &:hover": { color: "inherit" } },
+		[`${componentCls}-item-selected`]: {
+			color: colorItemTextSelected,
+			[`&${componentCls}-item-danger`]: { color: colorDangerItemTextSelected },
+			[`a, a:hover`]: { color: "inherit" }
+		},
+		[`& ${componentCls}-item-selected`]: {
+			backgroundColor: colorItemBgSelected,
+			[`&${componentCls}-item-danger`]: { backgroundColor: colorDangerItemBgSelected }
+		},
+		[`${componentCls}-item, ${componentCls}-submenu-title`]: { [`&:not(${componentCls}-item-disabled):focus-visible`]: _extends({}, accessibilityFocus(token)) },
+		[`&${componentCls}-submenu > ${componentCls}`]: { backgroundColor: menuSubMenuBg },
+		[`&${componentCls}-popup > ${componentCls}`]: { backgroundColor: colorItemBg },
+		[`&${componentCls}-horizontal`]: _extends(_extends({}, themeSuffix === "dark" ? { borderBottom: 0 } : {}), { [`> ${componentCls}-item, > ${componentCls}-submenu`]: {
+			top: colorActiveBarBorderSize,
+			marginTop: -colorActiveBarBorderSize,
+			marginBottom: 0,
+			borderRadius: 0,
+			"&::after": {
+				position: "absolute",
+				insetInline: menuItemPaddingInline,
+				bottom: 0,
+				borderBottom: `${colorActiveBarHeight}px solid transparent`,
+				transition: `border-color ${motionDurationSlow} ${motionEaseInOut}`,
+				content: "\"\""
+			},
+			[`&:hover, &-active, &-open`]: { "&::after": {
+				borderBottomWidth: colorActiveBarHeight,
+				borderBottomColor: colorItemTextSelectedHorizontal
+			} },
+			[`&-selected`]: {
+				color: colorItemTextSelectedHorizontal,
+				backgroundColor: colorItemBgSelectedHorizontal,
+				"&::after": {
+					borderBottomWidth: colorActiveBarHeight,
+					borderBottomColor: colorItemTextSelectedHorizontal
+				}
+			}
+		} }),
+		[`&${componentCls}-root`]: { [`&${componentCls}-inline, &${componentCls}-vertical`]: { borderInlineEnd: `${colorActiveBarBorderSize}px ${lineType} ${colorSplit}` } },
+		[`&${componentCls}-inline`]: {
+			[`${componentCls}-sub${componentCls}-inline`]: { background: colorSubItemBg },
+			[`${componentCls}-item, ${componentCls}-submenu-title`]: colorActiveBarBorderSize && colorActiveBarWidth ? { width: `calc(100% + ${colorActiveBarBorderSize}px)` } : {},
+			[`${componentCls}-item`]: {
+				position: "relative",
+				"&::after": {
+					position: "absolute",
+					insetBlock: 0,
+					insetInlineEnd: 0,
+					borderInlineEnd: `${colorActiveBarWidth}px solid ${colorItemTextSelected}`,
+					transform: "scaleY(0.0001)",
+					opacity: 0,
+					transition: [`transform ${motionDurationMid} ${motionEaseOut}`, `opacity ${motionDurationMid} ${motionEaseOut}`].join(","),
+					content: "\"\""
+				},
+				[`&${componentCls}-item-danger`]: { "&::after": { borderInlineEndColor: colorDangerItemTextSelected } }
+			},
+			[`${componentCls}-selected, ${componentCls}-item-selected`]: { "&::after": {
+				transform: "scaleY(1)",
+				opacity: 1,
+				transition: [`transform ${motionDurationMid} ${motionEaseInOut}`, `opacity ${motionDurationMid} ${motionEaseInOut}`].join(",")
+			} }
+		}
+	} };
+};
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/style/vertical.js
+var getVerticalInlineStyle = (token) => {
+	const { componentCls, menuItemHeight, itemMarginInline, padding, menuArrowSize, marginXS, marginXXS } = token;
+	const paddingWithArrow = padding + menuArrowSize + marginXS;
+	return {
+		[`${componentCls}-item`]: { position: "relative" },
+		[`${componentCls}-item, ${componentCls}-submenu-title`]: {
+			height: menuItemHeight,
+			lineHeight: `${menuItemHeight}px`,
+			paddingInline: padding,
+			overflow: "hidden",
+			textOverflow: "ellipsis",
+			marginInline: itemMarginInline,
+			marginBlock: marginXXS,
+			width: `calc(100% - ${itemMarginInline * 2}px)`
+		},
+		[`${componentCls}-submenu`]: { paddingBottom: .02 },
+		[`> ${componentCls}-item,
+            > ${componentCls}-submenu > ${componentCls}-submenu-title`]: {
+			height: menuItemHeight,
+			lineHeight: `${menuItemHeight}px`
+		},
+		[`${componentCls}-item-group-list ${componentCls}-submenu-title,
+            ${componentCls}-submenu-title`]: { paddingInlineEnd: paddingWithArrow }
+	};
+};
+var getVerticalStyle = (token) => {
+	const { componentCls, iconCls, menuItemHeight, colorTextLightSolid, dropdownWidth, controlHeightLG, motionDurationMid, motionEaseOut, paddingXL, fontSizeSM, fontSizeLG, motionDurationSlow, paddingXS, boxShadowSecondary } = token;
+	const inlineItemStyle = {
+		height: menuItemHeight,
+		lineHeight: `${menuItemHeight}px`,
+		listStylePosition: "inside",
+		listStyleType: "disc"
+	};
+	return [
+		{
+			[componentCls]: { [`&-inline, &-vertical`]: _extends({ [`&${componentCls}-root`]: { boxShadow: "none" } }, getVerticalInlineStyle(token)) },
+			[`${componentCls}-submenu-popup`]: { [`${componentCls}-vertical`]: _extends(_extends({}, getVerticalInlineStyle(token)), { boxShadow: boxShadowSecondary }) }
+		},
+		{ [`${componentCls}-submenu-popup ${componentCls}-vertical${componentCls}-sub`]: {
+			minWidth: dropdownWidth,
+			maxHeight: `calc(100vh - ${controlHeightLG * 2.5}px)`,
+			padding: "0",
+			overflow: "hidden",
+			borderInlineEnd: 0,
+			"&:not([class*='-active'])": {
+				overflowX: "hidden",
+				overflowY: "auto"
+			}
+		} },
+		{ [`${componentCls}-inline`]: {
+			width: "100%",
+			[`&${componentCls}-root`]: { [`${componentCls}-item, ${componentCls}-submenu-title`]: {
+				display: "flex",
+				alignItems: "center",
+				transition: [
+					`border-color ${motionDurationSlow}`,
+					`background ${motionDurationSlow}`,
+					`padding ${motionDurationMid} ${motionEaseOut}`
+				].join(","),
+				[`> ${componentCls}-title-content`]: {
+					flex: "auto",
+					minWidth: 0,
+					overflow: "hidden",
+					textOverflow: "ellipsis"
+				},
+				"> *": { flex: "none" }
+			} },
+			[`${componentCls}-sub${componentCls}-inline`]: {
+				padding: 0,
+				border: 0,
+				borderRadius: 0,
+				boxShadow: "none",
+				[`& > ${componentCls}-submenu > ${componentCls}-submenu-title`]: inlineItemStyle,
+				[`& ${componentCls}-item-group-title`]: { paddingInlineStart: paddingXL }
+			},
+			[`${componentCls}-item`]: inlineItemStyle
+		} },
+		{ [`${componentCls}-inline-collapsed`]: {
+			width: menuItemHeight * 2,
+			[`&${componentCls}-root`]: { [`${componentCls}-item, ${componentCls}-submenu ${componentCls}-submenu-title`]: { [`> ${componentCls}-inline-collapsed-noicon`]: {
+				fontSize: fontSizeLG,
+				textAlign: "center"
+			} } },
+			[`> ${componentCls}-item,
+          > ${componentCls}-item-group > ${componentCls}-item-group-list > ${componentCls}-item,
+          > ${componentCls}-item-group > ${componentCls}-item-group-list > ${componentCls}-submenu > ${componentCls}-submenu-title,
+          > ${componentCls}-submenu > ${componentCls}-submenu-title`]: {
+				insetInlineStart: 0,
+				paddingInline: `calc(50% - ${fontSizeSM}px)`,
+				textOverflow: "clip",
+				[`
+            ${componentCls}-submenu-arrow,
+            ${componentCls}-submenu-expand-icon
+          `]: { opacity: 0 },
+				[`${componentCls}-item-icon, ${iconCls}`]: {
+					margin: 0,
+					fontSize: fontSizeLG,
+					lineHeight: `${menuItemHeight}px`,
+					"+ span": {
+						display: "inline-block",
+						opacity: 0
+					}
+				}
+			},
+			[`${componentCls}-item-icon, ${iconCls}`]: { display: "inline-block" },
+			"&-tooltip": {
+				pointerEvents: "none",
+				[`${componentCls}-item-icon, ${iconCls}`]: { display: "none" },
+				"a, a:hover": { color: colorTextLightSolid }
+			},
+			[`${componentCls}-item-group-title`]: _extends(_extends({}, textEllipsis), { paddingInline: paddingXS })
+		} }
+	];
+};
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/style/index.js
+var genMenuItemStyle = (token) => {
+	const { componentCls, fontSize, motionDurationSlow, motionDurationMid, motionEaseInOut, motionEaseOut, iconCls, controlHeightSM } = token;
+	return {
+		[`${componentCls}-item, ${componentCls}-submenu-title`]: {
+			position: "relative",
+			display: "block",
+			margin: 0,
+			whiteSpace: "nowrap",
+			cursor: "pointer",
+			transition: [
+				`border-color ${motionDurationSlow}`,
+				`background ${motionDurationSlow}`,
+				`padding ${motionDurationSlow} ${motionEaseInOut}`
+			].join(","),
+			[`${componentCls}-item-icon, ${iconCls}`]: {
+				minWidth: fontSize,
+				fontSize,
+				transition: [
+					`font-size ${motionDurationMid} ${motionEaseOut}`,
+					`margin ${motionDurationSlow} ${motionEaseInOut}`,
+					`color ${motionDurationSlow}`
+				].join(","),
+				"+ span": {
+					marginInlineStart: controlHeightSM - fontSize,
+					opacity: 1,
+					transition: [
+						`opacity ${motionDurationSlow} ${motionEaseInOut}`,
+						`margin ${motionDurationSlow}`,
+						`color ${motionDurationSlow}`
+					].join(",")
+				}
+			},
+			[`${componentCls}-item-icon`]: _extends({}, resetIcon()),
+			[`&${componentCls}-item-only-child`]: { [`> ${iconCls}, > ${componentCls}-item-icon`]: { marginInlineEnd: 0 } }
+		},
+		[`${componentCls}-item-disabled, ${componentCls}-submenu-disabled`]: {
+			background: "none !important",
+			cursor: "not-allowed",
+			"&::after": { borderColor: "transparent !important" },
+			a: { color: "inherit !important" },
+			[`> ${componentCls}-submenu-title`]: {
+				color: "inherit !important",
+				cursor: "not-allowed"
+			}
+		}
+	};
+};
+var genSubMenuArrowStyle = (token) => {
+	const { componentCls, motionDurationSlow, motionEaseInOut, borderRadius, menuArrowSize, menuArrowOffset } = token;
+	return { [`${componentCls}-submenu`]: {
+		[`&-expand-icon, &-arrow`]: {
+			position: "absolute",
+			top: "50%",
+			insetInlineEnd: token.margin,
+			width: menuArrowSize,
+			color: "currentcolor",
+			transform: "translateY(-50%)",
+			transition: `transform ${motionDurationSlow} ${motionEaseInOut}, opacity ${motionDurationSlow}`
+		},
+		"&-arrow": {
+			"&::before, &::after": {
+				position: "absolute",
+				width: menuArrowSize * .6,
+				height: menuArrowSize * .15,
+				backgroundColor: "currentcolor",
+				borderRadius,
+				transition: [
+					`background ${motionDurationSlow} ${motionEaseInOut}`,
+					`transform ${motionDurationSlow} ${motionEaseInOut}`,
+					`top ${motionDurationSlow} ${motionEaseInOut}`,
+					`color ${motionDurationSlow} ${motionEaseInOut}`
+				].join(","),
+				content: "\"\""
+			},
+			"&::before": { transform: `rotate(45deg) translateY(-${menuArrowOffset})` },
+			"&::after": { transform: `rotate(-45deg) translateY(${menuArrowOffset})` }
+		}
+	} };
+};
+var getBaseStyle = (token) => {
+	const { antCls, componentCls, fontSize, motionDurationSlow, motionDurationMid, motionEaseInOut, lineHeight, paddingXS, padding, colorSplit, lineWidth, zIndexPopup, borderRadiusLG, radiusSubMenuItem, menuArrowSize, menuArrowOffset, lineType, menuPanelMaskInset } = token;
+	return [
+		{
+			"": { [`${componentCls}`]: _extends(_extends({}, clearFix()), { [`&-hidden`]: { display: "none" } }) },
+			[`${componentCls}-submenu-hidden`]: { display: "none" }
+		},
+		{ [componentCls]: _extends(_extends(_extends(_extends(_extends(_extends(_extends({}, resetComponent(token)), clearFix()), {
+			marginBottom: 0,
+			paddingInlineStart: 0,
+			fontSize,
+			lineHeight: 0,
+			listStyle: "none",
+			outline: "none",
+			transition: `width ${motionDurationSlow} cubic-bezier(0.2, 0, 0, 1) 0s`,
+			[`ul, ol`]: {
+				margin: 0,
+				padding: 0,
+				listStyle: "none"
+			},
+			[`&-overflow`]: {
+				display: "flex",
+				[`${componentCls}-item`]: { flex: "none" }
+			},
+			[`${componentCls}-item, ${componentCls}-submenu, ${componentCls}-submenu-title`]: { borderRadius: token.radiusItem },
+			[`${componentCls}-item-group-title`]: {
+				padding: `${paddingXS}px ${padding}px`,
+				fontSize,
+				lineHeight,
+				transition: `all ${motionDurationSlow}`
+			},
+			[`&-horizontal ${componentCls}-submenu`]: { transition: [`border-color ${motionDurationSlow} ${motionEaseInOut}`, `background ${motionDurationSlow} ${motionEaseInOut}`].join(",") },
+			[`${componentCls}-submenu, ${componentCls}-submenu-inline`]: { transition: [
+				`border-color ${motionDurationSlow} ${motionEaseInOut}`,
+				`background ${motionDurationSlow} ${motionEaseInOut}`,
+				`padding ${motionDurationMid} ${motionEaseInOut}`
+			].join(",") },
+			[`${componentCls}-submenu ${componentCls}-sub`]: {
+				cursor: "initial",
+				transition: [`background ${motionDurationSlow} ${motionEaseInOut}`, `padding ${motionDurationSlow} ${motionEaseInOut}`].join(",")
+			},
+			[`${componentCls}-title-content`]: { transition: `color ${motionDurationSlow}` },
+			[`${componentCls}-item a`]: { "&::before": {
+				position: "absolute",
+				inset: 0,
+				backgroundColor: "transparent",
+				content: "\"\""
+			} },
+			[`${componentCls}-item-divider`]: {
+				overflow: "hidden",
+				lineHeight: 0,
+				borderColor: colorSplit,
+				borderStyle: lineType,
+				borderWidth: 0,
+				borderTopWidth: lineWidth,
+				marginBlock: lineWidth,
+				padding: 0,
+				"&-dashed": { borderStyle: "dashed" }
+			}
+		}), genMenuItemStyle(token)), {
+			[`${componentCls}-item-group`]: { [`${componentCls}-item-group-list`]: {
+				margin: 0,
+				padding: 0,
+				[`${componentCls}-item, ${componentCls}-submenu-title`]: { paddingInline: `${fontSize * 2}px ${padding}px` }
+			} },
+			"&-submenu": {
+				"&-popup": {
+					position: "absolute",
+					zIndex: zIndexPopup,
+					background: "transparent",
+					borderRadius: borderRadiusLG,
+					boxShadow: "none",
+					transformOrigin: "0 0",
+					"&::before": {
+						position: "absolute",
+						inset: `${menuPanelMaskInset}px 0 0`,
+						zIndex: -1,
+						width: "100%",
+						height: "100%",
+						opacity: 0,
+						content: "\"\""
+					}
+				},
+				"&-placement-rightTop::before": {
+					top: 0,
+					insetInlineStart: menuPanelMaskInset
+				},
+				[`> ${componentCls}`]: _extends(_extends(_extends({ borderRadius: borderRadiusLG }, genMenuItemStyle(token)), genSubMenuArrowStyle(token)), {
+					[`${componentCls}-item, ${componentCls}-submenu > ${componentCls}-submenu-title`]: { borderRadius: radiusSubMenuItem },
+					[`${componentCls}-submenu-title::after`]: { transition: `transform ${motionDurationSlow} ${motionEaseInOut}` }
+				})
+			}
+		}), genSubMenuArrowStyle(token)), {
+			[`&-inline-collapsed ${componentCls}-submenu-arrow,
+        &-inline ${componentCls}-submenu-arrow`]: {
+				"&::before": { transform: `rotate(-45deg) translateX(${menuArrowOffset})` },
+				"&::after": { transform: `rotate(45deg) translateX(-${menuArrowOffset})` }
+			},
+			[`${componentCls}-submenu-open${componentCls}-submenu-inline > ${componentCls}-submenu-title > ${componentCls}-submenu-arrow`]: {
+				transform: `translateY(-${menuArrowSize * .2}px)`,
+				"&::after": { transform: `rotate(-45deg) translateX(-${menuArrowOffset})` },
+				"&::before": { transform: `rotate(45deg) translateX(${menuArrowOffset})` }
+			}
+		}) },
+		{ [`${antCls}-layout-header`]: { [componentCls]: { lineHeight: "inherit" } } }
+	];
+};
+var style_default = ((prefixCls, injectStyle) => {
+	return genComponentStyleHook("Menu", (token, _ref) => {
+		let { overrideComponentToken } = _ref;
+		if ((injectStyle === null || injectStyle === void 0 ? void 0 : injectStyle.value) === false) return [];
+		const { colorBgElevated, colorPrimary, colorError, colorErrorHover, colorTextLightSolid } = token;
+		const { controlHeightLG, fontSize } = token;
+		const menuArrowSize = fontSize / 7 * 5;
+		const menuToken = merge(token, {
+			menuItemHeight: controlHeightLG,
+			menuItemPaddingInline: token.margin,
+			menuArrowSize,
+			menuHorizontalHeight: controlHeightLG * 1.15,
+			menuArrowOffset: `${menuArrowSize * .25}px`,
+			menuPanelMaskInset: -7,
+			menuSubMenuBg: colorBgElevated
+		});
+		const colorTextDark = new TinyColor(colorTextLightSolid).setAlpha(.65).toRgbString();
+		const menuDarkToken = merge(menuToken, {
+			colorItemText: colorTextDark,
+			colorItemTextHover: colorTextLightSolid,
+			colorGroupTitle: colorTextDark,
+			colorItemTextSelected: colorTextLightSolid,
+			colorItemBg: "#001529",
+			colorSubItemBg: "#000c17",
+			colorItemBgActive: "transparent",
+			colorItemBgSelected: colorPrimary,
+			colorActiveBarWidth: 0,
+			colorActiveBarHeight: 0,
+			colorActiveBarBorderSize: 0,
+			colorItemTextDisabled: new TinyColor(colorTextLightSolid).setAlpha(.25).toRgbString(),
+			colorDangerItemText: colorError,
+			colorDangerItemTextHover: colorErrorHover,
+			colorDangerItemTextSelected: colorTextLightSolid,
+			colorDangerItemBgActive: colorError,
+			colorDangerItemBgSelected: colorError,
+			menuSubMenuBg: "#001529",
+			colorItemTextSelectedHorizontal: colorTextLightSolid,
+			colorItemBgSelectedHorizontal: colorPrimary
+		}, _extends({}, overrideComponentToken));
+		return [
+			getBaseStyle(menuToken),
+			getHorizontalStyle(menuToken),
+			getVerticalStyle(menuToken),
+			getThemeStyle(menuToken, "light"),
+			getThemeStyle(menuDarkToken, "dark"),
+			getRTLStyle(menuToken),
+			genCollapseMotion(menuToken),
+			initSlideMotion(menuToken, "slide-up"),
+			initSlideMotion(menuToken, "slide-down"),
+			initZoomMotion(menuToken, "zoom-big")
+		];
+	}, (token) => {
+		const { colorPrimary, colorError, colorTextDisabled, colorErrorBg, colorText, colorTextDescription, colorBgContainer, colorFillAlter, colorFillContent, lineWidth, lineWidthBold, controlItemBgActive, colorBgTextHover } = token;
+		return {
+			dropdownWidth: 160,
+			zIndexPopup: token.zIndexPopupBase + 50,
+			radiusItem: token.borderRadiusLG,
+			radiusSubMenuItem: token.borderRadiusSM,
+			colorItemText: colorText,
+			colorItemTextHover: colorText,
+			colorItemTextHoverHorizontal: colorPrimary,
+			colorGroupTitle: colorTextDescription,
+			colorItemTextSelected: colorPrimary,
+			colorItemTextSelectedHorizontal: colorPrimary,
+			colorItemBg: colorBgContainer,
+			colorItemBgHover: colorBgTextHover,
+			colorItemBgActive: colorFillContent,
+			colorSubItemBg: colorFillAlter,
+			colorItemBgSelected: controlItemBgActive,
+			colorItemBgSelectedHorizontal: "transparent",
+			colorActiveBarWidth: 0,
+			colorActiveBarHeight: lineWidthBold,
+			colorActiveBarBorderSize: lineWidth,
+			colorItemTextDisabled: colorTextDisabled,
+			colorDangerItemText: colorError,
+			colorDangerItemTextHover: colorError,
+			colorDangerItemTextSelected: colorError,
+			colorDangerItemBgActive: colorErrorBg,
+			colorDangerItemBgSelected: colorErrorBg,
+			itemMarginInline: token.marginXXS
+		};
+	})(prefixCls);
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/src/Menu.js
+var menuProps = () => ({
+	id: String,
+	prefixCls: String,
+	items: Array,
+	disabled: Boolean,
+	inlineCollapsed: Boolean,
+	disabledOverflow: Boolean,
+	forceSubMenuRender: Boolean,
+	openKeys: Array,
+	selectedKeys: Array,
+	activeKey: String,
+	selectable: {
+		type: Boolean,
+		default: true
+	},
+	multiple: {
+		type: Boolean,
+		default: false
+	},
+	tabindex: { type: [Number, String] },
+	motion: Object,
+	role: String,
+	theme: {
+		type: String,
+		default: "light"
+	},
+	mode: {
+		type: String,
+		default: "vertical"
+	},
+	inlineIndent: {
+		type: Number,
+		default: 24
+	},
+	subMenuOpenDelay: {
+		type: Number,
+		default: 0
+	},
+	subMenuCloseDelay: {
+		type: Number,
+		default: .1
+	},
+	builtinPlacements: { type: Object },
+	triggerSubMenuAction: {
+		type: String,
+		default: "hover"
+	},
+	getPopupContainer: Function,
+	expandIcon: Function,
+	onOpenChange: Function,
+	onSelect: Function,
+	onDeselect: Function,
+	onClick: [Function, Array],
+	onFocus: Function,
+	onBlur: Function,
+	onMousedown: Function,
+	"onUpdate:openKeys": Function,
+	"onUpdate:selectedKeys": Function,
+	"onUpdate:activeKey": Function
+});
+var EMPTY_LIST = [];
+var Menu_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "AMenu",
+	inheritAttrs: false,
+	props: menuProps(),
+	slots: Object,
+	setup(props, _ref) {
+		let { slots, emit, attrs } = _ref;
+		const { direction, getPrefixCls } = useConfigInject_default("menu", props);
+		const override = useInjectOverride();
+		const prefixCls = computed(() => {
+			var _a;
+			return getPrefixCls("menu", props.prefixCls || ((_a = override === null || override === void 0 ? void 0 : override.prefixCls) === null || _a === void 0 ? void 0 : _a.value));
+		});
+		const [wrapSSR, hashId] = style_default(prefixCls, computed(() => {
+			return !override;
+		}));
+		const store = shallowRef(/* @__PURE__ */ new Map());
+		const siderCollapsed = inject(SiderCollapsedKey, ref(void 0));
+		const inlineCollapsed = computed(() => {
+			if (siderCollapsed.value !== void 0) return siderCollapsed.value;
+			return props.inlineCollapsed;
+		});
+		const { itemsNodes } = useItems(props);
+		const isMounted = shallowRef(false);
+		watchEffect(() => {
+			devWarning_default(!(props.inlineCollapsed === true && props.mode !== "inline"), "Menu", "`inlineCollapsed` should only be used when `mode` is inline.");
+			devWarning_default(!(siderCollapsed.value !== void 0 && props.inlineCollapsed === true), "Menu", "`inlineCollapsed` not control Menu under Sider. Should set `collapsed` on Sider instead.");
+		});
+		const activeKeys = ref([]);
+		const mergedSelectedKeys = ref([]);
+		const keyMapStore = ref({});
+		watch(store, () => {
+			const newKeyMapStore = {};
+			for (const menuInfo of store.value.values()) newKeyMapStore[menuInfo.key] = menuInfo;
+			keyMapStore.value = newKeyMapStore;
+		}, { flush: "post" });
+		watchEffect(() => {
+			if (props.activeKey !== void 0) {
+				let keys = [];
+				const menuInfo = props.activeKey ? keyMapStore.value[props.activeKey] : void 0;
+				if (menuInfo && props.activeKey !== void 0) keys = uniq([].concat(unref(menuInfo.parentKeys), props.activeKey));
+				else keys = [];
+				if (!shallowequal_default(activeKeys.value, keys)) activeKeys.value = keys;
+			}
+		});
+		watch(() => props.selectedKeys, (selectedKeys) => {
+			if (selectedKeys) mergedSelectedKeys.value = selectedKeys.slice();
+		}, {
+			immediate: true,
+			deep: true
+		});
+		const selectedSubMenuKeys = ref([]);
+		watch([keyMapStore, mergedSelectedKeys], () => {
+			let subMenuParentKeys = [];
+			mergedSelectedKeys.value.forEach((key) => {
+				const menuInfo = keyMapStore.value[key];
+				if (menuInfo) subMenuParentKeys = subMenuParentKeys.concat(unref(menuInfo.parentKeys));
+			});
+			subMenuParentKeys = uniq(subMenuParentKeys);
+			if (!shallowequal_default(selectedSubMenuKeys.value, subMenuParentKeys)) selectedSubMenuKeys.value = subMenuParentKeys;
+		}, { immediate: true });
+		const triggerSelection = (info) => {
+			if (props.selectable) {
+				const { key: targetKey } = info;
+				const exist = mergedSelectedKeys.value.includes(targetKey);
+				let newSelectedKeys;
+				if (props.multiple) {
+					if (exist) newSelectedKeys = mergedSelectedKeys.value.filter((key) => key !== targetKey);
+					else newSelectedKeys = [...mergedSelectedKeys.value, targetKey];
+				} else newSelectedKeys = [targetKey];
+				const selectInfo = _extends(_extends({}, info), { selectedKeys: newSelectedKeys });
+				if (!shallowequal_default(newSelectedKeys, mergedSelectedKeys.value)) {
+					if (props.selectedKeys === void 0) mergedSelectedKeys.value = newSelectedKeys;
+					emit("update:selectedKeys", newSelectedKeys);
+					if (exist && props.multiple) emit("deselect", selectInfo);
+					else emit("select", selectInfo);
+				}
+			}
+			if (mergedMode.value !== "inline" && !props.multiple && mergedOpenKeys.value.length) triggerOpenKeys(EMPTY_LIST);
+		};
+		const mergedOpenKeys = ref([]);
+		watch(() => props.openKeys, function() {
+			let openKeys = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : mergedOpenKeys.value;
+			if (!shallowequal_default(mergedOpenKeys.value, openKeys)) mergedOpenKeys.value = openKeys.slice();
+		}, {
+			immediate: true,
+			deep: true
+		});
+		let timeout;
+		const changeActiveKeys = (keys) => {
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				if (props.activeKey === void 0) activeKeys.value = keys;
+				emit("update:activeKey", keys[keys.length - 1]);
+			});
+		};
+		const disabled = computed(() => !!props.disabled);
+		const isRtl = computed(() => direction.value === "rtl");
+		const mergedMode = ref("vertical");
+		const mergedInlineCollapsed = shallowRef(false);
+		watchEffect(() => {
+			var _a;
+			if ((props.mode === "inline" || props.mode === "vertical") && inlineCollapsed.value) {
+				mergedMode.value = "vertical";
+				mergedInlineCollapsed.value = inlineCollapsed.value;
+			} else {
+				mergedMode.value = props.mode;
+				mergedInlineCollapsed.value = false;
+			}
+			if ((_a = override === null || override === void 0 ? void 0 : override.mode) === null || _a === void 0 ? void 0 : _a.value) mergedMode.value = override.mode.value;
+		});
+		const isInlineMode = computed(() => mergedMode.value === "inline");
+		const triggerOpenKeys = (keys) => {
+			mergedOpenKeys.value = keys;
+			emit("update:openKeys", keys);
+			emit("openChange", keys);
+		};
+		const inlineCacheOpenKeys = ref(mergedOpenKeys.value);
+		const mountRef = shallowRef(false);
+		watch(mergedOpenKeys, () => {
+			if (isInlineMode.value) inlineCacheOpenKeys.value = mergedOpenKeys.value;
+		}, { immediate: true });
+		watch(isInlineMode, () => {
+			if (!mountRef.value) {
+				mountRef.value = true;
+				return;
+			}
+			if (isInlineMode.value) mergedOpenKeys.value = inlineCacheOpenKeys.value;
+			else triggerOpenKeys(EMPTY_LIST);
+		}, { immediate: true });
+		const className = computed(() => {
+			return {
+				[`${prefixCls.value}`]: true,
+				[`${prefixCls.value}-root`]: true,
+				[`${prefixCls.value}-${mergedMode.value}`]: true,
+				[`${prefixCls.value}-inline-collapsed`]: mergedInlineCollapsed.value,
+				[`${prefixCls.value}-rtl`]: isRtl.value,
+				[`${prefixCls.value}-${props.theme}`]: true
+			};
+		});
+		const rootPrefixCls = computed(() => getPrefixCls());
+		const defaultMotions = computed(() => ({
+			horizontal: { name: `${rootPrefixCls.value}-slide-up` },
+			inline: collapseMotion(`${rootPrefixCls.value}-motion-collapse`),
+			other: { name: `${rootPrefixCls.value}-zoom-big` }
+		}));
+		useProvideFirstLevel(true);
+		const getChildrenKeys = function() {
+			let eventKeys = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+			const keys = [];
+			const storeValue = store.value;
+			eventKeys.forEach((eventKey) => {
+				const { key, childrenEventKeys } = storeValue.get(eventKey);
+				keys.push(key, ...getChildrenKeys(unref(childrenEventKeys)));
+			});
+			return keys;
+		};
+		/**
+		* Click for item. SubMenu do not have selection status
+		*/
+		const onInternalClick = (info) => {
+			var _a;
+			emit("click", info);
+			triggerSelection(info);
+			(_a = override === null || override === void 0 ? void 0 : override.onClick) === null || _a === void 0 || _a.call(override);
+		};
+		const onInternalOpenChange = (key, open) => {
+			var _a;
+			const childrenEventKeys = ((_a = keyMapStore.value[key]) === null || _a === void 0 ? void 0 : _a.childrenEventKeys) || [];
+			let newOpenKeys = mergedOpenKeys.value.filter((k) => k !== key);
+			if (open) newOpenKeys.push(key);
+			else if (mergedMode.value !== "inline") {
+				const subPathKeys = getChildrenKeys(unref(childrenEventKeys));
+				newOpenKeys = uniq(newOpenKeys.filter((k) => !subPathKeys.includes(k)));
+			}
+			if (!shallowequal_default(mergedOpenKeys, newOpenKeys)) triggerOpenKeys(newOpenKeys);
+		};
+		const registerMenuInfo = (key, info) => {
+			store.value.set(key, info);
+			store.value = new Map(store.value);
+		};
+		const unRegisterMenuInfo = (key) => {
+			store.value.delete(key);
+			store.value = new Map(store.value);
+		};
+		const lastVisibleIndex = ref(0);
+		const expandIcon = computed(() => {
+			var _a;
+			return props.expandIcon || slots.expandIcon || ((_a = override === null || override === void 0 ? void 0 : override.expandIcon) === null || _a === void 0 ? void 0 : _a.value) ? (opt) => {
+				let icon = props.expandIcon || slots.expandIcon;
+				icon = typeof icon === "function" ? icon(opt) : icon;
+				return cloneElement(icon, { class: `${prefixCls.value}-submenu-expand-icon` }, false);
+			} : null;
+		});
+		useProvideMenu({
+			prefixCls,
+			activeKeys,
+			openKeys: mergedOpenKeys,
+			selectedKeys: mergedSelectedKeys,
+			changeActiveKeys,
+			disabled,
+			rtl: isRtl,
+			mode: mergedMode,
+			inlineIndent: computed(() => props.inlineIndent),
+			subMenuCloseDelay: computed(() => props.subMenuCloseDelay),
+			subMenuOpenDelay: computed(() => props.subMenuOpenDelay),
+			builtinPlacements: computed(() => props.builtinPlacements),
+			triggerSubMenuAction: computed(() => props.triggerSubMenuAction),
+			getPopupContainer: computed(() => props.getPopupContainer),
+			inlineCollapsed: mergedInlineCollapsed,
+			theme: computed(() => props.theme),
+			siderCollapsed,
+			defaultMotions: computed(() => isMounted.value ? defaultMotions.value : null),
+			motion: computed(() => isMounted.value ? props.motion : null),
+			overflowDisabled: shallowRef(void 0),
+			onOpenChange: onInternalOpenChange,
+			onItemClick: onInternalClick,
+			registerMenuInfo,
+			unRegisterMenuInfo,
+			selectedSubMenuKeys,
+			expandIcon,
+			forceSubMenuRender: computed(() => props.forceSubMenuRender),
+			rootClassName: hashId
+		});
+		const getChildrenList = () => {
+			var _a;
+			return itemsNodes.value || flattenChildren((_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots));
+		};
+		return () => {
+			var _a;
+			const childList = getChildrenList();
+			const allVisible = lastVisibleIndex.value >= childList.length - 1 || mergedMode.value !== "horizontal" || props.disabledOverflow;
+			const getWrapperList = (childList) => {
+				return mergedMode.value !== "horizontal" || props.disabledOverflow ? childList : childList.map((child, index) => createVNode(MenuContextProvider, {
+					"key": child.key,
+					"overflowDisabled": index > lastVisibleIndex.value
+				}, { default: () => child }));
+			};
+			const overflowedIndicator = ((_a = slots.overflowedIndicator) === null || _a === void 0 ? void 0 : _a.call(slots)) || createVNode(EllipsisOutlined, null, null);
+			return wrapSSR(createVNode(vc_overflow_default, _objectSpread2(_objectSpread2({}, attrs), {}, {
+				"onMousedown": props.onMousedown,
+				"prefixCls": `${prefixCls.value}-overflow`,
+				"component": "ul",
+				"itemComponent": MenuItem_default,
+				"class": [
+					className.value,
+					attrs.class,
+					hashId.value
+				],
+				"role": "menu",
+				"id": props.id,
+				"data": getWrapperList(childList),
+				"renderRawItem": (node) => node,
+				"renderRawRest": (omitItems) => {
+					const len = omitItems.length;
+					const originOmitItems = len ? childList.slice(-len) : null;
+					return createVNode(Fragment, null, [createVNode(SubMenu_default, {
+						"eventKey": OVERFLOW_KEY,
+						"key": OVERFLOW_KEY,
+						"title": overflowedIndicator,
+						"disabled": allVisible,
+						"internalPopupClose": len === 0
+					}, { default: () => originOmitItems }), createVNode(PathContext, null, { default: () => [createVNode(SubMenu_default, {
+						"eventKey": OVERFLOW_KEY,
+						"key": OVERFLOW_KEY,
+						"title": overflowedIndicator,
+						"disabled": allVisible,
+						"internalPopupClose": len === 0
+					}, { default: () => originOmitItems })] })]);
+				},
+				"maxCount": mergedMode.value !== "horizontal" || props.disabledOverflow ? vc_overflow_default.INVALIDATE : vc_overflow_default.RESPONSIVE,
+				"ssr": "full",
+				"data-menu-list": true,
+				"onVisibleChange": (newLastIndex) => {
+					lastVisibleIndex.value = newLastIndex;
+				}
+			}), { default: () => [createVNode(Teleport, { "to": "body" }, { default: () => [createVNode("div", {
+				"style": { display: "none" },
+				"aria-hidden": true
+			}, [createVNode(PathContext, null, { default: () => [getWrapperList(getChildrenList())] })])] })] }));
+		};
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ant-design-vue@4.2.6_vue@3.5.41_typescript@5.9.3_/node_modules/ant-design-vue/es/menu/index.js
+/* istanbul ignore next */
+Menu_default.install = function(app) {
+	app.component(Menu_default.name, Menu_default);
+	app.component(MenuItem_default.name, MenuItem_default);
+	app.component(SubMenu_default.name, SubMenu_default);
+	app.component(Divider_default.name, Divider_default);
+	app.component(ItemGroup_default.name, ItemGroup_default);
+	return app;
+};
+Menu_default.Item = MenuItem_default;
+Menu_default.Divider = Divider_default;
+Menu_default.SubMenu = SubMenu_default;
+Menu_default.ItemGroup = ItemGroup_default;
+var menu_default = Menu_default;
+
+export { Divider_default as D, EllipsisOutlined as E, MenuItem_default as M, SiderHookProviderKey as S, SiderCollapsedKey as a, menu_default as m, shallowequal_default as s, useProvideOverride as u, vc_dropdown_default as v };
+//# sourceMappingURL=menu-BXt-X0dt.mjs.map