agentworkshop 0.7.66 → 0.7.71

package/.output/server/chunks/_/SearchOutlined.mjs

@@ -0,0 +1,1401 @@
+import { q as classNames, x as genComponentStyleHook, r as _objectSpread2, P as PropTypes, av as findDOMNode, o as _extends, y as merge, aN as clearFix, L as Keyframe, bg as initMotion, b8 as genCompactItemStyle, K as resetComponent, aT as Icon } from '../virtual/entry.mjs';
+import { i as index } from '../build/firstNotUndefined-8H5_qHUu.mjs';
+import { defineComponent, computed, shallowRef, watch, createVNode, reactive, getCurrentInstance, ref, provide, inject } from 'vue';
+
+//#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-resize-observer/index.js
+var vc_resize_observer_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "ResizeObserver",
+	props: {
+		disabled: Boolean,
+		onResize: Function
+	},
+	emits: ["resize"],
+	setup(props, _ref) {
+		let { slots } = _ref;
+		const state = reactive({
+			width: 0,
+			height: 0,
+			offsetHeight: 0,
+			offsetWidth: 0
+		});
+		let currentElement = null;
+		let resizeObserver = null;
+		const destroyObserver = () => {
+			if (resizeObserver) {
+				resizeObserver.disconnect();
+				resizeObserver = null;
+			}
+		};
+		const onResize = (entries) => {
+			const { onResize } = props;
+			const target = entries[0].target;
+			const { width, height } = target.getBoundingClientRect();
+			const { offsetWidth, offsetHeight } = target;
+			/**
+			* Resize observer trigger when content size changed.
+			* In most case we just care about element size,
+			* let's use `boundary` instead of `contentRect` here to avoid shaking.
+			*/
+			const fixedWidth = Math.floor(width);
+			const fixedHeight = Math.floor(height);
+			if (state.width !== fixedWidth || state.height !== fixedHeight || state.offsetWidth !== offsetWidth || state.offsetHeight !== offsetHeight) {
+				const size = {
+					width: fixedWidth,
+					height: fixedHeight,
+					offsetWidth,
+					offsetHeight
+				};
+				_extends(state, size);
+				if (onResize) Promise.resolve().then(() => {
+					onResize(_extends(_extends({}, size), {
+						offsetWidth,
+						offsetHeight
+					}), target);
+				});
+			}
+		};
+		const instance = getCurrentInstance();
+		const registerObserver = () => {
+			const { disabled } = props;
+			if (disabled) {
+				destroyObserver();
+				return;
+			}
+			const element = findDOMNode(instance);
+			if (element !== currentElement) {
+				destroyObserver();
+				currentElement = element;
+			}
+			if (!resizeObserver && element) {
+				resizeObserver = new index(onResize);
+				resizeObserver.observe(element);
+			}
+		};
+		watch(() => props.disabled, () => {
+			registerObserver();
+		}, { flush: "post" });
+		return () => {
+			var _a;
+			return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)[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/_util/BaseInputInner.js
+var __rest$4 = 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;
+};
+var BaseInputInner = defineComponent({
+	compatConfig: { MODE: 3 },
+	props: {
+		disabled: PropTypes.looseBool,
+		type: PropTypes.string,
+		value: PropTypes.any,
+		tag: {
+			type: String,
+			default: "input"
+		},
+		size: PropTypes.string,
+		onChange: Function,
+		onInput: Function,
+		onBlur: Function,
+		onFocus: Function,
+		onKeydown: Function,
+		onCompositionstart: Function,
+		onCompositionend: Function,
+		onKeyup: Function,
+		onPaste: Function,
+		onMousedown: Function
+	},
+	emits: [
+		"change",
+		"input",
+		"blur",
+		"keydown",
+		"focus",
+		"compositionstart",
+		"compositionend",
+		"keyup",
+		"paste",
+		"mousedown"
+	],
+	setup(props, _ref) {
+		let { expose } = _ref;
+		const inputRef = shallowRef(null);
+		const focus = () => {
+			if (inputRef.value) inputRef.value.focus();
+		};
+		const blur = () => {
+			if (inputRef.value) inputRef.value.blur();
+		};
+		const setSelectionRange = (start, end, direction) => {
+			var _a;
+			(_a = inputRef.value) === null || _a === void 0 || _a.setSelectionRange(start, end, direction);
+		};
+		const select = () => {
+			var _a;
+			(_a = inputRef.value) === null || _a === void 0 || _a.select();
+		};
+		expose({
+			focus,
+			blur,
+			input: inputRef,
+			setSelectionRange,
+			select,
+			getSelectionStart: () => {
+				var _a;
+				return (_a = inputRef.value) === null || _a === void 0 ? void 0 : _a.selectionStart;
+			},
+			getSelectionEnd: () => {
+				var _a;
+				return (_a = inputRef.value) === null || _a === void 0 ? void 0 : _a.selectionEnd;
+			},
+			getScrollTop: () => {
+				var _a;
+				return (_a = inputRef.value) === null || _a === void 0 ? void 0 : _a.scrollTop;
+			}
+		});
+		return () => {
+			const { tag: Tag, value } = props, restProps = __rest$4(props, ["tag", "value"]);
+			return createVNode(Tag, _objectSpread2(_objectSpread2({}, restProps), {}, {
+				"ref": inputRef,
+				"value": 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/vc-util/Dom/css.js
+function getOffset(node) {
+	const box = node.getBoundingClientRect();
+	const docElem = (void 0).documentElement;
+	return {
+		left: box.left + ((void 0).scrollX || docElem.scrollLeft) - (docElem.clientLeft || (void 0).body.clientLeft || 0),
+		top: box.top + ((void 0).scrollY || docElem.scrollTop) - (docElem.clientTop || (void 0).body.clientTop || 0)
+	};
+}
+function styleObjectToString(style) {
+	return Object.keys(style).reduce((acc, name) => {
+		const styleValue = style[name];
+		if (typeof styleValue === "undefined" || styleValue === null) return acc;
+		acc += `${name}: ${style[name]};`;
+		return acc;
+	}, "");
+}
+//#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/BaseInput.js
+var __rest$3 = 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;
+};
+var BaseInput = defineComponent({
+	compatConfig: { MODE: 3 },
+	inheritAttrs: false,
+	props: {
+		disabled: PropTypes.looseBool,
+		type: PropTypes.string,
+		value: PropTypes.any,
+		lazy: PropTypes.bool.def(true),
+		tag: {
+			type: String,
+			default: "input"
+		},
+		size: PropTypes.string,
+		style: PropTypes.oneOfType([String, Object]),
+		class: PropTypes.string
+	},
+	emits: [
+		"change",
+		"input",
+		"blur",
+		"keydown",
+		"focus",
+		"compositionstart",
+		"compositionend",
+		"keyup",
+		"paste",
+		"mousedown"
+	],
+	setup(props, _ref) {
+		let { emit, attrs, expose } = _ref;
+		const inputRef = shallowRef(null);
+		const renderValue = ref();
+		const isComposing = ref(false);
+		watch([() => props.value, isComposing], () => {
+			if (isComposing.value) return;
+			renderValue.value = props.value;
+		}, { immediate: true });
+		const handleChange = (e) => {
+			emit("change", e);
+		};
+		const onCompositionstart = (e) => {
+			isComposing.value = true;
+			e.target.composing = true;
+			emit("compositionstart", e);
+		};
+		const onCompositionend = (e) => {
+			isComposing.value = false;
+			e.target.composing = false;
+			emit("compositionend", e);
+			const event = (void 0).createEvent("HTMLEvents");
+			event.initEvent("input", true, true);
+			e.target.dispatchEvent(event);
+			handleChange(e);
+		};
+		const handleInput = (e) => {
+			if (isComposing.value && props.lazy) {
+				renderValue.value = e.target.value;
+				return;
+			}
+			emit("input", e);
+		};
+		const handleBlur = (e) => {
+			emit("blur", e);
+		};
+		const handleFocus = (e) => {
+			emit("focus", e);
+		};
+		const focus = () => {
+			if (inputRef.value) inputRef.value.focus();
+		};
+		const blur = () => {
+			if (inputRef.value) inputRef.value.blur();
+		};
+		const handleKeyDown = (e) => {
+			emit("keydown", e);
+		};
+		const handleKeyUp = (e) => {
+			emit("keyup", e);
+		};
+		const setSelectionRange = (start, end, direction) => {
+			var _a;
+			(_a = inputRef.value) === null || _a === void 0 || _a.setSelectionRange(start, end, direction);
+		};
+		const select = () => {
+			var _a;
+			(_a = inputRef.value) === null || _a === void 0 || _a.select();
+		};
+		expose({
+			focus,
+			blur,
+			input: computed(() => {
+				var _a;
+				return (_a = inputRef.value) === null || _a === void 0 ? void 0 : _a.input;
+			}),
+			setSelectionRange,
+			select,
+			getSelectionStart: () => {
+				var _a;
+				return (_a = inputRef.value) === null || _a === void 0 ? void 0 : _a.getSelectionStart();
+			},
+			getSelectionEnd: () => {
+				var _a;
+				return (_a = inputRef.value) === null || _a === void 0 ? void 0 : _a.getSelectionEnd();
+			},
+			getScrollTop: () => {
+				var _a;
+				return (_a = inputRef.value) === null || _a === void 0 ? void 0 : _a.getScrollTop();
+			}
+		});
+		const handleMousedown = (e) => {
+			emit("mousedown", e);
+		};
+		const handlePaste = (e) => {
+			emit("paste", e);
+		};
+		const styleString = computed(() => {
+			return props.style && typeof props.style !== "string" ? styleObjectToString(props.style) : props.style;
+		});
+		return () => {
+			const { style, lazy } = props, restProps = __rest$3(props, ["style", "lazy"]);
+			return createVNode(BaseInputInner, _objectSpread2(_objectSpread2(_objectSpread2({}, restProps), attrs), {}, {
+				"style": styleString.value,
+				"onInput": handleInput,
+				"onChange": handleChange,
+				"onBlur": handleBlur,
+				"onFocus": handleFocus,
+				"ref": inputRef,
+				"value": renderValue.value,
+				"onCompositionstart": onCompositionstart,
+				"onCompositionend": onCompositionend,
+				"onKeyup": handleKeyUp,
+				"onKeydown": handleKeyDown,
+				"onPaste": handlePaste,
+				"onMousedown": handleMousedown
+			}), 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/vc-overflow/context.js
+var OverflowContextProviderKey = Symbol("OverflowContextProviderKey");
+var OverflowContextProvider = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "OverflowContextProvider",
+	inheritAttrs: false,
+	props: { value: { type: Object } },
+	setup(props, _ref) {
+		let { slots } = _ref;
+		provide(OverflowContextProviderKey, computed(() => props.value));
+		return () => {
+			var _a;
+			return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+		};
+	}
+});
+var useInjectOverflowContext = () => {
+	return inject(OverflowContextProviderKey, computed(() => 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/vc-overflow/Item.js
+var __rest$2 = 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;
+};
+var UNDEFINED = void 0;
+var Item_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "Item",
+	props: {
+		prefixCls: String,
+		item: PropTypes.any,
+		renderItem: Function,
+		responsive: Boolean,
+		itemKey: { type: [String, Number] },
+		registerSize: Function,
+		display: Boolean,
+		order: Number,
+		component: PropTypes.any,
+		invalidate: Boolean
+	},
+	setup(props, _ref) {
+		let { slots, expose } = _ref;
+		const mergedHidden = computed(() => props.responsive && !props.display);
+		const itemNodeRef = ref();
+		expose({ itemNodeRef });
+		function internalRegisterSize(width) {
+			props.registerSize(props.itemKey, width);
+		}
+		return () => {
+			var _a;
+			const { prefixCls, invalidate, item, renderItem, responsive, registerSize, itemKey, display, order, component: Component = "div" } = props, restProps = __rest$2(props, [
+				"prefixCls",
+				"invalidate",
+				"item",
+				"renderItem",
+				"responsive",
+				"registerSize",
+				"itemKey",
+				"display",
+				"order",
+				"component"
+			]);
+			const children = (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+			const childNode = renderItem && item !== UNDEFINED ? renderItem(item) : children;
+			let overflowStyle;
+			if (!invalidate) overflowStyle = {
+				opacity: mergedHidden.value ? 0 : 1,
+				height: mergedHidden.value ? 0 : UNDEFINED,
+				overflowY: mergedHidden.value ? "hidden" : UNDEFINED,
+				order: responsive ? order : UNDEFINED,
+				pointerEvents: mergedHidden.value ? "none" : UNDEFINED,
+				position: mergedHidden.value ? "absolute" : UNDEFINED
+			};
+			const overflowProps = {};
+			if (mergedHidden.value) overflowProps["aria-hidden"] = true;
+			return createVNode(vc_resize_observer_default, {
+				"disabled": !responsive,
+				"onResize": (_ref2) => {
+					let { offsetWidth } = _ref2;
+					internalRegisterSize(offsetWidth);
+				}
+			}, { default: () => createVNode(Component, _objectSpread2(_objectSpread2(_objectSpread2({
+				"class": classNames(!invalidate && prefixCls),
+				"style": overflowStyle
+			}, overflowProps), restProps), {}, { "ref": itemNodeRef }), { default: () => [childNode] }) });
+		};
+	}
+});
+//#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-overflow/RawItem.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;
+};
+var RawItem_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "RawItem",
+	inheritAttrs: false,
+	props: {
+		component: PropTypes.any,
+		title: PropTypes.any,
+		id: String,
+		onMouseenter: { type: Function },
+		onMouseleave: { type: Function },
+		onClick: { type: Function },
+		onKeydown: { type: Function },
+		onFocus: { type: Function },
+		role: String,
+		tabindex: Number
+	},
+	setup(props, _ref) {
+		let { slots, attrs } = _ref;
+		const context = useInjectOverflowContext();
+		return () => {
+			var _a;
+			if (!context.value) {
+				const { component: Component = "div" } = props, restProps = __rest$1(props, ["component"]);
+				return createVNode(Component, _objectSpread2(_objectSpread2({}, restProps), attrs), { default: () => [(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)] });
+			}
+			const _b = context.value, { className: contextClassName } = _b, restContext = __rest$1(_b, ["className"]);
+			const { class: className } = attrs, restProps = __rest$1(attrs, ["class"]);
+			return createVNode(OverflowContextProvider, { "value": null }, { default: () => [createVNode(Item_default, _objectSpread2(_objectSpread2(_objectSpread2({ "class": classNames(contextClassName, className) }, restContext), restProps), props), 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/vc-overflow/Overflow.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;
+};
+var RESPONSIVE = "responsive";
+var INVALIDATE = "invalidate";
+function defaultRenderRest(omittedItems) {
+	return `+ ${omittedItems.length} ...`;
+}
+var overflowProps = () => {
+	return {
+		id: String,
+		prefixCls: String,
+		data: Array,
+		itemKey: [
+			String,
+			Number,
+			Function
+		],
+		/** Used for `responsive`. It will limit render node to avoid perf issue */
+		itemWidth: {
+			type: Number,
+			default: 10
+		},
+		renderItem: Function,
+		/** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+		renderRawItem: Function,
+		maxCount: [Number, String],
+		renderRest: Function,
+		/** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+		renderRawRest: Function,
+		suffix: PropTypes.any,
+		component: String,
+		itemComponent: PropTypes.any,
+		/** @private This API may be refactor since not well design */
+		onVisibleChange: Function,
+		/** When set to `full`, ssr will render full items by default and remove at client side */
+		ssr: String,
+		onMousedown: Function,
+		role: String
+	};
+};
+var Overflow = defineComponent({
+	name: "Overflow",
+	inheritAttrs: false,
+	props: overflowProps(),
+	emits: ["visibleChange"],
+	setup(props, _ref) {
+		let { attrs, emit, slots } = _ref;
+		const fullySSR = computed(() => props.ssr === "full");
+		const containerWidth = shallowRef(null);
+		const mergedContainerWidth = computed(() => containerWidth.value || 0);
+		const itemWidths = shallowRef(/* @__PURE__ */ new Map());
+		const prevRestWidth = shallowRef(0);
+		const restWidth = shallowRef(0);
+		const suffixWidth = shallowRef(0);
+		const suffixFixedStart = shallowRef(null);
+		const displayCount = shallowRef(null);
+		const mergedDisplayCount = computed(() => {
+			if (displayCount.value === null && fullySSR.value) return Number.MAX_SAFE_INTEGER;
+			return displayCount.value || 0;
+		});
+		const restReady = shallowRef(false);
+		const itemPrefixCls = computed(() => `${props.prefixCls}-item`);
+		const mergedRestWidth = computed(() => Math.max(prevRestWidth.value, restWidth.value));
+		const isResponsive = computed(() => !!(props.data.length && props.maxCount === RESPONSIVE));
+		const invalidate = computed(() => props.maxCount === INVALIDATE);
+		/**
+		* When is `responsive`, we will always render rest node to get the real width of it for calculation
+		*/
+		const showRest = computed(() => isResponsive.value || typeof props.maxCount === "number" && props.data.length > props.maxCount);
+		const mergedData = computed(() => {
+			let items = props.data;
+			if (isResponsive.value) {
+				if (containerWidth.value === null && fullySSR.value) items = props.data;
+				else items = props.data.slice(0, Math.min(props.data.length, mergedContainerWidth.value / props.itemWidth));
+			} else if (typeof props.maxCount === "number") items = props.data.slice(0, props.maxCount);
+			return items;
+		});
+		const omittedItems = computed(() => {
+			if (isResponsive.value) return props.data.slice(mergedDisplayCount.value + 1);
+			return props.data.slice(mergedData.value.length);
+		});
+		const getKey = (item, index) => {
+			var _a;
+			if (typeof props.itemKey === "function") return props.itemKey(item);
+			return (_a = props.itemKey && (item === null || item === void 0 ? void 0 : item[props.itemKey])) !== null && _a !== void 0 ? _a : index;
+		};
+		const mergedRenderItem = computed(() => props.renderItem || ((item) => item));
+		const updateDisplayCount = (count, notReady) => {
+			displayCount.value = count;
+			if (!notReady) {
+				restReady.value = count < props.data.length - 1;
+				emit("visibleChange", count);
+			}
+		};
+		const onOverflowResize = (_, element) => {
+			containerWidth.value = element.clientWidth;
+		};
+		const registerSize = (key, width) => {
+			const clone = new Map(itemWidths.value);
+			if (width === null) clone.delete(key);
+			else clone.set(key, width);
+			itemWidths.value = clone;
+		};
+		const registerOverflowSize = (_, width) => {
+			prevRestWidth.value = restWidth.value;
+			restWidth.value = width;
+		};
+		const registerSuffixSize = (_, width) => {
+			suffixWidth.value = width;
+		};
+		const getItemWidth = (index) => {
+			return itemWidths.value.get(getKey(mergedData.value[index], index));
+		};
+		watch([
+			mergedContainerWidth,
+			itemWidths,
+			restWidth,
+			suffixWidth,
+			() => props.itemKey,
+			mergedData
+		], () => {
+			if (mergedContainerWidth.value && mergedRestWidth.value && mergedData.value) {
+				let totalWidth = suffixWidth.value;
+				const len = mergedData.value.length;
+				const lastIndex = len - 1;
+				if (!len) {
+					updateDisplayCount(0);
+					suffixFixedStart.value = null;
+					return;
+				}
+				for (let i = 0; i < len; i += 1) {
+					const currentItemWidth = getItemWidth(i);
+					if (currentItemWidth === void 0) {
+						updateDisplayCount(i - 1, true);
+						break;
+					}
+					totalWidth += currentItemWidth;
+					if (lastIndex === 0 && totalWidth <= mergedContainerWidth.value || i === lastIndex - 1 && totalWidth + getItemWidth(lastIndex) <= mergedContainerWidth.value) {
+						updateDisplayCount(lastIndex);
+						suffixFixedStart.value = null;
+						break;
+					} else if (totalWidth + mergedRestWidth.value > mergedContainerWidth.value) {
+						updateDisplayCount(i - 1);
+						suffixFixedStart.value = totalWidth - currentItemWidth - suffixWidth.value + restWidth.value;
+						break;
+					}
+				}
+				if (props.suffix && getItemWidth(0) + suffixWidth.value > mergedContainerWidth.value) suffixFixedStart.value = null;
+			}
+		});
+		return () => {
+			const displayRest = restReady.value && !!omittedItems.value.length;
+			const { itemComponent, renderRawItem, renderRawRest, renderRest, prefixCls = "rc-overflow", suffix, component: Component = "div", id, onMousedown } = props;
+			const { class: className, style } = attrs, restAttrs = __rest(attrs, ["class", "style"]);
+			let suffixStyle = {};
+			if (suffixFixedStart.value !== null && isResponsive.value) suffixStyle = {
+				position: "absolute",
+				left: `${suffixFixedStart.value}px`,
+				top: 0
+			};
+			const itemSharedProps = {
+				prefixCls: itemPrefixCls.value,
+				responsive: isResponsive.value,
+				component: itemComponent,
+				invalidate: invalidate.value
+			};
+			const internalRenderItemNode = renderRawItem ? (item, index) => {
+				const key = getKey(item, index);
+				return createVNode(OverflowContextProvider, {
+					"key": key,
+					"value": _extends(_extends({}, itemSharedProps), {
+						order: index,
+						item,
+						itemKey: key,
+						registerSize,
+						display: index <= mergedDisplayCount.value
+					})
+				}, { default: () => [renderRawItem(item, index)] });
+			} : (item, index) => {
+				const key = getKey(item, index);
+				return createVNode(Item_default, _objectSpread2(_objectSpread2({}, itemSharedProps), {}, {
+					"order": index,
+					"key": key,
+					"item": item,
+					"renderItem": mergedRenderItem.value,
+					"itemKey": key,
+					"registerSize": registerSize,
+					"display": index <= mergedDisplayCount.value
+				}), null);
+			};
+			let restNode = () => null;
+			const restContextProps = {
+				order: displayRest ? mergedDisplayCount.value : Number.MAX_SAFE_INTEGER,
+				className: `${itemPrefixCls.value} ${itemPrefixCls.value}-rest`,
+				registerSize: registerOverflowSize,
+				display: displayRest
+			};
+			if (!renderRawRest) {
+				const mergedRenderRest = renderRest || defaultRenderRest;
+				restNode = () => createVNode(Item_default, _objectSpread2(_objectSpread2({}, itemSharedProps), restContextProps), { default: () => typeof mergedRenderRest === "function" ? mergedRenderRest(omittedItems.value) : mergedRenderRest });
+			} else if (renderRawRest) restNode = () => createVNode(OverflowContextProvider, { "value": _extends(_extends({}, itemSharedProps), restContextProps) }, { default: () => [renderRawRest(omittedItems.value)] });
+			const overflowNode = () => {
+				var _a;
+				return createVNode(Component, _objectSpread2({
+					"id": id,
+					"class": classNames(!invalidate.value && prefixCls, className),
+					"style": style,
+					"onMousedown": onMousedown,
+					"role": props.role
+				}, restAttrs), { default: () => [
+					mergedData.value.map(internalRenderItemNode),
+					showRest.value ? restNode() : null,
+					suffix && createVNode(Item_default, _objectSpread2(_objectSpread2({}, itemSharedProps), {}, {
+						"order": mergedDisplayCount.value,
+						"class": `${itemPrefixCls.value}-suffix`,
+						"registerSize": registerSuffixSize,
+						"display": true,
+						"style": suffixStyle
+					}), { default: () => suffix }),
+					(_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)
+				] });
+			};
+			return createVNode(vc_resize_observer_default, {
+				"disabled": !isResponsive.value,
+				"onResize": onOverflowResize
+			}, { default: overflowNode });
+		};
+	}
+});
+Overflow.Item = RawItem_default;
+Overflow.RESPONSIVE = RESPONSIVE;
+Overflow.INVALIDATE = INVALIDATE;
+//#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-overflow/index.js
+var vc_overflow_default = Overflow;
+//#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/statusUtils.js
+function getStatusClassNames(prefixCls, status, hasFeedback) {
+	return classNames({
+		[`${prefixCls}-status-success`]: status === "success",
+		[`${prefixCls}-status-warning`]: status === "warning",
+		[`${prefixCls}-status-error`]: status === "error",
+		[`${prefixCls}-status-validating`]: status === "validating",
+		[`${prefixCls}-has-feedback`]: hasFeedback
+	});
+}
+var getMergedStatus = (contextStatus, customStatus) => customStatus || contextStatus;
+//#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/style/motion/slide.js
+var slideUpIn = new Keyframe("antSlideUpIn", {
+	"0%": {
+		transform: "scaleY(0.8)",
+		transformOrigin: "0% 0%",
+		opacity: 0
+	},
+	"100%": {
+		transform: "scaleY(1)",
+		transformOrigin: "0% 0%",
+		opacity: 1
+	}
+});
+var slideUpOut = new Keyframe("antSlideUpOut", {
+	"0%": {
+		transform: "scaleY(1)",
+		transformOrigin: "0% 0%",
+		opacity: 1
+	},
+	"100%": {
+		transform: "scaleY(0.8)",
+		transformOrigin: "0% 0%",
+		opacity: 0
+	}
+});
+var slideDownIn = new Keyframe("antSlideDownIn", {
+	"0%": {
+		transform: "scaleY(0.8)",
+		transformOrigin: "100% 100%",
+		opacity: 0
+	},
+	"100%": {
+		transform: "scaleY(1)",
+		transformOrigin: "100% 100%",
+		opacity: 1
+	}
+});
+var slideDownOut = new Keyframe("antSlideDownOut", {
+	"0%": {
+		transform: "scaleY(1)",
+		transformOrigin: "100% 100%",
+		opacity: 1
+	},
+	"100%": {
+		transform: "scaleY(0.8)",
+		transformOrigin: "100% 100%",
+		opacity: 0
+	}
+});
+var slideLeftIn = new Keyframe("antSlideLeftIn", {
+	"0%": {
+		transform: "scaleX(0.8)",
+		transformOrigin: "0% 0%",
+		opacity: 0
+	},
+	"100%": {
+		transform: "scaleX(1)",
+		transformOrigin: "0% 0%",
+		opacity: 1
+	}
+});
+var slideLeftOut = new Keyframe("antSlideLeftOut", {
+	"0%": {
+		transform: "scaleX(1)",
+		transformOrigin: "0% 0%",
+		opacity: 1
+	},
+	"100%": {
+		transform: "scaleX(0.8)",
+		transformOrigin: "0% 0%",
+		opacity: 0
+	}
+});
+var slideRightIn = new Keyframe("antSlideRightIn", {
+	"0%": {
+		transform: "scaleX(0.8)",
+		transformOrigin: "100% 0%",
+		opacity: 0
+	},
+	"100%": {
+		transform: "scaleX(1)",
+		transformOrigin: "100% 0%",
+		opacity: 1
+	}
+});
+var slideRightOut = new Keyframe("antSlideRightOut", {
+	"0%": {
+		transform: "scaleX(1)",
+		transformOrigin: "100% 0%",
+		opacity: 1
+	},
+	"100%": {
+		transform: "scaleX(0.8)",
+		transformOrigin: "100% 0%",
+		opacity: 0
+	}
+});
+var slideMotion = {
+	"slide-up": {
+		inKeyframes: slideUpIn,
+		outKeyframes: slideUpOut
+	},
+	"slide-down": {
+		inKeyframes: slideDownIn,
+		outKeyframes: slideDownOut
+	},
+	"slide-left": {
+		inKeyframes: slideLeftIn,
+		outKeyframes: slideLeftOut
+	},
+	"slide-right": {
+		inKeyframes: slideRightIn,
+		outKeyframes: slideRightOut
+	}
+};
+var initSlideMotion = (token, motionName) => {
+	const { antCls } = token;
+	const motionCls = `${antCls}-${motionName}`;
+	const { inKeyframes, outKeyframes } = slideMotion[motionName];
+	return [initMotion(motionCls, inKeyframes, outKeyframes, token.motionDurationMid), {
+		[`
+      ${motionCls}-enter,
+      ${motionCls}-appear
+    `]: {
+			transform: "scale(0)",
+			transformOrigin: "0% 0%",
+			opacity: 0,
+			animationTimingFunction: token.motionEaseOutQuint
+		},
+		[`${motionCls}-leave`]: { animationTimingFunction: token.motionEaseInQuint }
+	}];
+};
+//#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/input/style/index.js
+var genPlaceholderStyle = (color) => ({
+	"&::-moz-placeholder": { opacity: 1 },
+	"&::placeholder": {
+		color,
+		userSelect: "none"
+	},
+	"&:placeholder-shown": { textOverflow: "ellipsis" }
+});
+var genHoverStyle = (token) => ({
+	borderColor: token.inputBorderHoverColor,
+	borderInlineEndWidth: token.lineWidth
+});
+var genActiveStyle = (token) => ({
+	borderColor: token.inputBorderHoverColor,
+	boxShadow: `0 0 0 ${token.controlOutlineWidth}px ${token.controlOutline}`,
+	borderInlineEndWidth: token.lineWidth,
+	outline: 0
+});
+var genDisabledStyle = (token) => ({
+	color: token.colorTextDisabled,
+	backgroundColor: token.colorBgContainerDisabled,
+	borderColor: token.colorBorder,
+	boxShadow: "none",
+	cursor: "not-allowed",
+	opacity: 1,
+	"&:hover": _extends({}, genHoverStyle(merge(token, { inputBorderHoverColor: token.colorBorder })))
+});
+var genInputLargeStyle = (token) => {
+	const { inputPaddingVerticalLG, fontSizeLG, lineHeightLG, borderRadiusLG, inputPaddingHorizontalLG } = token;
+	return {
+		padding: `${inputPaddingVerticalLG}px ${inputPaddingHorizontalLG}px`,
+		fontSize: fontSizeLG,
+		lineHeight: lineHeightLG,
+		borderRadius: borderRadiusLG
+	};
+};
+var genInputSmallStyle = (token) => ({
+	padding: `${token.inputPaddingVerticalSM}px ${token.controlPaddingHorizontalSM - 1}px`,
+	borderRadius: token.borderRadiusSM
+});
+var genStatusStyle = (token, parentCls) => {
+	const { componentCls, colorError, colorWarning, colorErrorOutline, colorWarningOutline, colorErrorBorderHover, colorWarningBorderHover } = token;
+	return {
+		[`&-status-error:not(${parentCls}-disabled):not(${parentCls}-borderless)${parentCls}`]: {
+			borderColor: colorError,
+			"&:hover": { borderColor: colorErrorBorderHover },
+			"&:focus, &-focused": _extends({}, genActiveStyle(merge(token, {
+				inputBorderActiveColor: colorError,
+				inputBorderHoverColor: colorError,
+				controlOutline: colorErrorOutline
+			}))),
+			[`${componentCls}-prefix`]: { color: colorError }
+		},
+		[`&-status-warning:not(${parentCls}-disabled):not(${parentCls}-borderless)${parentCls}`]: {
+			borderColor: colorWarning,
+			"&:hover": { borderColor: colorWarningBorderHover },
+			"&:focus, &-focused": _extends({}, genActiveStyle(merge(token, {
+				inputBorderActiveColor: colorWarning,
+				inputBorderHoverColor: colorWarning,
+				controlOutline: colorWarningOutline
+			}))),
+			[`${componentCls}-prefix`]: { color: colorWarning }
+		}
+	};
+};
+var genBasicInputStyle = (token) => _extends(_extends({
+	position: "relative",
+	display: "inline-block",
+	width: "100%",
+	minWidth: 0,
+	padding: `${token.inputPaddingVertical}px ${token.inputPaddingHorizontal}px`,
+	color: token.colorText,
+	fontSize: token.fontSize,
+	lineHeight: token.lineHeight,
+	backgroundColor: token.colorBgContainer,
+	backgroundImage: "none",
+	borderWidth: token.lineWidth,
+	borderStyle: token.lineType,
+	borderColor: token.colorBorder,
+	borderRadius: token.borderRadius,
+	transition: `all ${token.motionDurationMid}`
+}, genPlaceholderStyle(token.colorTextPlaceholder)), {
+	"&:hover": _extends({}, genHoverStyle(token)),
+	"&:focus, &-focused": _extends({}, genActiveStyle(token)),
+	"&-disabled, &[disabled]": _extends({}, genDisabledStyle(token)),
+	"&-borderless": { "&, &:hover, &:focus, &-focused, &-disabled, &[disabled]": {
+		backgroundColor: "transparent",
+		border: "none",
+		boxShadow: "none"
+	} },
+	"textarea&": {
+		maxWidth: "100%",
+		height: "auto",
+		minHeight: token.controlHeight,
+		lineHeight: token.lineHeight,
+		verticalAlign: "bottom",
+		transition: `all ${token.motionDurationSlow}, height 0s`,
+		resize: "vertical"
+	},
+	"&-lg": _extends({}, genInputLargeStyle(token)),
+	"&-sm": _extends({}, genInputSmallStyle(token)),
+	"&-rtl": { direction: "rtl" },
+	"&-textarea-rtl": { direction: "rtl" }
+});
+var genInputGroupStyle = (token) => {
+	const { componentCls, antCls } = token;
+	return {
+		position: "relative",
+		display: "table",
+		width: "100%",
+		borderCollapse: "separate",
+		borderSpacing: 0,
+		[`&[class*='col-']`]: {
+			paddingInlineEnd: token.paddingXS,
+			"&:last-child": { paddingInlineEnd: 0 }
+		},
+		[`&-lg ${componentCls}, &-lg > ${componentCls}-group-addon`]: _extends({}, genInputLargeStyle(token)),
+		[`&-sm ${componentCls}, &-sm > ${componentCls}-group-addon`]: _extends({}, genInputSmallStyle(token)),
+		[`> ${componentCls}`]: {
+			display: "table-cell",
+			"&:not(:first-child):not(:last-child)": { borderRadius: 0 }
+		},
+		[`${componentCls}-group`]: {
+			[`&-addon, &-wrap`]: {
+				display: "table-cell",
+				width: 1,
+				whiteSpace: "nowrap",
+				verticalAlign: "middle",
+				"&:not(:first-child):not(:last-child)": { borderRadius: 0 }
+			},
+			"&-wrap > *": { display: "block !important" },
+			"&-addon": {
+				position: "relative",
+				padding: `0 ${token.inputPaddingHorizontal}px`,
+				color: token.colorText,
+				fontWeight: "normal",
+				fontSize: token.fontSize,
+				textAlign: "center",
+				backgroundColor: token.colorFillAlter,
+				border: `${token.lineWidth}px ${token.lineType} ${token.colorBorder}`,
+				borderRadius: token.borderRadius,
+				transition: `all ${token.motionDurationSlow}`,
+				lineHeight: 1,
+				[`${antCls}-select`]: {
+					margin: `-${token.inputPaddingVertical + 1}px -${token.inputPaddingHorizontal}px`,
+					[`&${antCls}-select-single:not(${antCls}-select-customize-input)`]: { [`${antCls}-select-selector`]: {
+						backgroundColor: "inherit",
+						border: `${token.lineWidth}px ${token.lineType} transparent`,
+						boxShadow: "none"
+					} },
+					"&-open, &-focused": { [`${antCls}-select-selector`]: { color: token.colorPrimary } }
+				},
+				[`${antCls}-cascader-picker`]: {
+					margin: `-9px -${token.inputPaddingHorizontal}px`,
+					backgroundColor: "transparent",
+					[`${antCls}-cascader-input`]: {
+						textAlign: "start",
+						border: 0,
+						boxShadow: "none"
+					}
+				}
+			},
+			"&-addon:first-child": { borderInlineEnd: 0 },
+			"&-addon:last-child": { borderInlineStart: 0 }
+		},
+		[`${componentCls}`]: {
+			float: "inline-start",
+			width: "100%",
+			marginBottom: 0,
+			textAlign: "inherit",
+			"&:focus": {
+				zIndex: 1,
+				borderInlineEndWidth: 1
+			},
+			"&:hover": {
+				zIndex: 1,
+				borderInlineEndWidth: 1,
+				[`${componentCls}-search-with-button &`]: { zIndex: 0 }
+			}
+		},
+		[`> ${componentCls}:first-child, ${componentCls}-group-addon:first-child`]: {
+			borderStartEndRadius: 0,
+			borderEndEndRadius: 0,
+			[`${antCls}-select ${antCls}-select-selector`]: {
+				borderStartEndRadius: 0,
+				borderEndEndRadius: 0
+			}
+		},
+		[`> ${componentCls}-affix-wrapper`]: {
+			[`&:not(:first-child) ${componentCls}`]: {
+				borderStartStartRadius: 0,
+				borderEndStartRadius: 0
+			},
+			[`&:not(:last-child) ${componentCls}`]: {
+				borderStartEndRadius: 0,
+				borderEndEndRadius: 0
+			}
+		},
+		[`> ${componentCls}:last-child, ${componentCls}-group-addon:last-child`]: {
+			borderStartStartRadius: 0,
+			borderEndStartRadius: 0,
+			[`${antCls}-select ${antCls}-select-selector`]: {
+				borderStartStartRadius: 0,
+				borderEndStartRadius: 0
+			}
+		},
+		[`${componentCls}-affix-wrapper`]: {
+			"&:not(:last-child)": {
+				borderStartEndRadius: 0,
+				borderEndEndRadius: 0,
+				[`${componentCls}-search &`]: {
+					borderStartStartRadius: token.borderRadius,
+					borderEndStartRadius: token.borderRadius
+				}
+			},
+			[`&:not(:first-child), ${componentCls}-search &:not(:first-child)`]: {
+				borderStartStartRadius: 0,
+				borderEndStartRadius: 0
+			}
+		},
+		[`&${componentCls}-group-compact`]: _extends(_extends({ display: "block" }, clearFix()), {
+			[`${componentCls}-group-addon, ${componentCls}-group-wrap, > ${componentCls}`]: { "&:not(:first-child):not(:last-child)": {
+				borderInlineEndWidth: token.lineWidth,
+				"&:hover": { zIndex: 1 },
+				"&:focus": { zIndex: 1 }
+			} },
+			"& > *": {
+				display: "inline-block",
+				float: "none",
+				verticalAlign: "top",
+				borderRadius: 0
+			},
+			[`& > ${componentCls}-affix-wrapper`]: { display: "inline-flex" },
+			[`& > ${antCls}-picker-range`]: { display: "inline-flex" },
+			"& > *:not(:last-child)": {
+				marginInlineEnd: -token.lineWidth,
+				borderInlineEndWidth: token.lineWidth
+			},
+			[`${componentCls}`]: { float: "none" },
+			[`& > ${antCls}-select > ${antCls}-select-selector,
+      & > ${antCls}-select-auto-complete ${componentCls},
+      & > ${antCls}-cascader-picker ${componentCls},
+      & > ${componentCls}-group-wrapper ${componentCls}`]: {
+				borderInlineEndWidth: token.lineWidth,
+				borderRadius: 0,
+				"&:hover": { zIndex: 1 },
+				"&:focus": { zIndex: 1 }
+			},
+			[`& > ${antCls}-select-focused`]: { zIndex: 1 },
+			[`& > ${antCls}-select > ${antCls}-select-arrow`]: { zIndex: 1 },
+			[`& > *:first-child,
+      & > ${antCls}-select:first-child > ${antCls}-select-selector,
+      & > ${antCls}-select-auto-complete:first-child ${componentCls},
+      & > ${antCls}-cascader-picker:first-child ${componentCls}`]: {
+				borderStartStartRadius: token.borderRadius,
+				borderEndStartRadius: token.borderRadius
+			},
+			[`& > *:last-child,
+      & > ${antCls}-select:last-child > ${antCls}-select-selector,
+      & > ${antCls}-cascader-picker:last-child ${componentCls},
+      & > ${antCls}-cascader-picker-focused:last-child ${componentCls}`]: {
+				borderInlineEndWidth: token.lineWidth,
+				borderStartEndRadius: token.borderRadius,
+				borderEndEndRadius: token.borderRadius
+			},
+			[`& > ${antCls}-select-auto-complete ${componentCls}`]: { verticalAlign: "top" },
+			[`${componentCls}-group-wrapper + ${componentCls}-group-wrapper`]: {
+				marginInlineStart: -token.lineWidth,
+				[`${componentCls}-affix-wrapper`]: { borderRadius: 0 }
+			},
+			[`${componentCls}-group-wrapper:not(:last-child)`]: { [`&${componentCls}-search > ${componentCls}-group`]: {
+				[`& > ${componentCls}-group-addon > ${componentCls}-search-button`]: { borderRadius: 0 },
+				[`& > ${componentCls}`]: {
+					borderStartStartRadius: token.borderRadius,
+					borderStartEndRadius: 0,
+					borderEndEndRadius: 0,
+					borderEndStartRadius: token.borderRadius
+				}
+			} }
+		}),
+		[`&&-sm ${antCls}-btn`]: {
+			fontSize: token.fontSizeSM,
+			height: token.controlHeightSM,
+			lineHeight: "normal"
+		},
+		[`&&-lg ${antCls}-btn`]: {
+			fontSize: token.fontSizeLG,
+			height: token.controlHeightLG,
+			lineHeight: "normal"
+		},
+		[`&&-lg ${antCls}-select-single ${antCls}-select-selector`]: {
+			height: `${token.controlHeightLG}px`,
+			[`${antCls}-select-selection-item, ${antCls}-select-selection-placeholder`]: { lineHeight: `${token.controlHeightLG - 2}px` },
+			[`${antCls}-select-selection-search-input`]: { height: `${token.controlHeightLG}px` }
+		},
+		[`&&-sm ${antCls}-select-single ${antCls}-select-selector`]: {
+			height: `${token.controlHeightSM}px`,
+			[`${antCls}-select-selection-item, ${antCls}-select-selection-placeholder`]: { lineHeight: `${token.controlHeightSM - 2}px` },
+			[`${antCls}-select-selection-search-input`]: { height: `${token.controlHeightSM}px` }
+		}
+	};
+};
+var genInputStyle = (token) => {
+	const { componentCls, controlHeightSM, lineWidth } = token;
+	const colorSmallPadding = (controlHeightSM - lineWidth * 2 - 16) / 2;
+	return { [componentCls]: _extends(_extends(_extends(_extends({}, resetComponent(token)), genBasicInputStyle(token)), genStatusStyle(token, componentCls)), { "&[type=\"color\"]": {
+		height: token.controlHeight,
+		[`&${componentCls}-lg`]: { height: token.controlHeightLG },
+		[`&${componentCls}-sm`]: {
+			height: controlHeightSM,
+			paddingTop: colorSmallPadding,
+			paddingBottom: colorSmallPadding
+		}
+	} }) };
+};
+var genAllowClearStyle = (token) => {
+	const { componentCls } = token;
+	return {
+		[`${componentCls}-clear-icon`]: {
+			margin: 0,
+			color: token.colorTextQuaternary,
+			fontSize: token.fontSizeIcon,
+			verticalAlign: -1,
+			cursor: "pointer",
+			transition: `color ${token.motionDurationSlow}`,
+			"&:hover": { color: token.colorTextTertiary },
+			"&:active": { color: token.colorText },
+			"&-hidden": { visibility: "hidden" },
+			"&-has-suffix": { margin: `0 ${token.inputAffixPadding}px` }
+		},
+		"&-textarea-with-clear-btn": {
+			padding: "0 !important",
+			border: "0 !important",
+			[`${componentCls}-clear-icon`]: {
+				position: "absolute",
+				insetBlockStart: token.paddingXS,
+				insetInlineEnd: token.paddingXS,
+				zIndex: 1
+			}
+		}
+	};
+};
+var genAffixStyle = (token) => {
+	const { componentCls, inputAffixPadding, colorTextDescription, motionDurationSlow, colorIcon, colorIconHover, iconCls } = token;
+	return { [`${componentCls}-affix-wrapper`]: _extends(_extends(_extends(_extends(_extends({}, genBasicInputStyle(token)), {
+		display: "inline-flex",
+		[`&:not(${componentCls}-affix-wrapper-disabled):hover`]: _extends(_extends({}, genHoverStyle(token)), {
+			zIndex: 1,
+			[`${componentCls}-search-with-button &`]: { zIndex: 0 }
+		}),
+		"&-focused, &:focus": { zIndex: 1 },
+		"&-disabled": { [`${componentCls}[disabled]`]: { background: "transparent" } },
+		[`> input${componentCls}`]: {
+			padding: 0,
+			fontSize: "inherit",
+			border: "none",
+			borderRadius: 0,
+			outline: "none",
+			"&:focus": { boxShadow: "none !important" }
+		},
+		"&::before": {
+			width: 0,
+			visibility: "hidden",
+			content: "\"\\a0\""
+		},
+		[`${componentCls}`]: {
+			"&-prefix, &-suffix": {
+				display: "flex",
+				flex: "none",
+				alignItems: "center",
+				"> *:not(:last-child)": { marginInlineEnd: token.paddingXS }
+			},
+			"&-show-count-suffix": { color: colorTextDescription },
+			"&-show-count-has-suffix": { marginInlineEnd: token.paddingXXS },
+			"&-prefix": { marginInlineEnd: inputAffixPadding },
+			"&-suffix": { marginInlineStart: inputAffixPadding }
+		}
+	}), genAllowClearStyle(token)), { [`${iconCls}${componentCls}-password-icon`]: {
+		color: colorIcon,
+		cursor: "pointer",
+		transition: `all ${motionDurationSlow}`,
+		"&:hover": { color: colorIconHover }
+	} }), genStatusStyle(token, `${componentCls}-affix-wrapper`)) };
+};
+var genGroupStyle = (token) => {
+	const { componentCls, colorError, colorSuccess, borderRadiusLG, borderRadiusSM } = token;
+	return { [`${componentCls}-group`]: _extends(_extends(_extends({}, resetComponent(token)), genInputGroupStyle(token)), {
+		"&-rtl": { direction: "rtl" },
+		"&-wrapper": {
+			display: "inline-block",
+			width: "100%",
+			textAlign: "start",
+			verticalAlign: "top",
+			"&-rtl": { direction: "rtl" },
+			"&-lg": { [`${componentCls}-group-addon`]: { borderRadius: borderRadiusLG } },
+			"&-sm": { [`${componentCls}-group-addon`]: { borderRadius: borderRadiusSM } },
+			"&-status-error": { [`${componentCls}-group-addon`]: {
+				color: colorError,
+				borderColor: colorError
+			} },
+			"&-status-warning": { [`${componentCls}-group-addon:last-child`]: {
+				color: colorSuccess,
+				borderColor: colorSuccess
+			} }
+		}
+	}) };
+};
+var genSearchInputStyle = (token) => {
+	const { componentCls, antCls } = token;
+	const searchPrefixCls = `${componentCls}-search`;
+	return { [searchPrefixCls]: {
+		[`${componentCls}`]: { "&:hover, &:focus": {
+			borderColor: token.colorPrimaryHover,
+			[`+ ${componentCls}-group-addon ${searchPrefixCls}-button:not(${antCls}-btn-primary)`]: { borderInlineStartColor: token.colorPrimaryHover }
+		} },
+		[`${componentCls}-affix-wrapper`]: { borderRadius: 0 },
+		[`${componentCls}-lg`]: { lineHeight: token.lineHeightLG - 2e-4 },
+		[`> ${componentCls}-group`]: { [`> ${componentCls}-group-addon:last-child`]: {
+			insetInlineStart: -1,
+			padding: 0,
+			border: 0,
+			[`${searchPrefixCls}-button`]: {
+				paddingTop: 0,
+				paddingBottom: 0,
+				borderStartStartRadius: 0,
+				borderStartEndRadius: token.borderRadius,
+				borderEndEndRadius: token.borderRadius,
+				borderEndStartRadius: 0
+			},
+			[`${searchPrefixCls}-button:not(${antCls}-btn-primary)`]: {
+				color: token.colorTextDescription,
+				"&:hover": { color: token.colorPrimaryHover },
+				"&:active": { color: token.colorPrimaryActive },
+				[`&${antCls}-btn-loading::before`]: {
+					insetInlineStart: 0,
+					insetInlineEnd: 0,
+					insetBlockStart: 0,
+					insetBlockEnd: 0
+				}
+			}
+		} },
+		[`${searchPrefixCls}-button`]: {
+			height: token.controlHeight,
+			"&:hover, &:focus": { zIndex: 1 }
+		},
+		[`&-large ${searchPrefixCls}-button`]: { height: token.controlHeightLG },
+		[`&-small ${searchPrefixCls}-button`]: { height: token.controlHeightSM },
+		"&-rtl": { direction: "rtl" },
+		[`&${componentCls}-compact-item`]: {
+			[`&:not(${componentCls}-compact-last-item)`]: { [`${componentCls}-group-addon`]: { [`${componentCls}-search-button`]: {
+				marginInlineEnd: -token.lineWidth,
+				borderRadius: 0
+			} } },
+			[`&:not(${componentCls}-compact-first-item)`]: { [`${componentCls},${componentCls}-affix-wrapper`]: { borderRadius: 0 } },
+			[`> ${componentCls}-group-addon ${componentCls}-search-button,
+        > ${componentCls},
+        ${componentCls}-affix-wrapper`]: { "&:hover,&:focus,&:active": { zIndex: 2 } },
+			[`> ${componentCls}-affix-wrapper-focused`]: { zIndex: 2 }
+		}
+	} };
+};
+function initInputToken(token) {
+	return merge(token, {
+		inputAffixPadding: token.paddingXXS,
+		inputPaddingVertical: Math.max(Math.round((token.controlHeight - token.fontSize * token.lineHeight) / 2 * 10) / 10 - token.lineWidth, 3),
+		inputPaddingVerticalLG: Math.ceil((token.controlHeightLG - token.fontSizeLG * token.lineHeightLG) / 2 * 10) / 10 - token.lineWidth,
+		inputPaddingVerticalSM: Math.max(Math.round((token.controlHeightSM - token.fontSize * token.lineHeight) / 2 * 10) / 10 - token.lineWidth, 0),
+		inputPaddingHorizontal: token.paddingSM - token.lineWidth,
+		inputPaddingHorizontalSM: token.paddingXS - token.lineWidth,
+		inputPaddingHorizontalLG: token.controlPaddingHorizontal - token.lineWidth,
+		inputBorderHoverColor: token.colorPrimaryHover,
+		inputBorderActiveColor: token.colorPrimaryHover
+	});
+}
+var genTextAreaStyle = (token) => {
+	const { componentCls, inputPaddingHorizontal, paddingLG } = token;
+	const textareaPrefixCls = `${componentCls}-textarea`;
+	return { [textareaPrefixCls]: {
+		position: "relative",
+		[`${textareaPrefixCls}-suffix`]: {
+			position: "absolute",
+			top: 0,
+			insetInlineEnd: inputPaddingHorizontal,
+			bottom: 0,
+			zIndex: 1,
+			display: "inline-flex",
+			alignItems: "center",
+			margin: "auto"
+		},
+		[`&-status-error,
+        &-status-warning,
+        &-status-success,
+        &-status-validating`]: { [`&${textareaPrefixCls}-has-feedback`]: { [`${componentCls}`]: { paddingInlineEnd: paddingLG } } },
+		"&-show-count": {
+			[`> ${componentCls}`]: { height: "100%" },
+			"&::after": {
+				color: token.colorTextDescription,
+				whiteSpace: "nowrap",
+				content: "attr(data-count)",
+				pointerEvents: "none",
+				float: "right"
+			}
+		},
+		"&-rtl": { "&::after": { float: "left" } }
+	} };
+};
+var style_default = genComponentStyleHook("Input", (token) => {
+	const inputToken = initInputToken(token);
+	return [
+		genInputStyle(inputToken),
+		genTextAreaStyle(inputToken),
+		genAffixStyle(inputToken),
+		genGroupStyle(inputToken),
+		genSearchInputStyle(inputToken),
+		genCompactItemStyle(inputToken)
+	];
+});
+
+// This icon file is generated automatically.
+var SearchOutlined$1 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M909.6 854.5L649.9 594.8C690.2 542.7 712 479 712 412c0-80.2-31.3-155.4-87.9-212.1-56.6-56.7-132-87.9-212.1-87.9s-155.5 31.3-212.1 87.9C143.2 256.5 112 331.8 112 412c0 80.1 31.3 155.5 87.9 212.1C256.5 680.8 331.8 712 412 712c67 0 130.6-21.8 182.7-62l259.7 259.6a8.2 8.2 0 0011.6 0l43.6-43.5a8.2 8.2 0 000-11.6zM570.4 570.4C528 612.7 471.8 636 412 636s-116-23.3-158.4-65.6C211.3 528 188 471.8 188 412s23.3-116.1 65.6-158.4C296 211.3 352.2 188 412 188s116.1 23.2 158.4 65.6S636 352.2 636 412s-23.3 116.1-65.6 158.4z" } }] }, "name": "search", "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 SearchOutlined = function SearchOutlined(props, context) {
+  var p = _objectSpread({}, props, context.attrs);
+
+  return createVNode(Icon, _objectSpread({}, p, {
+    "icon": SearchOutlined$1
+  }), null);
+};
+
+SearchOutlined.displayName = 'SearchOutlined';
+SearchOutlined.inheritAttrs = false;
+
+export { BaseInput as B, SearchOutlined as S, slideUpOut as a, slideDownIn as b, slideUpIn as c, getStatusClassNames as d, initInputToken as e, genBasicInputStyle as f, getMergedStatus as g, genStatusStyle as h, initSlideMotion as i, genPlaceholderStyle as j, genInputGroupStyle as k, genDisabledStyle as l, genActiveStyle as m, genHoverStyle as n, vc_resize_observer_default as o, style_default as p, genInputSmallStyle as q, getOffset as r, slideDownOut as s, vc_overflow_default as v };
+//# sourceMappingURL=SearchOutlined.mjs.map