agentworkshop 0.7.66 → 0.7.70

package/.output/server/chunks/build/firstNotUndefined-8H5_qHUu.mjs

@@ -0,0 +1,2448 @@
+import { z as filterEmpty, al as getSlot, ar as getEvents, as as contains, q as classNames, p as cloneElement, o as _extends, ao as PortalWrapper_default, at as hasProp, au as getComponent, av as findDOMNode, aw as addEventListenerWrap, ax as useProvidePortal, ay as getOptionProps, r as _objectSpread2$1, P as PropTypes, m as flattenChildren, az as getMotion, s as getTransitionProps, aA as supportsPassive_default } from '../virtual/entry.mjs';
+import { ref, unref, watchEffect, watch, defineComponent, createVNode, Fragment, provide, computed, shallowRef, inject, toRaw, nextTick, Transition, toRef, withDirectives, withModifiers, vShow, resolveDirective } from 'vue';
+
+//#region node_modules/.pnpm/resize-observer-polyfill@1.5.1/node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js
+/**
+* A collection of shims that provide minimal functionality of the ES6 collections.
+*
+* These implementations are not meant to be used outside of the ResizeObserver
+* modules as they cover only a limited range of use cases.
+*/
+var MapShim = (function() {
+	if (typeof Map !== "undefined") return Map;
+	/**
+	* Returns index in provided array that matches the specified key.
+	*
+	* @param {Array<Array>} arr
+	* @param {*} key
+	* @returns {number}
+	*/
+	function getIndex(arr, key) {
+		var result = -1;
+		arr.some(function(entry, index) {
+			if (entry[0] === key) {
+				result = index;
+				return true;
+			}
+			return false;
+		});
+		return result;
+	}
+	return function() {
+		function class_1() {
+			this.__entries__ = [];
+		}
+		Object.defineProperty(class_1.prototype, "size", {
+			/**
+			* @returns {boolean}
+			*/
+			get: function() {
+				return this.__entries__.length;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		/**
+		* @param {*} key
+		* @returns {*}
+		*/
+		class_1.prototype.get = function(key) {
+			var index = getIndex(this.__entries__, key);
+			var entry = this.__entries__[index];
+			return entry && entry[1];
+		};
+		/**
+		* @param {*} key
+		* @param {*} value
+		* @returns {void}
+		*/
+		class_1.prototype.set = function(key, value) {
+			var index = getIndex(this.__entries__, key);
+			if (~index) this.__entries__[index][1] = value;
+			else this.__entries__.push([key, value]);
+		};
+		/**
+		* @param {*} key
+		* @returns {void}
+		*/
+		class_1.prototype.delete = function(key) {
+			var entries = this.__entries__;
+			var index = getIndex(entries, key);
+			if (~index) entries.splice(index, 1);
+		};
+		/**
+		* @param {*} key
+		* @returns {void}
+		*/
+		class_1.prototype.has = function(key) {
+			return !!~getIndex(this.__entries__, key);
+		};
+		/**
+		* @returns {void}
+		*/
+		class_1.prototype.clear = function() {
+			this.__entries__.splice(0);
+		};
+		/**
+		* @param {Function} callback
+		* @param {*} [ctx=null]
+		* @returns {void}
+		*/
+		class_1.prototype.forEach = function(callback, ctx) {
+			if (ctx === void 0) ctx = null;
+			for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
+				var entry = _a[_i];
+				callback.call(ctx, entry[1], entry[0]);
+			}
+		};
+		return class_1;
+	}();
+})();
+var global$1 = (function() {
+	if (typeof global !== "undefined" && global.Math === Math) return global;
+	if (typeof self !== "undefined" && self.Math === Math) return self;
+	return Function("return this")();
+})();
+/**
+* A shim for the requestAnimationFrame which falls back to the setTimeout if
+* first one is not supported.
+*
+* @returns {number} Requests' identifier.
+*/
+var requestAnimationFrame$1 = (function() {
+	if (typeof requestAnimationFrame === "function") return requestAnimationFrame.bind(global$1);
+	return function(callback) {
+		return setTimeout(function() {
+			return callback(Date.now());
+		}, 1e3 / 60);
+	};
+})();
+var trailingTimeout = 2;
+/**
+* Creates a wrapper function which ensures that provided callback will be
+* invoked only once during the specified delay period.
+*
+* @param {Function} callback - Function to be invoked after the delay period.
+* @param {number} delay - Delay after which to invoke callback.
+* @returns {Function}
+*/
+function throttle(callback, delay) {
+	var leadingCall = false, trailingCall = false, lastCallTime = 0;
+	/**
+	* Invokes the original callback function and schedules new invocation if
+	* the "proxy" was called during current request.
+	*
+	* @returns {void}
+	*/
+	function resolvePending() {
+		if (leadingCall) {
+			leadingCall = false;
+			callback();
+		}
+		if (trailingCall) proxy();
+	}
+	/**
+	* Callback invoked after the specified delay. It will further postpone
+	* invocation of the original function delegating it to the
+	* requestAnimationFrame.
+	*
+	* @returns {void}
+	*/
+	function timeoutCallback() {
+		requestAnimationFrame$1(resolvePending);
+	}
+	/**
+	* Schedules invocation of the original function.
+	*
+	* @returns {void}
+	*/
+	function proxy() {
+		var timeStamp = Date.now();
+		if (leadingCall) {
+			if (timeStamp - lastCallTime < trailingTimeout) return;
+			trailingCall = true;
+		} else {
+			leadingCall = true;
+			trailingCall = false;
+			setTimeout(timeoutCallback, delay);
+		}
+		lastCallTime = timeStamp;
+	}
+	return proxy;
+}
+var REFRESH_DELAY = 20;
+var transitionKeys = [
+	"top",
+	"right",
+	"bottom",
+	"left",
+	"width",
+	"height",
+	"size",
+	"weight"
+];
+/**
+* Singleton controller class which handles updates of ResizeObserver instances.
+*/
+var ResizeObserverController = function() {
+	/**
+	* Creates a new instance of ResizeObserverController.
+	*
+	* @private
+	*/
+	function ResizeObserverController() {
+		/**
+		* Indicates whether DOM listeners have been added.
+		*
+		* @private {boolean}
+		*/
+		this.connected_ = false;
+		/**
+		* Tells that controller has subscribed for Mutation Events.
+		*
+		* @private {boolean}
+		*/
+		this.mutationEventsAdded_ = false;
+		/**
+		* Keeps reference to the instance of MutationObserver.
+		*
+		* @private {MutationObserver}
+		*/
+		this.mutationsObserver_ = null;
+		/**
+		* A list of connected observers.
+		*
+		* @private {Array<ResizeObserverSPI>}
+		*/
+		this.observers_ = [];
+		this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
+		this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
+	}
+	/**
+	* Adds observer to observers list.
+	*
+	* @param {ResizeObserverSPI} observer - Observer to be added.
+	* @returns {void}
+	*/
+	ResizeObserverController.prototype.addObserver = function(observer) {
+		if (!~this.observers_.indexOf(observer)) this.observers_.push(observer);
+		if (!this.connected_) this.connect_();
+	};
+	/**
+	* Removes observer from observers list.
+	*
+	* @param {ResizeObserverSPI} observer - Observer to be removed.
+	* @returns {void}
+	*/
+	ResizeObserverController.prototype.removeObserver = function(observer) {
+		var observers = this.observers_;
+		var index = observers.indexOf(observer);
+		if (~index) observers.splice(index, 1);
+		if (!observers.length && this.connected_) this.disconnect_();
+	};
+	/**
+	* Invokes the update of observers. It will continue running updates insofar
+	* it detects changes.
+	*
+	* @returns {void}
+	*/
+	ResizeObserverController.prototype.refresh = function() {
+		if (this.updateObservers_()) this.refresh();
+	};
+	/**
+	* Updates every observer from observers list and notifies them of queued
+	* entries.
+	*
+	* @private
+	* @returns {boolean} Returns "true" if any observer has detected changes in
+	*      dimensions of it's elements.
+	*/
+	ResizeObserverController.prototype.updateObservers_ = function() {
+		var activeObservers = this.observers_.filter(function(observer) {
+			return observer.gatherActive(), observer.hasActive();
+		});
+		activeObservers.forEach(function(observer) {
+			return observer.broadcastActive();
+		});
+		return activeObservers.length > 0;
+	};
+	/**
+	* Initializes DOM listeners.
+	*
+	* @private
+	* @returns {void}
+	*/
+	ResizeObserverController.prototype.connect_ = function() {
+		return;
+	};
+	/**
+	* Removes DOM listeners.
+	*
+	* @private
+	* @returns {void}
+	*/
+	ResizeObserverController.prototype.disconnect_ = function() {
+		return;
+	};
+	/**
+	* "Transitionend" event handler.
+	*
+	* @private
+	* @param {TransitionEvent} event
+	* @returns {void}
+	*/
+	ResizeObserverController.prototype.onTransitionEnd_ = function(_a) {
+		var _b = _a.propertyName, propertyName = _b === void 0 ? "" : _b;
+		if (transitionKeys.some(function(key) {
+			return !!~propertyName.indexOf(key);
+		})) this.refresh();
+	};
+	/**
+	* Returns instance of the ResizeObserverController.
+	*
+	* @returns {ResizeObserverController}
+	*/
+	ResizeObserverController.getInstance = function() {
+		if (!this.instance_) this.instance_ = new ResizeObserverController();
+		return this.instance_;
+	};
+	/**
+	* Holds reference to the controller's instance.
+	*
+	* @private {ResizeObserverController}
+	*/
+	ResizeObserverController.instance_ = null;
+	return ResizeObserverController;
+}();
+/**
+* Defines non-writable/enumerable properties of the provided target object.
+*
+* @param {Object} target - Object for which to define properties.
+* @param {Object} props - Properties to be defined.
+* @returns {Object} Target object.
+*/
+var defineConfigurable = (function(target, props) {
+	for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {
+		var key = _a[_i];
+		Object.defineProperty(target, key, {
+			value: props[key],
+			enumerable: false,
+			writable: false,
+			configurable: true
+		});
+	}
+	return target;
+});
+/**
+* Returns the global object associated with provided element.
+*
+* @param {Object} target
+* @returns {Object}
+*/
+var getWindowOf = (function(target) {
+	return target && target.ownerDocument && target.ownerDocument.defaultView || global$1;
+});
+var emptyRect = createRectInit(0, 0, 0, 0);
+/**
+* Calculates an appropriate content rectangle for provided html or svg element.
+*
+* @param {Element} target - Element content rectangle of which needs to be calculated.
+* @returns {DOMRectInit}
+*/
+function getContentRect(target) {
+	return emptyRect;
+}
+/**
+* Creates rectangle with an interface of the DOMRectReadOnly.
+* Spec: https://drafts.fxtf.org/geometry/#domrectreadonly
+*
+* @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.
+* @returns {DOMRectReadOnly}
+*/
+function createReadOnlyRect(_a) {
+	var x = _a.x, y = _a.y, width = _a.width, height = _a.height;
+	var rect = Object.create((typeof DOMRectReadOnly !== "undefined" ? DOMRectReadOnly : Object).prototype);
+	defineConfigurable(rect, {
+		x,
+		y,
+		width,
+		height,
+		top: y,
+		right: x + width,
+		bottom: height + y,
+		left: x
+	});
+	return rect;
+}
+/**
+* Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.
+* Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit
+*
+* @param {number} x - X coordinate.
+* @param {number} y - Y coordinate.
+* @param {number} width - Rectangle's width.
+* @param {number} height - Rectangle's height.
+* @returns {DOMRectInit}
+*/
+function createRectInit(x, y, width, height) {
+	return {
+		x,
+		y,
+		width,
+		height
+	};
+}
+/**
+* Class that is responsible for computations of the content rectangle of
+* provided DOM element and for keeping track of it's changes.
+*/
+var ResizeObservation = function() {
+	/**
+	* Creates an instance of ResizeObservation.
+	*
+	* @param {Element} target - Element to be observed.
+	*/
+	function ResizeObservation(target) {
+		/**
+		* Broadcasted width of content rectangle.
+		*
+		* @type {number}
+		*/
+		this.broadcastWidth = 0;
+		/**
+		* Broadcasted height of content rectangle.
+		*
+		* @type {number}
+		*/
+		this.broadcastHeight = 0;
+		/**
+		* Reference to the last observed content rectangle.
+		*
+		* @private {DOMRectInit}
+		*/
+		this.contentRect_ = createRectInit(0, 0, 0, 0);
+		this.target = target;
+	}
+	/**
+	* Updates content rectangle and tells whether it's width or height properties
+	* have changed since the last broadcast.
+	*
+	* @returns {boolean}
+	*/
+	ResizeObservation.prototype.isActive = function() {
+		var rect = getContentRect(this.target);
+		this.contentRect_ = rect;
+		return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;
+	};
+	/**
+	* Updates 'broadcastWidth' and 'broadcastHeight' properties with a data
+	* from the corresponding properties of the last observed content rectangle.
+	*
+	* @returns {DOMRectInit} Last observed content rectangle.
+	*/
+	ResizeObservation.prototype.broadcastRect = function() {
+		var rect = this.contentRect_;
+		this.broadcastWidth = rect.width;
+		this.broadcastHeight = rect.height;
+		return rect;
+	};
+	return ResizeObservation;
+}();
+var ResizeObserverEntry = function() {
+	/**
+	* Creates an instance of ResizeObserverEntry.
+	*
+	* @param {Element} target - Element that is being observed.
+	* @param {DOMRectInit} rectInit - Data of the element's content rectangle.
+	*/
+	function ResizeObserverEntry(target, rectInit) {
+		var contentRect = createReadOnlyRect(rectInit);
+		defineConfigurable(this, {
+			target,
+			contentRect
+		});
+	}
+	return ResizeObserverEntry;
+}();
+var ResizeObserverSPI = function() {
+	/**
+	* Creates a new instance of ResizeObserver.
+	*
+	* @param {ResizeObserverCallback} callback - Callback function that is invoked
+	*      when one of the observed elements changes it's content dimensions.
+	* @param {ResizeObserverController} controller - Controller instance which
+	*      is responsible for the updates of observer.
+	* @param {ResizeObserver} callbackCtx - Reference to the public
+	*      ResizeObserver instance which will be passed to callback function.
+	*/
+	function ResizeObserverSPI(callback, controller, callbackCtx) {
+		/**
+		* Collection of resize observations that have detected changes in dimensions
+		* of elements.
+		*
+		* @private {Array<ResizeObservation>}
+		*/
+		this.activeObservations_ = [];
+		/**
+		* Registry of the ResizeObservation instances.
+		*
+		* @private {Map<Element, ResizeObservation>}
+		*/
+		this.observations_ = new MapShim();
+		if (typeof callback !== "function") throw new TypeError("The callback provided as parameter 1 is not a function.");
+		this.callback_ = callback;
+		this.controller_ = controller;
+		this.callbackCtx_ = callbackCtx;
+	}
+	/**
+	* Starts observing provided element.
+	*
+	* @param {Element} target - Element to be observed.
+	* @returns {void}
+	*/
+	ResizeObserverSPI.prototype.observe = function(target) {
+		if (!arguments.length) throw new TypeError("1 argument required, but only 0 present.");
+		if (typeof Element === "undefined" || !(Element instanceof Object)) return;
+		if (!(target instanceof getWindowOf(target).Element)) throw new TypeError("parameter 1 is not of type \"Element\".");
+		var observations = this.observations_;
+		if (observations.has(target)) return;
+		observations.set(target, new ResizeObservation(target));
+		this.controller_.addObserver(this);
+		this.controller_.refresh();
+	};
+	/**
+	* Stops observing provided element.
+	*
+	* @param {Element} target - Element to stop observing.
+	* @returns {void}
+	*/
+	ResizeObserverSPI.prototype.unobserve = function(target) {
+		if (!arguments.length) throw new TypeError("1 argument required, but only 0 present.");
+		if (typeof Element === "undefined" || !(Element instanceof Object)) return;
+		if (!(target instanceof getWindowOf(target).Element)) throw new TypeError("parameter 1 is not of type \"Element\".");
+		var observations = this.observations_;
+		if (!observations.has(target)) return;
+		observations.delete(target);
+		if (!observations.size) this.controller_.removeObserver(this);
+	};
+	/**
+	* Stops observing all elements.
+	*
+	* @returns {void}
+	*/
+	ResizeObserverSPI.prototype.disconnect = function() {
+		this.clearActive();
+		this.observations_.clear();
+		this.controller_.removeObserver(this);
+	};
+	/**
+	* Collects observation instances the associated element of which has changed
+	* it's content rectangle.
+	*
+	* @returns {void}
+	*/
+	ResizeObserverSPI.prototype.gatherActive = function() {
+		var _this = this;
+		this.clearActive();
+		this.observations_.forEach(function(observation) {
+			if (observation.isActive()) _this.activeObservations_.push(observation);
+		});
+	};
+	/**
+	* Invokes initial callback function with a list of ResizeObserverEntry
+	* instances collected from active resize observations.
+	*
+	* @returns {void}
+	*/
+	ResizeObserverSPI.prototype.broadcastActive = function() {
+		if (!this.hasActive()) return;
+		var ctx = this.callbackCtx_;
+		var entries = this.activeObservations_.map(function(observation) {
+			return new ResizeObserverEntry(observation.target, observation.broadcastRect());
+		});
+		this.callback_.call(ctx, entries, ctx);
+		this.clearActive();
+	};
+	/**
+	* Clears the collection of active observations.
+	*
+	* @returns {void}
+	*/
+	ResizeObserverSPI.prototype.clearActive = function() {
+		this.activeObservations_.splice(0);
+	};
+	/**
+	* Tells whether observer has active observations.
+	*
+	* @returns {boolean}
+	*/
+	ResizeObserverSPI.prototype.hasActive = function() {
+		return this.activeObservations_.length > 0;
+	};
+	return ResizeObserverSPI;
+}();
+var observers = typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : new MapShim();
+/**
+* ResizeObserver API. Encapsulates the ResizeObserver SPI implementation
+* exposing only those methods and properties that are defined in the spec.
+*/
+var ResizeObserver = function() {
+	/**
+	* Creates a new instance of ResizeObserver.
+	*
+	* @param {ResizeObserverCallback} callback - Callback that is invoked when
+	*      dimensions of the observed elements change.
+	*/
+	function ResizeObserver(callback) {
+		if (!(this instanceof ResizeObserver)) throw new TypeError("Cannot call a class as a function.");
+		if (!arguments.length) throw new TypeError("1 argument required, but only 0 present.");
+		var observer = new ResizeObserverSPI(callback, ResizeObserverController.getInstance(), this);
+		observers.set(this, observer);
+	}
+	return ResizeObserver;
+}();
+[
+	"observe",
+	"unobserve",
+	"disconnect"
+].forEach(function(method) {
+	ResizeObserver.prototype[method] = function() {
+		var _a;
+		return (_a = observers.get(this))[method].apply(_a, arguments);
+	};
+});
+var index = (function() {
+	if (typeof global$1.ResizeObserver !== "undefined") return global$1.ResizeObserver;
+	return ResizeObserver;
+})();
+//#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/raf.js
+var raf = (callback) => setTimeout(callback, 16);
+var caf = (num) => clearTimeout(num);
+var rafUUID = 0;
+var rafIds = /* @__PURE__ */ new Map();
+function cleanup(id) {
+	rafIds.delete(id);
+}
+function wrapperRaf(callback) {
+	let times = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
+	rafUUID += 1;
+	const id = rafUUID;
+	function callRef(leftTimes) {
+		if (leftTimes === 0) {
+			cleanup(id);
+			callback();
+		} else {
+			const realId = raf(() => {
+				callRef(leftTimes - 1);
+			});
+			rafIds.set(id, realId);
+		}
+	}
+	callRef(times);
+	return id;
+}
+wrapperRaf.cancel = (id) => {
+	const realId = rafIds.get(id);
+	cleanup(realId);
+	return caf(realId);
+};
+//#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-trigger/interface.js
+function returnEmptyString() {
+	return "";
+}
+function returnDocument(element) {
+	if (element) return element.ownerDocument;
+	return (void 0).document;
+}
+function noop() {}
+var triggerProps = () => ({
+	action: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]).def([]),
+	showAction: PropTypes.any.def([]),
+	hideAction: PropTypes.any.def([]),
+	getPopupClassNameFromAlign: PropTypes.any.def(returnEmptyString),
+	onPopupVisibleChange: Function,
+	afterPopupVisibleChange: PropTypes.func.def(noop),
+	popup: PropTypes.any,
+	arrow: PropTypes.bool.def(true),
+	popupStyle: {
+		type: Object,
+		default: void 0
+	},
+	prefixCls: PropTypes.string.def("rc-trigger-popup"),
+	popupClassName: PropTypes.string.def(""),
+	popupPlacement: String,
+	builtinPlacements: PropTypes.object,
+	popupTransitionName: String,
+	popupAnimation: PropTypes.any,
+	mouseEnterDelay: PropTypes.number.def(0),
+	mouseLeaveDelay: PropTypes.number.def(.1),
+	zIndex: Number,
+	focusDelay: PropTypes.number.def(0),
+	blurDelay: PropTypes.number.def(.15),
+	getPopupContainer: Function,
+	getDocument: PropTypes.func.def(returnDocument),
+	forceRender: {
+		type: Boolean,
+		default: void 0
+	},
+	destroyPopupOnHide: {
+		type: Boolean,
+		default: false
+	},
+	mask: {
+		type: Boolean,
+		default: false
+	},
+	maskClosable: {
+		type: Boolean,
+		default: true
+	},
+	popupAlign: PropTypes.object.def(() => ({})),
+	popupVisible: {
+		type: Boolean,
+		default: void 0
+	},
+	defaultPopupVisible: {
+		type: Boolean,
+		default: false
+	},
+	maskTransitionName: String,
+	maskAnimation: String,
+	stretch: String,
+	alignPoint: {
+		type: Boolean,
+		default: void 0
+	},
+	autoDestroy: {
+		type: Boolean,
+		default: false
+	},
+	mobile: Object,
+	getTriggerDOMNode: Function
+});
+//#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-trigger/Popup/interface.js
+var innerProps = {
+	visible: Boolean,
+	prefixCls: String,
+	zIndex: Number,
+	destroyPopupOnHide: Boolean,
+	forceRender: Boolean,
+	arrow: {
+		type: Boolean,
+		default: true
+	},
+	animation: [String, Object],
+	transitionName: String,
+	stretch: { type: String },
+	align: { type: Object },
+	point: { type: Object },
+	getRootDomNode: { type: Function },
+	getClassNameFromAlign: { type: Function },
+	onAlign: { type: Function },
+	onMouseenter: { type: Function },
+	onMouseleave: { type: Function },
+	onMousedown: { type: Function },
+	onTouchstart: { type: Function }
+};
+var mobileProps = _extends(_extends({}, innerProps), { mobile: { type: Object } });
+var popupProps = _extends(_extends({}, innerProps), {
+	mask: Boolean,
+	mobile: { type: Object },
+	maskAnimation: String,
+	maskTransitionName: String
+});
+//#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-trigger/Popup/Mask.js
+function Mask(props) {
+	const { prefixCls, visible, zIndex, mask, maskAnimation, maskTransitionName } = props;
+	if (!mask) return null;
+	let motion = {};
+	if (maskTransitionName || maskAnimation) motion = getMotion({
+		prefixCls,
+		transitionName: maskTransitionName,
+		animation: maskAnimation
+	});
+	return createVNode(Transition, _objectSpread2$1({ "appear": true }, motion), { default: () => [withDirectives(createVNode("div", {
+		"style": { zIndex },
+		"class": `${prefixCls}-mask`
+	}, null), [[resolveDirective("if"), visible]])] });
+}
+Mask.displayName = "Mask";
+//#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-trigger/Popup/MobilePopupInner.js
+var MobilePopupInner_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "MobilePopupInner",
+	inheritAttrs: false,
+	props: mobileProps,
+	emits: [
+		"mouseenter",
+		"mouseleave",
+		"mousedown",
+		"touchstart",
+		"align"
+	],
+	setup(props, _ref) {
+		let { expose, slots } = _ref;
+		const elementRef = ref();
+		expose({
+			forceAlign: () => {},
+			getElement: () => elementRef.value
+		});
+		return () => {
+			var _a;
+			const { zIndex, visible, prefixCls, mobile: { popupClassName, popupStyle, popupMotion = {}, popupRender } = {} } = props;
+			const mergedStyle = _extends({ zIndex }, popupStyle);
+			let childNode = flattenChildren((_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots));
+			if (childNode.length > 1) {
+				childNode = createVNode("div", { "class": `${prefixCls}-content` }, [childNode]);
+			}
+			if (popupRender) childNode = popupRender(childNode);
+			const mergedClassName = classNames(prefixCls, popupClassName);
+			return createVNode(Transition, _objectSpread2$1({ "ref": elementRef }, popupMotion), { default: () => [visible ? createVNode("div", {
+				"class": mergedClassName,
+				"style": mergedStyle
+			}, [childNode]) : null] });
+		};
+	}
+});
+var useVisibleStatus_default = ((visible, doMeasure) => {
+	const status = shallowRef(null);
+	const rafRef = shallowRef();
+	const destroyRef = shallowRef(false);
+	function setStatus(nextStatus) {
+		if (!destroyRef.value) status.value = nextStatus;
+	}
+	function cancelRaf() {
+		wrapperRaf.cancel(rafRef.value);
+	}
+	function goNextStatus(callback) {
+		cancelRaf();
+		rafRef.value = wrapperRaf(() => {
+			let newStatus = status.value;
+			switch (status.value) {
+				case "align":
+					newStatus = "motion";
+					break;
+				case "motion": newStatus = "stable";
+			}
+			setStatus(newStatus);
+			callback === null || callback === void 0 || callback();
+		});
+	}
+	watch(visible, () => {
+		setStatus("measure");
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	return [status, goNextStatus];
+});
+//#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-trigger/Popup/useStretchStyle.js
+var useStretchStyle_default = ((stretch) => {
+	const targetSize = shallowRef({
+		width: 0,
+		height: 0
+	});
+	function measureStretch(element) {
+		targetSize.value = {
+			width: element.offsetWidth,
+			height: element.offsetHeight
+		};
+	}
+	return [computed(() => {
+		const sizeStyle = {};
+		if (stretch.value) {
+			const { width, height } = targetSize.value;
+			if (stretch.value.indexOf("height") !== -1 && height) sizeStyle.height = `${height}px`;
+			else if (stretch.value.indexOf("minHeight") !== -1 && height) sizeStyle.minHeight = `${height}px`;
+			if (stretch.value.indexOf("width") !== -1 && width) sizeStyle.width = `${width}px`;
+			else if (stretch.value.indexOf("minWidth") !== -1 && width) sizeStyle.minWidth = `${width}px`;
+		}
+		return sizeStyle;
+	}), measureStretch];
+});
+//#endregion
+//#region node_modules/.pnpm/dom-align@1.12.4/node_modules/dom-align/dist-web/index.js
+function ownKeys(object, enumerableOnly) {
+	var keys = Object.keys(object);
+	if (Object.getOwnPropertySymbols) {
+		var symbols = Object.getOwnPropertySymbols(object);
+		enumerableOnly && (symbols = symbols.filter(function(sym) {
+			return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+		})), keys.push.apply(keys, symbols);
+	}
+	return keys;
+}
+function _objectSpread2(target) {
+	for (var i = 1; i < arguments.length; i++) {
+		var source = null != arguments[i] ? arguments[i] : {};
+		i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+			_defineProperty(target, key, source[key]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+			Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+		});
+	}
+	return target;
+}
+function _typeof(obj) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) {
+		return typeof obj;
+	} : function(obj) {
+		return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+	}, _typeof(obj);
+}
+function _defineProperty(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+var vendorPrefix;
+var jsCssMap = {
+	Webkit: "-webkit-",
+	Moz: "-moz-",
+	ms: "-ms-",
+	O: "-o-"
+};
+function getVendorPrefix() {
+	if (vendorPrefix !== void 0) return vendorPrefix;
+	vendorPrefix = "";
+	var style = (void 0).createElement("p").style;
+	var testProp = "Transform";
+	for (var key in jsCssMap) if (key + testProp in style) vendorPrefix = key;
+	return vendorPrefix;
+}
+function getTransitionName() {
+	return getVendorPrefix() ? "".concat(getVendorPrefix(), "TransitionProperty") : "transitionProperty";
+}
+function getTransformName() {
+	return getVendorPrefix() ? "".concat(getVendorPrefix(), "Transform") : "transform";
+}
+function setTransitionProperty(node, value) {
+	var name = getTransitionName();
+	if (name) {
+		node.style[name] = value;
+		if (name !== "transitionProperty") node.style.transitionProperty = value;
+	}
+}
+function setTransform(node, value) {
+	var name = getTransformName();
+	if (name) {
+		node.style[name] = value;
+		if (name !== "transform") node.style.transform = value;
+	}
+}
+function getTransitionProperty(node) {
+	return node.style.transitionProperty || node.style[getTransitionName()];
+}
+function getTransformXY(node) {
+	var style = (void 0).getComputedStyle(node, null);
+	var transform = style.getPropertyValue("transform") || style.getPropertyValue(getTransformName());
+	if (transform && transform !== "none") {
+		var matrix = transform.replace(/[^0-9\-.,]/g, "").split(",");
+		return {
+			x: parseFloat(matrix[12] || matrix[4], 0),
+			y: parseFloat(matrix[13] || matrix[5], 0)
+		};
+	}
+	return {
+		x: 0,
+		y: 0
+	};
+}
+var matrix2d = /matrix\((.*)\)/;
+var matrix3d = /matrix3d\((.*)\)/;
+function setTransformXY(node, xy) {
+	var style = (void 0).getComputedStyle(node, null);
+	var transform = style.getPropertyValue("transform") || style.getPropertyValue(getTransformName());
+	if (transform && transform !== "none") {
+		var arr;
+		var match2d = transform.match(matrix2d);
+		if (match2d) {
+			match2d = match2d[1];
+			arr = match2d.split(",").map(function(item) {
+				return parseFloat(item, 10);
+			});
+			arr[4] = xy.x;
+			arr[5] = xy.y;
+			setTransform(node, "matrix(".concat(arr.join(","), ")"));
+		} else {
+			arr = transform.match(matrix3d)[1].split(",").map(function(item) {
+				return parseFloat(item, 10);
+			});
+			arr[12] = xy.x;
+			arr[13] = xy.y;
+			setTransform(node, "matrix3d(".concat(arr.join(","), ")"));
+		}
+	} else setTransform(node, "translateX(".concat(xy.x, "px) translateY(").concat(xy.y, "px) translateZ(0)"));
+}
+var getComputedStyleX;
+function forceRelayout(elem) {
+	var originalStyle = elem.style.display;
+	elem.style.display = "none";
+	elem.offsetHeight;
+	elem.style.display = originalStyle;
+}
+function css(el, name, v) {
+	var value = v;
+	if (_typeof(name) === "object") {
+		for (var i in name) if (name.hasOwnProperty(i)) css(el, i, name[i]);
+		return;
+	}
+	if (typeof value !== "undefined") {
+		if (typeof value === "number") value = "".concat(value, "px");
+		el.style[name] = value;
+		return;
+	}
+	return getComputedStyleX(el, name);
+}
+function getClientPosition(elem) {
+	var box;
+	var x;
+	var y;
+	var doc = elem.ownerDocument;
+	var body = doc.body;
+	var docElem = doc && doc.documentElement;
+	box = elem.getBoundingClientRect();
+	x = Math.floor(box.left);
+	y = Math.floor(box.top);
+	x -= docElem.clientLeft || body.clientLeft || 0;
+	y -= docElem.clientTop || body.clientTop || 0;
+	return {
+		left: x,
+		top: y
+	};
+}
+function getScroll(w, top) {
+	var ret = w["page".concat(top ? "Y" : "X", "Offset")];
+	var method = "scroll".concat(top ? "Top" : "Left");
+	if (typeof ret !== "number") {
+		var d = w.document;
+		ret = d.documentElement[method];
+		if (typeof ret !== "number") ret = d.body[method];
+	}
+	return ret;
+}
+function getScrollLeft(w) {
+	return getScroll(w);
+}
+function getScrollTop(w) {
+	return getScroll(w, true);
+}
+function getOffset(el) {
+	var pos = getClientPosition(el);
+	var doc = el.ownerDocument;
+	var w = doc.defaultView || doc.parentWindow;
+	pos.left += getScrollLeft(w);
+	pos.top += getScrollTop(w);
+	return pos;
+}
+/**
+* A crude way of determining if an object is a window
+* @member util
+*/
+function isWindow(obj) {
+	return obj !== null && obj !== void 0 && obj == obj.window;
+}
+function getDocument(node) {
+	if (isWindow(node)) return node.document;
+	if (node.nodeType === 9) return node;
+	return node.ownerDocument;
+}
+function getOffsetDirection(dir, option) {
+	if (dir === "left") return option.useCssRight ? "right" : dir;
+	return option.useCssBottom ? "bottom" : dir;
+}
+function oppositeOffsetDirection(dir) {
+	if (dir === "left") return "right";
+	else if (dir === "right") return "left";
+	else if (dir === "top") return "bottom";
+	else if (dir === "bottom") return "top";
+}
+function setLeftTop(elem, offset, option) {
+	if (css(elem, "position") === "static") elem.style.position = "relative";
+	var presetH = -999;
+	var presetV = -999;
+	var horizontalProperty = getOffsetDirection("left", option);
+	var verticalProperty = getOffsetDirection("top", option);
+	var oppositeHorizontalProperty = oppositeOffsetDirection(horizontalProperty);
+	var oppositeVerticalProperty = oppositeOffsetDirection(verticalProperty);
+	if (horizontalProperty !== "left") presetH = 999;
+	if (verticalProperty !== "top") presetV = 999;
+	var originalTransition = "";
+	var originalOffset = getOffset(elem);
+	if ("left" in offset || "top" in offset) {
+		originalTransition = getTransitionProperty(elem) || "";
+		setTransitionProperty(elem, "none");
+	}
+	if ("left" in offset) {
+		elem.style[oppositeHorizontalProperty] = "";
+		elem.style[horizontalProperty] = "".concat(presetH, "px");
+	}
+	if ("top" in offset) {
+		elem.style[oppositeVerticalProperty] = "";
+		elem.style[verticalProperty] = "".concat(presetV, "px");
+	}
+	forceRelayout(elem);
+	var old = getOffset(elem);
+	var originalStyle = {};
+	for (var key in offset) if (offset.hasOwnProperty(key)) {
+		var dir = getOffsetDirection(key, option);
+		var preset = key === "left" ? presetH : presetV;
+		var off = originalOffset[key] - old[key];
+		if (dir === key) originalStyle[dir] = preset + off;
+		else originalStyle[dir] = preset - off;
+	}
+	css(elem, originalStyle);
+	forceRelayout(elem);
+	if ("left" in offset || "top" in offset) setTransitionProperty(elem, originalTransition);
+	var ret = {};
+	for (var _key in offset) if (offset.hasOwnProperty(_key)) {
+		var _dir = getOffsetDirection(_key, option);
+		var _off = offset[_key] - originalOffset[_key];
+		if (_key === _dir) ret[_dir] = originalStyle[_dir] + _off;
+		else ret[_dir] = originalStyle[_dir] - _off;
+	}
+	css(elem, ret);
+}
+function setTransform$1(elem, offset) {
+	var originalOffset = getOffset(elem);
+	var originalXY = getTransformXY(elem);
+	var resultXY = {
+		x: originalXY.x,
+		y: originalXY.y
+	};
+	if ("left" in offset) resultXY.x = originalXY.x + offset.left - originalOffset.left;
+	if ("top" in offset) resultXY.y = originalXY.y + offset.top - originalOffset.top;
+	setTransformXY(elem, resultXY);
+}
+function setOffset(elem, offset, option) {
+	if (option.ignoreShake) {
+		var oriOffset = getOffset(elem);
+		var oLeft = oriOffset.left.toFixed(0);
+		var oTop = oriOffset.top.toFixed(0);
+		var tLeft = offset.left.toFixed(0);
+		var tTop = offset.top.toFixed(0);
+		if (oLeft === tLeft && oTop === tTop) return;
+	}
+	if (option.useCssRight || option.useCssBottom) setLeftTop(elem, offset, option);
+	else if (option.useCssTransform && getTransformName() in (void 0).body.style) setTransform$1(elem, offset);
+	else setLeftTop(elem, offset, option);
+}
+function each(arr, fn) {
+	for (var i = 0; i < arr.length; i++) fn(arr[i]);
+}
+function isBorderBoxFn(elem) {
+	return getComputedStyleX(elem, "boxSizing") === "border-box";
+}
+var BOX_MODELS = [
+	"margin",
+	"border",
+	"padding"
+];
+var CONTENT_INDEX = -1;
+var PADDING_INDEX = 2;
+var BORDER_INDEX = 1;
+var MARGIN_INDEX = 0;
+function swap(elem, options, callback) {
+	var old = {};
+	var style = elem.style;
+	var name;
+	for (name in options) if (options.hasOwnProperty(name)) {
+		old[name] = style[name];
+		style[name] = options[name];
+	}
+	callback.call(elem);
+	for (name in options) if (options.hasOwnProperty(name)) style[name] = old[name];
+}
+function getPBMWidth(elem, props, which) {
+	var value = 0;
+	var prop;
+	var j;
+	var i;
+	for (j = 0; j < props.length; j++) {
+		prop = props[j];
+		if (prop) for (i = 0; i < which.length; i++) {
+			var cssProp = void 0;
+			if (prop === "border") cssProp = "".concat(prop).concat(which[i], "Width");
+			else cssProp = prop + which[i];
+			value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;
+		}
+	}
+	return value;
+}
+var domUtils = { getParent: function getParent(element) {
+	var parent = element;
+	do
+		if (parent.nodeType === 11 && parent.host) parent = parent.host;
+		else parent = parent.parentNode;
+	while (parent && parent.nodeType !== 1 && parent.nodeType !== 9);
+	return parent;
+} };
+each(["Width", "Height"], function(name) {
+	domUtils["doc".concat(name)] = function(refWin) {
+		var d = refWin.document;
+		return Math.max(d.documentElement["scroll".concat(name)], d.body["scroll".concat(name)], domUtils["viewport".concat(name)](d));
+	};
+	domUtils["viewport".concat(name)] = function(win) {
+		var prop = "client".concat(name);
+		var doc = win.document;
+		var body = doc.body;
+		var documentElementProp = doc.documentElement[prop];
+		return doc.compatMode === "CSS1Compat" && documentElementProp || body && body[prop] || documentElementProp;
+	};
+});
+function getWH(elem, name, ex) {
+	var extra = ex;
+	if (isWindow(elem)) return name === "width" ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);
+	else if (elem.nodeType === 9) return name === "width" ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
+	var which = name === "width" ? ["Left", "Right"] : ["Top", "Bottom"];
+	var borderBoxValue = name === "width" ? Math.floor(elem.getBoundingClientRect().width) : Math.floor(elem.getBoundingClientRect().height);
+	var isBorderBox = isBorderBoxFn(elem);
+	var cssBoxValue = 0;
+	if (borderBoxValue === null || borderBoxValue === void 0 || borderBoxValue <= 0) {
+		borderBoxValue = void 0;
+		cssBoxValue = getComputedStyleX(elem, name);
+		if (cssBoxValue === null || cssBoxValue === void 0 || Number(cssBoxValue) < 0) cssBoxValue = elem.style[name] || 0;
+		cssBoxValue = Math.floor(parseFloat(cssBoxValue)) || 0;
+	}
+	if (extra === void 0) extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
+	var borderBoxValueOrIsBorderBox = borderBoxValue !== void 0 || isBorderBox;
+	var val = borderBoxValue || cssBoxValue;
+	if (extra === CONTENT_INDEX) {
+		if (borderBoxValueOrIsBorderBox) return val - getPBMWidth(elem, ["border", "padding"], which);
+		return cssBoxValue;
+	} else if (borderBoxValueOrIsBorderBox) {
+		if (extra === BORDER_INDEX) return val;
+		return val + (extra === PADDING_INDEX ? -getPBMWidth(elem, ["border"], which) : getPBMWidth(elem, ["margin"], which));
+	}
+	return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which);
+}
+var cssShow = {
+	position: "absolute",
+	visibility: "hidden",
+	display: "block"
+};
+function getWHIgnoreDisplay() {
+	for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) args[_key2] = arguments[_key2];
+	var val;
+	var elem = args[0];
+	if (elem.offsetWidth !== 0) val = getWH.apply(void 0, args);
+	else swap(elem, cssShow, function() {
+		val = getWH.apply(void 0, args);
+	});
+	return val;
+}
+each(["width", "height"], function(name) {
+	var first = name.charAt(0).toUpperCase() + name.slice(1);
+	domUtils["outer".concat(first)] = function(el, includeMargin) {
+		return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
+	};
+	var which = name === "width" ? ["Left", "Right"] : ["Top", "Bottom"];
+	domUtils[name] = function(elem, v) {
+		var val = v;
+		if (val !== void 0) {
+			if (elem) {
+				if (isBorderBoxFn(elem)) val += getPBMWidth(elem, ["padding", "border"], which);
+				return css(elem, name, val);
+			}
+			return;
+		}
+		return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
+	};
+});
+function mix(to, from) {
+	for (var i in from) if (from.hasOwnProperty(i)) to[i] = from[i];
+	return to;
+}
+var utils = {
+	getWindow: function getWindow(node) {
+		if (node && node.document && node.setTimeout) return node;
+		var doc = node.ownerDocument || node;
+		return doc.defaultView || doc.parentWindow;
+	},
+	getDocument,
+	offset: function offset(el, value, option) {
+		if (typeof value !== "undefined") setOffset(el, value, option || {});
+		else return getOffset(el);
+	},
+	isWindow,
+	each,
+	css,
+	clone: function clone(obj) {
+		var i;
+		var ret = {};
+		for (i in obj) if (obj.hasOwnProperty(i)) ret[i] = obj[i];
+		if (obj.overflow) {
+			for (i in obj) if (obj.hasOwnProperty(i)) ret.overflow[i] = obj.overflow[i];
+		}
+		return ret;
+	},
+	mix,
+	getWindowScrollLeft: function getWindowScrollLeft(w) {
+		return getScrollLeft(w);
+	},
+	getWindowScrollTop: function getWindowScrollTop(w) {
+		return getScrollTop(w);
+	},
+	merge: function merge() {
+		var ret = {};
+		for (var i = 0; i < arguments.length; i++) utils.mix(ret, i < 0 || arguments.length <= i ? void 0 : arguments[i]);
+		return ret;
+	},
+	viewportWidth: 0,
+	viewportHeight: 0
+};
+mix(utils, domUtils);
+/**
+* 得到会导致元素显示不全的祖先元素
+*/
+var getParent = utils.getParent;
+function getOffsetParent(element) {
+	if (utils.isWindow(element) || element.nodeType === 9) return null;
+	var body = utils.getDocument(element).body;
+	var parent;
+	var positionStyle = utils.css(element, "position");
+	if (!(positionStyle === "fixed" || positionStyle === "absolute")) return element.nodeName.toLowerCase() === "html" ? null : getParent(element);
+	for (parent = getParent(element); parent && parent !== body && parent.nodeType !== 9; parent = getParent(parent)) {
+		positionStyle = utils.css(parent, "position");
+		if (positionStyle !== "static") return parent;
+	}
+	return null;
+}
+var getParent$1 = utils.getParent;
+function isAncestorFixed(element) {
+	if (utils.isWindow(element) || element.nodeType === 9) return false;
+	var doc = utils.getDocument(element);
+	var body = doc.body;
+	var parent = null;
+	for (parent = getParent$1(element); parent && parent !== body && parent !== doc; parent = getParent$1(parent)) if (utils.css(parent, "position") === "fixed") return true;
+	return false;
+}
+/**
+* 获得元素的显示部分的区域
+*/
+function getVisibleRectForElement(element, alwaysByViewport) {
+	var visibleRect = {
+		left: 0,
+		right: Infinity,
+		top: 0,
+		bottom: Infinity
+	};
+	var el = getOffsetParent(element);
+	var doc = utils.getDocument(element);
+	var win = doc.defaultView || doc.parentWindow;
+	var body = doc.body;
+	var documentElement = doc.documentElement;
+	while (el) {
+		if (((void 0).userAgent.indexOf("MSIE") === -1 || el.clientWidth !== 0) && el !== body && el !== documentElement && utils.css(el, "overflow") !== "visible") {
+			var pos = utils.offset(el);
+			pos.left += el.clientLeft;
+			pos.top += el.clientTop;
+			visibleRect.top = Math.max(visibleRect.top, pos.top);
+			visibleRect.right = Math.min(visibleRect.right, pos.left + el.clientWidth);
+			visibleRect.bottom = Math.min(visibleRect.bottom, pos.top + el.clientHeight);
+			visibleRect.left = Math.max(visibleRect.left, pos.left);
+		} else if (el === body || el === documentElement) break;
+		el = getOffsetParent(el);
+	}
+	var originalPosition = null;
+	if (!utils.isWindow(element) && element.nodeType !== 9) {
+		originalPosition = element.style.position;
+		if (utils.css(element, "position") === "absolute") element.style.position = "fixed";
+	}
+	var scrollX = utils.getWindowScrollLeft(win);
+	var scrollY = utils.getWindowScrollTop(win);
+	var viewportWidth = utils.viewportWidth(win);
+	var viewportHeight = utils.viewportHeight(win);
+	var documentWidth = documentElement.scrollWidth;
+	var documentHeight = documentElement.scrollHeight;
+	var bodyStyle = (void 0).getComputedStyle(body);
+	if (bodyStyle.overflowX === "hidden") documentWidth = win.innerWidth;
+	if (bodyStyle.overflowY === "hidden") documentHeight = win.innerHeight;
+	if (element.style) element.style.position = originalPosition;
+	if (alwaysByViewport || isAncestorFixed(element)) {
+		visibleRect.left = Math.max(visibleRect.left, scrollX);
+		visibleRect.top = Math.max(visibleRect.top, scrollY);
+		visibleRect.right = Math.min(visibleRect.right, scrollX + viewportWidth);
+		visibleRect.bottom = Math.min(visibleRect.bottom, scrollY + viewportHeight);
+	} else {
+		var maxVisibleWidth = Math.max(documentWidth, scrollX + viewportWidth);
+		visibleRect.right = Math.min(visibleRect.right, maxVisibleWidth);
+		var maxVisibleHeight = Math.max(documentHeight, scrollY + viewportHeight);
+		visibleRect.bottom = Math.min(visibleRect.bottom, maxVisibleHeight);
+	}
+	return visibleRect.top >= 0 && visibleRect.left >= 0 && visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left ? visibleRect : null;
+}
+function adjustForViewport(elFuturePos, elRegion, visibleRect, overflow) {
+	var pos = utils.clone(elFuturePos);
+	var size = {
+		width: elRegion.width,
+		height: elRegion.height
+	};
+	if (overflow.adjustX && pos.left < visibleRect.left) pos.left = visibleRect.left;
+	if (overflow.resizeWidth && pos.left >= visibleRect.left && pos.left + size.width > visibleRect.right) size.width -= pos.left + size.width - visibleRect.right;
+	if (overflow.adjustX && pos.left + size.width > visibleRect.right) pos.left = Math.max(visibleRect.right - size.width, visibleRect.left);
+	if (overflow.adjustY && pos.top < visibleRect.top) pos.top = visibleRect.top;
+	if (overflow.resizeHeight && pos.top >= visibleRect.top && pos.top + size.height > visibleRect.bottom) size.height -= pos.top + size.height - visibleRect.bottom;
+	if (overflow.adjustY && pos.top + size.height > visibleRect.bottom) pos.top = Math.max(visibleRect.bottom - size.height, visibleRect.top);
+	return utils.mix(pos, size);
+}
+function getRegion(node) {
+	var offset;
+	var w;
+	var h;
+	if (!utils.isWindow(node) && node.nodeType !== 9) {
+		offset = utils.offset(node);
+		w = utils.outerWidth(node);
+		h = utils.outerHeight(node);
+	} else {
+		var win = utils.getWindow(node);
+		offset = {
+			left: utils.getWindowScrollLeft(win),
+			top: utils.getWindowScrollTop(win)
+		};
+		w = utils.viewportWidth(win);
+		h = utils.viewportHeight(win);
+	}
+	offset.width = w;
+	offset.height = h;
+	return offset;
+}
+/**
+* 获取 node 上的 align 对齐点 相对于页面的坐标
+*/
+function getAlignOffset(region, align) {
+	var V = align.charAt(0);
+	var H = align.charAt(1);
+	var w = region.width;
+	var h = region.height;
+	var x = region.left;
+	var y = region.top;
+	if (V === "c") y += h / 2;
+	else if (V === "b") y += h;
+	if (H === "c") x += w / 2;
+	else if (H === "r") x += w;
+	return {
+		left: x,
+		top: y
+	};
+}
+function getElFuturePos(elRegion, refNodeRegion, points, offset, targetOffset) {
+	var p1 = getAlignOffset(refNodeRegion, points[1]);
+	var p2 = getAlignOffset(elRegion, points[0]);
+	var diff = [p2.left - p1.left, p2.top - p1.top];
+	return {
+		left: Math.round(elRegion.left - diff[0] + offset[0] - targetOffset[0]),
+		top: Math.round(elRegion.top - diff[1] + offset[1] - targetOffset[1])
+	};
+}
+/**
+* align dom node flexibly
+* @author yiminghe@gmail.com
+*/
+function isFailX(elFuturePos, elRegion, visibleRect) {
+	return elFuturePos.left < visibleRect.left || elFuturePos.left + elRegion.width > visibleRect.right;
+}
+function isFailY(elFuturePos, elRegion, visibleRect) {
+	return elFuturePos.top < visibleRect.top || elFuturePos.top + elRegion.height > visibleRect.bottom;
+}
+function isCompleteFailX(elFuturePos, elRegion, visibleRect) {
+	return elFuturePos.left > visibleRect.right || elFuturePos.left + elRegion.width < visibleRect.left;
+}
+function isCompleteFailY(elFuturePos, elRegion, visibleRect) {
+	return elFuturePos.top > visibleRect.bottom || elFuturePos.top + elRegion.height < visibleRect.top;
+}
+function flip(points, reg, map) {
+	var ret = [];
+	utils.each(points, function(p) {
+		ret.push(p.replace(reg, function(m) {
+			return map[m];
+		}));
+	});
+	return ret;
+}
+function flipOffset(offset, index) {
+	offset[index] = -offset[index];
+	return offset;
+}
+function convertOffset(str, offsetLen) {
+	var n;
+	if (/%$/.test(str)) n = parseInt(str.substring(0, str.length - 1), 10) / 100 * offsetLen;
+	else n = parseInt(str, 10);
+	return n || 0;
+}
+function normalizeOffset(offset, el) {
+	offset[0] = convertOffset(offset[0], el.width);
+	offset[1] = convertOffset(offset[1], el.height);
+}
+/**
+* @param el
+* @param tgtRegion 参照节点所占的区域: { left, top, width, height }
+* @param align
+*/
+function doAlign(el, tgtRegion, align, isTgtRegionVisible) {
+	var points = align.points;
+	var offset = align.offset || [0, 0];
+	var targetOffset = align.targetOffset || [0, 0];
+	var overflow = align.overflow;
+	var source = align.source || el;
+	offset = [].concat(offset);
+	targetOffset = [].concat(targetOffset);
+	overflow = overflow || {};
+	var newOverflowCfg = {};
+	var fail = 0;
+	var visibleRect = getVisibleRectForElement(source, !!(overflow && overflow.alwaysByViewport));
+	var elRegion = getRegion(source);
+	normalizeOffset(offset, elRegion);
+	normalizeOffset(targetOffset, tgtRegion);
+	var elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset, targetOffset);
+	var newElRegion = utils.merge(elRegion, elFuturePos);
+	if (visibleRect && (overflow.adjustX || overflow.adjustY) && isTgtRegionVisible) {
+		if (overflow.adjustX) {
+			if (isFailX(elFuturePos, elRegion, visibleRect)) {
+				var newPoints = flip(points, /[lr]/gi, {
+					l: "r",
+					r: "l"
+				});
+				var newOffset = flipOffset(offset, 0);
+				var newTargetOffset = flipOffset(targetOffset, 0);
+				if (!isCompleteFailX(getElFuturePos(elRegion, tgtRegion, newPoints, newOffset, newTargetOffset), elRegion, visibleRect)) {
+					fail = 1;
+					points = newPoints;
+					offset = newOffset;
+					targetOffset = newTargetOffset;
+				}
+			}
+		}
+		if (overflow.adjustY) {
+			if (isFailY(elFuturePos, elRegion, visibleRect)) {
+				var _newPoints = flip(points, /[tb]/gi, {
+					t: "b",
+					b: "t"
+				});
+				var _newOffset = flipOffset(offset, 1);
+				var _newTargetOffset = flipOffset(targetOffset, 1);
+				if (!isCompleteFailY(getElFuturePos(elRegion, tgtRegion, _newPoints, _newOffset, _newTargetOffset), elRegion, visibleRect)) {
+					fail = 1;
+					points = _newPoints;
+					offset = _newOffset;
+					targetOffset = _newTargetOffset;
+				}
+			}
+		}
+		if (fail) {
+			elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset, targetOffset);
+			utils.mix(newElRegion, elFuturePos);
+		}
+		var isStillFailX = isFailX(elFuturePos, elRegion, visibleRect);
+		var isStillFailY = isFailY(elFuturePos, elRegion, visibleRect);
+		if (isStillFailX || isStillFailY) {
+			var _newPoints2 = points;
+			if (isStillFailX) _newPoints2 = flip(points, /[lr]/gi, {
+				l: "r",
+				r: "l"
+			});
+			if (isStillFailY) _newPoints2 = flip(points, /[tb]/gi, {
+				t: "b",
+				b: "t"
+			});
+			points = _newPoints2;
+			offset = align.offset || [0, 0];
+			targetOffset = align.targetOffset || [0, 0];
+		}
+		newOverflowCfg.adjustX = overflow.adjustX && isStillFailX;
+		newOverflowCfg.adjustY = overflow.adjustY && isStillFailY;
+		if (newOverflowCfg.adjustX || newOverflowCfg.adjustY) newElRegion = adjustForViewport(elFuturePos, elRegion, visibleRect, newOverflowCfg);
+	}
+	if (newElRegion.width !== elRegion.width) utils.css(source, "width", utils.width(source) + newElRegion.width - elRegion.width);
+	if (newElRegion.height !== elRegion.height) utils.css(source, "height", utils.height(source) + newElRegion.height - elRegion.height);
+	utils.offset(source, {
+		left: newElRegion.left,
+		top: newElRegion.top
+	}, {
+		useCssRight: align.useCssRight,
+		useCssBottom: align.useCssBottom,
+		useCssTransform: align.useCssTransform,
+		ignoreShake: align.ignoreShake
+	});
+	return {
+		points,
+		offset,
+		targetOffset,
+		overflow: newOverflowCfg
+	};
+}
+/**
+*  2012-04-26 yiminghe@gmail.com
+*   - 优化智能对齐算法
+*   - 慎用 resizeXX
+*
+*  2011-07-13 yiminghe@gmail.com note:
+*   - 增加智能对齐，以及大小调整选项
+**/
+function isOutOfVisibleRect(target, alwaysByViewport) {
+	var visibleRect = getVisibleRectForElement(target, alwaysByViewport);
+	var targetRegion = getRegion(target);
+	return !visibleRect || targetRegion.left + targetRegion.width <= visibleRect.left || targetRegion.top + targetRegion.height <= visibleRect.top || targetRegion.left >= visibleRect.right || targetRegion.top >= visibleRect.bottom;
+}
+function alignElement(el, refNode, align) {
+	var target = align.target || refNode;
+	return doAlign(el, getRegion(target), align, !isOutOfVisibleRect(target, align.overflow && align.overflow.alwaysByViewport));
+}
+alignElement.__getOffsetParent = getOffsetParent;
+alignElement.__getVisibleRectForElement = getVisibleRectForElement;
+/**
+* `tgtPoint`: { pageX, pageY } or { clientX, clientY }.
+* If client position provided, will internal convert to page position.
+*/
+function alignPoint(el, tgtPoint, align) {
+	var pageX;
+	var pageY;
+	var doc = utils.getDocument(el);
+	var win = doc.defaultView || doc.parentWindow;
+	var scrollX = utils.getWindowScrollLeft(win);
+	var scrollY = utils.getWindowScrollTop(win);
+	var viewportWidth = utils.viewportWidth(win);
+	var viewportHeight = utils.viewportHeight(win);
+	if ("pageX" in tgtPoint) pageX = tgtPoint.pageX;
+	else pageX = scrollX + tgtPoint.clientX;
+	if ("pageY" in tgtPoint) pageY = tgtPoint.pageY;
+	else pageY = scrollY + tgtPoint.clientY;
+	var tgtRegion = {
+		left: pageX,
+		top: pageY,
+		width: 0,
+		height: 0
+	};
+	var pointInView = pageX >= 0 && pageX <= scrollX + viewportWidth && pageY >= 0 && pageY <= scrollY + viewportHeight;
+	var points = [align.points[0], "cc"];
+	return doAlign(el, tgtRegion, _objectSpread2(_objectSpread2({}, align), {}, { points }), pointInView);
+}
+//#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/isVisible.js
+var isVisible_default = ((element) => {
+	if (!element) return false;
+	if (element.offsetParent) return true;
+	if (element.getBBox) {
+		const box = element.getBBox();
+		if (box.width || box.height) return true;
+	}
+	if (element.getBoundingClientRect) {
+		const box = element.getBoundingClientRect();
+		if (box.width || box.height) return true;
+	}
+	return 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/vc-align/util.js
+function restoreFocus(activeElement, container) {
+	if (activeElement !== (void 0).activeElement && contains(container, activeElement) && typeof activeElement.focus === "function") activeElement.focus();
+}
+//#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-align/hooks/useBuffer.js
+var useBuffer_default = ((callback, buffer) => {
+	let called = false;
+	let timeout = null;
+	function cancelTrigger() {
+		clearTimeout(timeout);
+	}
+	function trigger(force) {
+		if (!called || force === true) {
+			if (callback() === false) return;
+			called = true;
+			cancelTrigger();
+			timeout = setTimeout(() => {
+				called = false;
+			}, buffer.value);
+		} else {
+			cancelTrigger();
+			timeout = setTimeout(() => {
+				called = false;
+				trigger();
+			}, buffer.value);
+		}
+	}
+	return [trigger, () => {
+		called = false;
+		cancelTrigger();
+	}];
+});
+//#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-align/Align.js
+var alignProps = {
+	align: Object,
+	target: [Object, Function],
+	onAlign: Function,
+	monitorBufferTime: Number,
+	monitorWindowResize: Boolean,
+	disabled: Boolean
+};
+function getElement(func) {
+	if (typeof func !== "function") return null;
+	return func();
+}
+function getPoint(point) {
+	if (typeof point !== "object" || !point) return null;
+	return point;
+}
+var Align_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "Align",
+	props: alignProps,
+	emits: ["align"],
+	setup(props, _ref) {
+		let { expose, slots } = _ref;
+		const cacheRef = ref({});
+		const nodeRef = ref();
+		const [forceAlign, cancelForceAlign] = useBuffer_default(() => {
+			const { disabled: latestDisabled, target: latestTarget, align: latestAlign, onAlign: latestOnAlign } = props;
+			if (!latestDisabled && latestTarget && nodeRef.value) {
+				const source = nodeRef.value;
+				let result;
+				const element = getElement(latestTarget);
+				const point = getPoint(latestTarget);
+				cacheRef.value.element = element;
+				cacheRef.value.point = point;
+				cacheRef.value.align = latestAlign;
+				const { activeElement } = void 0;
+				if (element && isVisible_default(element)) result = alignElement(source, element, latestAlign);
+				else if (point) result = alignPoint(source, point, latestAlign);
+				restoreFocus(activeElement, source);
+				if (latestOnAlign && result) latestOnAlign(source, result);
+				return true;
+			}
+			return false;
+		}, computed(() => props.monitorBufferTime));
+		ref({ cancel: () => {} });
+		ref({ cancel: () => {} });
+		watch(() => props.disabled, (disabled) => {
+			if (!disabled) forceAlign();
+			else cancelForceAlign();
+		}, {
+			immediate: true,
+			flush: "post"
+		});
+		const winResizeRef = ref(null);
+		watch(() => props.monitorWindowResize, (monitorWindowResize) => {
+			if (monitorWindowResize) {
+				if (!winResizeRef.value) winResizeRef.value = addEventListenerWrap(void 0, "resize", forceAlign);
+			} else if (winResizeRef.value) {
+				winResizeRef.value.remove();
+				winResizeRef.value = null;
+			}
+		}, { flush: "post" });
+		expose({ forceAlign: () => forceAlign(true) });
+		return () => {
+			const child = slots === null || slots === void 0 ? void 0 : slots.default();
+			if (child) return cloneElement(child[0], { ref: nodeRef }, true, true);
+			return 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-trigger/Popup/PopupInner.js
+var PopupInner_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "PopupInner",
+	inheritAttrs: false,
+	props: innerProps,
+	emits: [
+		"mouseenter",
+		"mouseleave",
+		"mousedown",
+		"touchstart",
+		"align"
+	],
+	setup(props, _ref) {
+		let { expose, attrs, slots } = _ref;
+		const alignRef = shallowRef();
+		const elementRef = shallowRef();
+		const alignedClassName = shallowRef();
+		const [stretchStyle] = useStretchStyle_default(toRef(props, "stretch"));
+		const visible = shallowRef(false);
+		let timeoutId;
+		watch(() => props.visible, (val) => {
+			clearTimeout(timeoutId);
+			if (val) timeoutId = setTimeout(() => {
+				visible.value = props.visible;
+			});
+			else visible.value = false;
+		}, { immediate: true });
+		const [status, goNextStatus] = useVisibleStatus_default(visible);
+		const prepareResolveRef = shallowRef();
+		const getAlignTarget = () => {
+			if (props.point) return props.point;
+			return props.getRootDomNode;
+		};
+		const forceAlign = () => {
+			var _a;
+			(_a = alignRef.value) === null || _a === void 0 || _a.forceAlign();
+		};
+		const onInternalAlign = (popupDomNode, matchAlign) => {
+			var _a;
+			const nextAlignedClassName = props.getClassNameFromAlign(matchAlign);
+			const preAlignedClassName = alignedClassName.value;
+			if (alignedClassName.value !== nextAlignedClassName) alignedClassName.value = nextAlignedClassName;
+			if (status.value === "align") {
+				if (preAlignedClassName !== nextAlignedClassName) Promise.resolve().then(() => {
+					forceAlign();
+				});
+				else goNextStatus(() => {
+					var _a;
+					(_a = prepareResolveRef.value) === null || _a === void 0 || _a.call(prepareResolveRef);
+				});
+				(_a = props.onAlign) === null || _a === void 0 || _a.call(props, popupDomNode, matchAlign);
+			}
+		};
+		const motion = computed(() => {
+			const m = typeof props.animation === "object" ? props.animation : getMotion(props);
+			["onAfterEnter", "onAfterLeave"].forEach((eventName) => {
+				const originFn = m[eventName];
+				m[eventName] = (node) => {
+					goNextStatus();
+					status.value = "stable";
+					originFn === null || originFn === void 0 || originFn(node);
+				};
+			});
+			return m;
+		});
+		const onShowPrepare = () => {
+			return new Promise((resolve) => {
+				prepareResolveRef.value = resolve;
+			});
+		};
+		watch([motion, status], () => {
+			if (!motion.value && status.value === "motion") goNextStatus();
+		}, { immediate: true });
+		expose({
+			forceAlign,
+			getElement: () => {
+				return elementRef.value.$el || elementRef.value;
+			}
+		});
+		const alignDisabled = computed(() => {
+			var _a;
+			if (((_a = props.align) === null || _a === void 0 ? void 0 : _a.points) && (status.value === "align" || status.value === "stable")) return false;
+			return true;
+		});
+		return () => {
+			var _a;
+			const { zIndex, align, prefixCls, destroyPopupOnHide, onMouseenter, onMouseleave, onTouchstart = () => {}, onMousedown } = props;
+			const statusValue = status.value;
+			const mergedStyle = [_extends(_extends({}, stretchStyle.value), {
+				zIndex,
+				opacity: statusValue === "motion" || statusValue === "stable" || !visible.value ? null : 0,
+				pointerEvents: !visible.value && statusValue !== "stable" ? "none" : null
+			}), attrs.style];
+			let childNode = flattenChildren((_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots, { visible: props.visible }));
+			if (childNode.length > 1) {
+				childNode = createVNode("div", { "class": `${prefixCls}-content` }, [childNode]);
+			}
+			const mergedClassName = classNames(prefixCls, attrs.class, alignedClassName.value, !props.arrow && `${prefixCls}-arrow-hidden`);
+			const transitionProps = visible.value || !props.visible ? getTransitionProps(motion.value.name, motion.value) : {};
+			return createVNode(Transition, _objectSpread2$1(_objectSpread2$1({ "ref": elementRef }, transitionProps), {}, { "onBeforeEnter": onShowPrepare }), { default: () => {
+				return !destroyPopupOnHide || props.visible ? withDirectives(createVNode(Align_default, {
+					"target": getAlignTarget(),
+					"key": "popup",
+					"ref": alignRef,
+					"monitorWindowResize": true,
+					"disabled": alignDisabled.value,
+					"align": align,
+					"onAlign": onInternalAlign
+				}, { default: () => createVNode("div", {
+					"class": mergedClassName,
+					"onMouseenter": onMouseenter,
+					"onMouseleave": onMouseleave,
+					"onMousedown": withModifiers(onMousedown, ["capture"]),
+					[supportsPassive_default ? "onTouchstartPassive" : "onTouchstart"]: withModifiers(onTouchstart, ["capture"]),
+					"style": mergedStyle
+				}, [childNode]) }), [[vShow, visible.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-trigger/Popup/index.js
+var Popup_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "Popup",
+	inheritAttrs: false,
+	props: popupProps,
+	setup(props, _ref) {
+		let { attrs, slots, expose } = _ref;
+		const innerVisible = shallowRef(false);
+		const inMobile = shallowRef(false);
+		const popupRef = shallowRef();
+		const rootRef = shallowRef();
+		watch([() => props.visible, () => props.mobile], () => {
+			innerVisible.value = props.visible;
+			if (props.visible && props.mobile) inMobile.value = true;
+		}, {
+			immediate: true,
+			flush: "post"
+		});
+		expose({
+			forceAlign: () => {
+				var _a;
+				(_a = popupRef.value) === null || _a === void 0 || _a.forceAlign();
+			},
+			getElement: () => {
+				var _a;
+				return (_a = popupRef.value) === null || _a === void 0 ? void 0 : _a.getElement();
+			}
+		});
+		return () => {
+			const cloneProps = _extends(_extends(_extends({}, props), attrs), { visible: innerVisible.value });
+			const popupNode = inMobile.value ? createVNode(MobilePopupInner_default, _objectSpread2$1(_objectSpread2$1({}, cloneProps), {}, {
+				"mobile": props.mobile,
+				"ref": popupRef
+			}), { default: slots.default }) : createVNode(PopupInner_default, _objectSpread2$1(_objectSpread2$1({}, cloneProps), {}, { "ref": popupRef }), { default: slots.default });
+			return createVNode("div", { "ref": rootRef }, [createVNode(Mask, cloneProps, null), popupNode]);
+		};
+	}
+});
+//#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-trigger/utils/alignUtil.js
+function isPointsEq(a1, a2, isAlignPoint) {
+	if (isAlignPoint) return a1[0] === a2[0];
+	return a1[0] === a2[0] && a1[1] === a2[1];
+}
+function getAlignFromPlacement(builtinPlacements, placementStr, align) {
+	const baseAlign = builtinPlacements[placementStr] || {};
+	return _extends(_extends({}, baseAlign), align);
+}
+function getAlignPopupClassName(builtinPlacements, prefixCls, align, isAlignPoint) {
+	const { points } = align;
+	const placements = Object.keys(builtinPlacements);
+	for (let i = 0; i < placements.length; i += 1) {
+		const placement = placements[i];
+		if (isPointsEq(builtinPlacements[placement].points, points, isAlignPoint)) return `${prefixCls}-placement-${placement}`;
+	}
+	return "";
+}
+//#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/BaseMixin.js
+var BaseMixin_default = { methods: {
+	setState() {
+		let state = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+		let callback = arguments.length > 1 ? arguments[1] : void 0;
+		let newState = typeof state === "function" ? state(this.$data, this.$props) : state;
+		if (this.getDerivedStateFromProps) {
+			const s = this.getDerivedStateFromProps(getOptionProps(this), _extends(_extends({}, this.$data), newState));
+			if (s === null) return;
+			else newState = _extends(_extends({}, newState), s || {});
+		}
+		_extends(this.$data, newState);
+		if (this._.isMounted) this.$forceUpdate();
+		nextTick(() => {
+			callback && callback();
+		});
+	},
+	__emit() {
+		const args = [].slice.call(arguments, 0);
+		let eventName = args[0];
+		eventName = `on${eventName[0].toUpperCase()}${eventName.substring(1)}`;
+		const event = this.$props[eventName] || this.$attrs[eventName];
+		if (args.length && event) {
+			if (Array.isArray(event)) for (let i = 0, l = event.length; i < l; i++) event[i](...args.slice(1));
+			else event(...args.slice(1));
+		}
+	}
+} };
+//#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-trigger/Trigger.js
+var ALL_HANDLERS = [
+	"onClick",
+	"onMousedown",
+	"onTouchstart",
+	"onMouseenter",
+	"onMouseleave",
+	"onFocus",
+	"onBlur",
+	"onContextmenu"
+];
+//#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-trigger/index.js
+var vc_trigger_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "Trigger",
+	mixins: [BaseMixin_default],
+	inheritAttrs: false,
+	props: triggerProps(),
+	setup(props) {
+		const align = computed(() => {
+			const { popupPlacement, popupAlign, builtinPlacements } = props;
+			if (popupPlacement && builtinPlacements) return getAlignFromPlacement(builtinPlacements, popupPlacement, popupAlign);
+			return popupAlign;
+		});
+		const popupRef = shallowRef(null);
+		const setPopupRef = (val) => {
+			popupRef.value = val;
+		};
+		return {
+			vcTriggerContext: inject("vcTriggerContext", {}),
+			popupRef,
+			setPopupRef,
+			triggerRef: shallowRef(null),
+			align,
+			focusTime: null,
+			clickOutsideHandler: null,
+			contextmenuOutsideHandler1: null,
+			contextmenuOutsideHandler2: null,
+			touchOutsideHandler: null,
+			attachId: null,
+			delayTimer: null,
+			hasPopupMouseDown: false,
+			preClickTime: null,
+			preTouchTime: null,
+			mouseDownTimeout: null,
+			childOriginEvents: {}
+		};
+	},
+	data() {
+		const props = this.$props;
+		let popupVisible;
+		if (this.popupVisible !== void 0) popupVisible = !!props.popupVisible;
+		else popupVisible = !!props.defaultPopupVisible;
+		ALL_HANDLERS.forEach((h) => {
+			this[`fire${h}`] = (e) => {
+				this.fireEvents(h, e);
+			};
+		});
+		return {
+			prevPopupVisible: popupVisible,
+			sPopupVisible: popupVisible,
+			point: null
+		};
+	},
+	watch: { popupVisible(val) {
+		if (val !== void 0) {
+			this.prevPopupVisible = this.sPopupVisible;
+			this.sPopupVisible = val;
+		}
+	} },
+	created() {
+		provide("vcTriggerContext", {
+			onPopupMouseDown: this.onPopupMouseDown,
+			onPopupMouseenter: this.onPopupMouseenter,
+			onPopupMouseleave: this.onPopupMouseleave
+		});
+		useProvidePortal(this);
+	},
+	deactivated() {
+		this.setPopupVisible(false);
+	},
+	mounted() {
+		this.$nextTick(() => {
+			this.updatedCal();
+		});
+	},
+	updated() {
+		this.$nextTick(() => {
+			this.updatedCal();
+		});
+	},
+	beforeUnmount() {
+		this.clearDelayTimer();
+		this.clearOutsideHandler();
+		clearTimeout(this.mouseDownTimeout);
+		wrapperRaf.cancel(this.attachId);
+	},
+	methods: {
+		updatedCal() {
+			const props = this.$props;
+			if (this.$data.sPopupVisible) {
+				let currentDocument;
+				if (!this.clickOutsideHandler && (this.isClickToHide() || this.isContextmenuToShow())) {
+					currentDocument = props.getDocument(this.getRootDomNode());
+					this.clickOutsideHandler = addEventListenerWrap(currentDocument, "mousedown", this.onDocumentClick);
+				}
+				if (!this.touchOutsideHandler) {
+					currentDocument = currentDocument || props.getDocument(this.getRootDomNode());
+					this.touchOutsideHandler = addEventListenerWrap(currentDocument, "touchstart", this.onDocumentClick, supportsPassive_default ? { passive: false } : false);
+				}
+				if (!this.contextmenuOutsideHandler1 && this.isContextmenuToShow()) {
+					currentDocument = currentDocument || props.getDocument(this.getRootDomNode());
+					this.contextmenuOutsideHandler1 = addEventListenerWrap(currentDocument, "scroll", this.onContextmenuClose);
+				}
+				if (!this.contextmenuOutsideHandler2 && this.isContextmenuToShow()) this.contextmenuOutsideHandler2 = addEventListenerWrap(void 0, "blur", this.onContextmenuClose);
+			} else this.clearOutsideHandler();
+		},
+		onMouseenter(e) {
+			const { mouseEnterDelay } = this.$props;
+			this.fireEvents("onMouseenter", e);
+			this.delaySetPopupVisible(true, mouseEnterDelay, mouseEnterDelay ? null : e);
+		},
+		onMouseMove(e) {
+			this.fireEvents("onMousemove", e);
+			this.setPoint(e);
+		},
+		onMouseleave(e) {
+			this.fireEvents("onMouseleave", e);
+			this.delaySetPopupVisible(false, this.$props.mouseLeaveDelay);
+		},
+		onPopupMouseenter() {
+			const { vcTriggerContext = {} } = this;
+			if (vcTriggerContext.onPopupMouseenter) vcTriggerContext.onPopupMouseenter();
+			this.clearDelayTimer();
+		},
+		onPopupMouseleave(e) {
+			var _a;
+			if (e && e.relatedTarget && !e.relatedTarget.setTimeout && contains((_a = this.popupRef) === null || _a === void 0 ? void 0 : _a.getElement(), e.relatedTarget)) return;
+			if (this.isMouseLeaveToHide()) this.delaySetPopupVisible(false, this.$props.mouseLeaveDelay);
+			const { vcTriggerContext = {} } = this;
+			if (vcTriggerContext.onPopupMouseleave) vcTriggerContext.onPopupMouseleave(e);
+		},
+		onFocus(e) {
+			this.fireEvents("onFocus", e);
+			this.clearDelayTimer();
+			if (this.isFocusToShow()) {
+				this.focusTime = Date.now();
+				this.delaySetPopupVisible(true, this.$props.focusDelay);
+			}
+		},
+		onMousedown(e) {
+			this.fireEvents("onMousedown", e);
+			this.preClickTime = Date.now();
+		},
+		onTouchstart(e) {
+			this.fireEvents("onTouchstart", e);
+			this.preTouchTime = Date.now();
+		},
+		onBlur(e) {
+			if (!contains(e.target, e.relatedTarget || (void 0).activeElement)) {
+				this.fireEvents("onBlur", e);
+				this.clearDelayTimer();
+				if (this.isBlurToHide()) this.delaySetPopupVisible(false, this.$props.blurDelay);
+			}
+		},
+		onContextmenu(e) {
+			e.preventDefault();
+			this.fireEvents("onContextmenu", e);
+			this.setPopupVisible(true, e);
+		},
+		onContextmenuClose() {
+			if (this.isContextmenuToShow()) this.close();
+		},
+		onClick(event) {
+			this.fireEvents("onClick", event);
+			if (this.focusTime) {
+				let preTime;
+				if (this.preClickTime && this.preTouchTime) preTime = Math.min(this.preClickTime, this.preTouchTime);
+				else if (this.preClickTime) preTime = this.preClickTime;
+				else if (this.preTouchTime) preTime = this.preTouchTime;
+				if (Math.abs(preTime - this.focusTime) < 20) return;
+				this.focusTime = 0;
+			}
+			this.preClickTime = 0;
+			this.preTouchTime = 0;
+			if (this.isClickToShow() && (this.isClickToHide() || this.isBlurToHide()) && event && event.preventDefault) event.preventDefault();
+			if (event && event.domEvent) event.domEvent.preventDefault();
+			const nextVisible = !this.$data.sPopupVisible;
+			if (this.isClickToHide() && !nextVisible || nextVisible && this.isClickToShow()) this.setPopupVisible(!this.$data.sPopupVisible, event);
+		},
+		onPopupMouseDown() {
+			const { vcTriggerContext = {} } = this;
+			this.hasPopupMouseDown = true;
+			clearTimeout(this.mouseDownTimeout);
+			this.mouseDownTimeout = setTimeout(() => {
+				this.hasPopupMouseDown = false;
+			}, 0);
+			if (vcTriggerContext.onPopupMouseDown) vcTriggerContext.onPopupMouseDown(...arguments);
+		},
+		onDocumentClick(event) {
+			if (this.$props.mask && !this.$props.maskClosable) return;
+			const target = event.target;
+			const root = this.getRootDomNode();
+			const popupNode = this.getPopupDomNode();
+			if ((!contains(root, target) || this.isContextMenuOnly()) && !contains(popupNode, target) && !this.hasPopupMouseDown) this.delaySetPopupVisible(false, .1);
+		},
+		getPopupDomNode() {
+			var _a;
+			return ((_a = this.popupRef) === null || _a === void 0 ? void 0 : _a.getElement()) || null;
+		},
+		getRootDomNode() {
+			var _a, _b, _c, _d;
+			const { getTriggerDOMNode } = this.$props;
+			if (getTriggerDOMNode) {
+				const domNode = ((_b = (_a = this.triggerRef) === null || _a === void 0 ? void 0 : _a.$el) === null || _b === void 0 ? void 0 : _b.nodeName) === "#comment" ? null : findDOMNode(this.triggerRef);
+				return findDOMNode(getTriggerDOMNode(domNode));
+			}
+			try {
+				const domNode = ((_d = (_c = this.triggerRef) === null || _c === void 0 ? void 0 : _c.$el) === null || _d === void 0 ? void 0 : _d.nodeName) === "#comment" ? null : findDOMNode(this.triggerRef);
+				if (domNode) return domNode;
+			} catch (err) {}
+			return findDOMNode(this);
+		},
+		handleGetPopupClassFromAlign(align) {
+			const className = [];
+			const { popupPlacement, builtinPlacements, prefixCls, alignPoint, getPopupClassNameFromAlign } = this.$props;
+			if (popupPlacement && builtinPlacements) className.push(getAlignPopupClassName(builtinPlacements, prefixCls, align, alignPoint));
+			if (getPopupClassNameFromAlign) className.push(getPopupClassNameFromAlign(align));
+			return className.join(" ");
+		},
+		getPopupAlign() {
+			const { popupPlacement, popupAlign, builtinPlacements } = this.$props;
+			if (popupPlacement && builtinPlacements) return getAlignFromPlacement(builtinPlacements, popupPlacement, popupAlign);
+			return popupAlign;
+		},
+		getComponent() {
+			const mouseProps = {};
+			if (this.isMouseEnterToShow()) mouseProps.onMouseenter = this.onPopupMouseenter;
+			if (this.isMouseLeaveToHide()) mouseProps.onMouseleave = this.onPopupMouseleave;
+			mouseProps.onMousedown = this.onPopupMouseDown;
+			mouseProps[supportsPassive_default ? "onTouchstartPassive" : "onTouchstart"] = this.onPopupMouseDown;
+			const { handleGetPopupClassFromAlign, getRootDomNode, $attrs } = this;
+			const { prefixCls, destroyPopupOnHide, popupClassName, popupAnimation, popupTransitionName, popupStyle, mask, maskAnimation, maskTransitionName, zIndex, stretch, alignPoint, mobile, arrow, forceRender } = this.$props;
+			const { sPopupVisible, point } = this.$data;
+			const popupProps = _extends(_extends({
+				prefixCls,
+				arrow,
+				destroyPopupOnHide,
+				visible: sPopupVisible,
+				point: alignPoint ? point : null,
+				align: this.align,
+				animation: popupAnimation,
+				getClassNameFromAlign: handleGetPopupClassFromAlign,
+				stretch,
+				getRootDomNode,
+				mask,
+				zIndex,
+				transitionName: popupTransitionName,
+				maskAnimation,
+				maskTransitionName,
+				class: popupClassName,
+				style: popupStyle,
+				onAlign: $attrs.onPopupAlign || noop
+			}, mouseProps), {
+				ref: this.setPopupRef,
+				mobile,
+				forceRender
+			});
+			return createVNode(Popup_default, popupProps, { default: this.$slots.popup || (() => getComponent(this, "popup")) });
+		},
+		attachParent(popupContainer) {
+			wrapperRaf.cancel(this.attachId);
+			const { getPopupContainer, getDocument } = this.$props;
+			const domNode = this.getRootDomNode();
+			let mountNode;
+			if (!getPopupContainer) mountNode = getDocument(this.getRootDomNode()).body;
+			else if (domNode || getPopupContainer.length === 0) mountNode = getPopupContainer(domNode);
+			if (mountNode) mountNode.appendChild(popupContainer);
+			else this.attachId = wrapperRaf(() => {
+				this.attachParent(popupContainer);
+			});
+		},
+		getContainer() {
+			const { $props: props } = this;
+			const { getDocument } = props;
+			const popupContainer = getDocument(this.getRootDomNode()).createElement("div");
+			popupContainer.style.position = "absolute";
+			popupContainer.style.top = "0";
+			popupContainer.style.left = "0";
+			popupContainer.style.width = "100%";
+			this.attachParent(popupContainer);
+			return popupContainer;
+		},
+		setPopupVisible(sPopupVisible, event) {
+			const { alignPoint, sPopupVisible: prevPopupVisible, onPopupVisibleChange } = this;
+			this.clearDelayTimer();
+			if (prevPopupVisible !== sPopupVisible) {
+				if (!hasProp(this, "popupVisible")) this.setState({
+					sPopupVisible,
+					prevPopupVisible
+				});
+				onPopupVisibleChange && onPopupVisibleChange(sPopupVisible);
+			}
+			if (alignPoint && event && sPopupVisible) this.setPoint(event);
+		},
+		setPoint(point) {
+			const { alignPoint } = this.$props;
+			if (!alignPoint || !point) return;
+			this.setState({ point: {
+				pageX: point.pageX,
+				pageY: point.pageY
+			} });
+		},
+		handlePortalUpdate() {
+			if (this.prevPopupVisible !== this.sPopupVisible) this.afterPopupVisibleChange(this.sPopupVisible);
+		},
+		delaySetPopupVisible(visible, delayS, event) {
+			const delay = delayS * 1e3;
+			this.clearDelayTimer();
+			if (delay) {
+				const point = event ? {
+					pageX: event.pageX,
+					pageY: event.pageY
+				} : null;
+				this.delayTimer = setTimeout(() => {
+					this.setPopupVisible(visible, point);
+					this.clearDelayTimer();
+				}, delay);
+			} else this.setPopupVisible(visible, event);
+		},
+		clearDelayTimer() {
+			if (this.delayTimer) {
+				clearTimeout(this.delayTimer);
+				this.delayTimer = null;
+			}
+		},
+		clearOutsideHandler() {
+			if (this.clickOutsideHandler) {
+				this.clickOutsideHandler.remove();
+				this.clickOutsideHandler = null;
+			}
+			if (this.contextmenuOutsideHandler1) {
+				this.contextmenuOutsideHandler1.remove();
+				this.contextmenuOutsideHandler1 = null;
+			}
+			if (this.contextmenuOutsideHandler2) {
+				this.contextmenuOutsideHandler2.remove();
+				this.contextmenuOutsideHandler2 = null;
+			}
+			if (this.touchOutsideHandler) {
+				this.touchOutsideHandler.remove();
+				this.touchOutsideHandler = null;
+			}
+		},
+		createTwoChains(event) {
+			let fn = () => {};
+			const events = getEvents(this);
+			if (this.childOriginEvents[event] && events[event]) return this[`fire${event}`];
+			fn = this.childOriginEvents[event] || events[event] || fn;
+			return fn;
+		},
+		isClickToShow() {
+			const { action, showAction } = this.$props;
+			return action.indexOf("click") !== -1 || showAction.indexOf("click") !== -1;
+		},
+		isContextMenuOnly() {
+			const { action } = this.$props;
+			return action === "contextmenu" || action.length === 1 && action[0] === "contextmenu";
+		},
+		isContextmenuToShow() {
+			const { action, showAction } = this.$props;
+			return action.indexOf("contextmenu") !== -1 || showAction.indexOf("contextmenu") !== -1;
+		},
+		isClickToHide() {
+			const { action, hideAction } = this.$props;
+			return action.indexOf("click") !== -1 || hideAction.indexOf("click") !== -1;
+		},
+		isMouseEnterToShow() {
+			const { action, showAction } = this.$props;
+			return action.indexOf("hover") !== -1 || showAction.indexOf("mouseenter") !== -1;
+		},
+		isMouseLeaveToHide() {
+			const { action, hideAction } = this.$props;
+			return action.indexOf("hover") !== -1 || hideAction.indexOf("mouseleave") !== -1;
+		},
+		isFocusToShow() {
+			const { action, showAction } = this.$props;
+			return action.indexOf("focus") !== -1 || showAction.indexOf("focus") !== -1;
+		},
+		isBlurToHide() {
+			const { action, hideAction } = this.$props;
+			return action.indexOf("focus") !== -1 || hideAction.indexOf("blur") !== -1;
+		},
+		forcePopupAlign() {
+			var _a;
+			if (this.$data.sPopupVisible) (_a = this.popupRef) === null || _a === void 0 || _a.forceAlign();
+		},
+		fireEvents(type, e) {
+			if (this.childOriginEvents[type]) this.childOriginEvents[type](e);
+			const event = this.$props[type] || this.$attrs[type];
+			if (event) event(e);
+		},
+		close() {
+			this.setPopupVisible(false);
+		}
+	},
+	render() {
+		const { $attrs } = this;
+		const children = filterEmpty(getSlot(this));
+		const { alignPoint, getPopupContainer } = this.$props;
+		const child = children[0];
+		this.childOriginEvents = getEvents(child);
+		const newChildProps = { key: "trigger" };
+		if (this.isContextmenuToShow()) newChildProps.onContextmenu = this.onContextmenu;
+		else newChildProps.onContextmenu = this.createTwoChains("onContextmenu");
+		if (this.isClickToHide() || this.isClickToShow()) {
+			newChildProps.onClick = this.onClick;
+			newChildProps.onMousedown = this.onMousedown;
+			newChildProps[supportsPassive_default ? "onTouchstartPassive" : "onTouchstart"] = this.onTouchstart;
+		} else {
+			newChildProps.onClick = this.createTwoChains("onClick");
+			newChildProps.onMousedown = this.createTwoChains("onMousedown");
+			newChildProps[supportsPassive_default ? "onTouchstartPassive" : "onTouchstart"] = this.createTwoChains("onTouchstart");
+		}
+		if (this.isMouseEnterToShow()) {
+			newChildProps.onMouseenter = this.onMouseenter;
+			if (alignPoint) newChildProps.onMousemove = this.onMouseMove;
+		} else newChildProps.onMouseenter = this.createTwoChains("onMouseenter");
+		if (this.isMouseLeaveToHide()) newChildProps.onMouseleave = this.onMouseleave;
+		else newChildProps.onMouseleave = this.createTwoChains("onMouseleave");
+		if (this.isFocusToShow() || this.isBlurToHide()) {
+			newChildProps.onFocus = this.onFocus;
+			newChildProps.onBlur = this.onBlur;
+		} else {
+			newChildProps.onFocus = this.createTwoChains("onFocus");
+			newChildProps.onBlur = (e) => {
+				if (e && (!e.relatedTarget || !contains(e.target, e.relatedTarget))) this.createTwoChains("onBlur")(e);
+			};
+		}
+		const childrenClassName = classNames(child && child.props && child.props.class, $attrs.class);
+		if (childrenClassName) newChildProps.class = childrenClassName;
+		const trigger = cloneElement(child, _extends(_extends({}, newChildProps), { ref: "triggerRef" }), true, true);
+		const portal = createVNode(PortalWrapper_default, {
+			"key": "portal",
+			"getContainer": getPopupContainer && (() => getPopupContainer(this.getRootDomNode())),
+			"didUpdate": this.handlePortalUpdate,
+			"visible": this.$data.sPopupVisible
+		}, { default: this.getComponent });
+		return createVNode(Fragment, null, [trigger, portal]);
+	}
+});
+//#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/hooks/useMergedState.js
+function useMergedState(defaultStateValue, option) {
+	const { defaultValue, value = ref() } = option || {};
+	let initValue = typeof defaultStateValue === "function" ? defaultStateValue() : defaultStateValue;
+	if (value.value !== void 0) initValue = unref(value);
+	if (defaultValue !== void 0) initValue = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+	const innerValue = ref(initValue);
+	const mergedValue = ref(initValue);
+	watchEffect(() => {
+		let val = value.value !== void 0 ? value.value : innerValue.value;
+		if (option.postState) val = option.postState(val);
+		mergedValue.value = val;
+	});
+	function triggerChange(newValue) {
+		const preVal = mergedValue.value;
+		innerValue.value = newValue;
+		if (toRaw(mergedValue.value) !== newValue && option.onChange) option.onChange(newValue, preVal);
+	}
+	watch(value, () => {
+		innerValue.value = value.value;
+	});
+	return [mergedValue, triggerChange];
+}
+//#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/firstNotUndefined.js
+function firstNotUndefined() {
+	let arr = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+	for (let i = 0, len = arr.length; i < len; i++) if (arr[i] !== void 0) return arr[i];
+}
+
+export { BaseMixin_default as B, isVisible_default as a, firstNotUndefined as f, index as i, useMergedState as u, vc_trigger_default as v, wrapperRaf as w };
+//# sourceMappingURL=firstNotUndefined-8H5_qHUu.mjs.map