agentworkshop 0.7.66 → 0.7.70

package/.output/server/chunks/build/input-number-BNlNDK7H.mjs

@@ -0,0 +1,1120 @@
+import { aT as Icon, o as _extends, k as useConfigInject_default, b7 as useCompactItemContext, Y as useInjectDisabled, q as classNames, r as _objectSpread2, Z as omit, an as NoCompactStyle, p as cloneElement, x as genComponentStyleHook, b8 as genCompactItemStyle, P as PropTypes, E as stringType, I as booleanType, K as resetComponent, b9 as resetIcon, ag as KeyCode, J as functionType, F as someType } from '../virtual/entry.mjs';
+import { w as wrapperRaf } from './firstNotUndefined-8H5_qHUu.mjs';
+import { g as getMergedStatus, d as getStatusClassNames, e as initInputToken, f as genBasicInputStyle, h as genStatusStyle, j as genPlaceholderStyle, k as genInputGroupStyle, l as genDisabledStyle, m as genActiveStyle, n as genHoverStyle } from '../_/SearchOutlined.mjs';
+import { u as useInjectFormItemContext, F as FormItemInputContext, N as NoFormStatus } from './FormItemContext-BlyzocS0.mjs';
+import { createVNode, defineComponent, computed, shallowRef, watch, ref } from 'vue';
+import { D as DownOutlined } from './select--XFl7CtY.mjs';
+
+// This icon file is generated automatically.
+var UpOutlined$1 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M890.5 755.3L537.9 269.2c-12.8-17.6-39-17.6-51.7 0L133.5 755.3A8 8 0 00140 768h75c5.1 0 9.9-2.5 12.9-6.6L512 369.8l284.1 391.6c3 4.1 7.8 6.6 12.9 6.6h75c6.5 0 10.3-7.4 6.5-12.7z" } }] }, "name": "up", "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 UpOutlined = function UpOutlined(props, context) {
+  var p = _objectSpread({}, props, context.attrs);
+
+  return createVNode(Icon, _objectSpread({}, p, {
+    "icon": UpOutlined$1
+  }), null);
+};
+
+UpOutlined.displayName = 'UpOutlined';
+UpOutlined.inheritAttrs = 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/input-number/src/utils/supportUtil.js
+function supportBigInt() {
+	return typeof BigInt === "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/input-number/src/utils/numberUtil.js
+/**
+* Format string number to readable number
+*/
+function trimNumber(numStr) {
+	let str = numStr.trim();
+	let negative = str.startsWith("-");
+	if (negative) str = str.slice(1);
+	str = str.replace(/(\.\d*[^0])0*$/, "$1").replace(/\.0*$/, "").replace(/^0+/, "");
+	if (str.startsWith(".")) str = `0${str}`;
+	const trimStr = str || "0";
+	const splitNumber = trimStr.split(".");
+	const integerStr = splitNumber[0] || "0";
+	const decimalStr = splitNumber[1] || "0";
+	if (integerStr === "0" && decimalStr === "0") negative = false;
+	const negativeStr = negative ? "-" : "";
+	return {
+		negative,
+		negativeStr,
+		trimStr,
+		integerStr,
+		decimalStr,
+		fullStr: `${negativeStr}${trimStr}`
+	};
+}
+function isE(number) {
+	const str = String(number);
+	return !Number.isNaN(Number(str)) && str.includes("e");
+}
+/**
+* [Legacy] Convert 1e-9 to 0.000000001.
+* This may lose some precision if user really want 1e-9.
+*/
+function getNumberPrecision(number) {
+	const numStr = String(number);
+	if (isE(number)) {
+		let precision = Number(numStr.slice(numStr.indexOf("e-") + 2));
+		const decimalMatch = numStr.match(/\.(\d+)/);
+		if (decimalMatch === null || decimalMatch === void 0 ? void 0 : decimalMatch[1]) precision += decimalMatch[1].length;
+		return precision;
+	}
+	return numStr.includes(".") && validateNumber(numStr) ? numStr.length - numStr.indexOf(".") - 1 : 0;
+}
+/**
+* Convert number (includes scientific notation) to -xxx.yyy format
+*/
+function num2str(number) {
+	let numStr = String(number);
+	if (isE(number)) {
+		if (number > Number.MAX_SAFE_INTEGER) return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);
+		if (number < Number.MIN_SAFE_INTEGER) return String(supportBigInt() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER);
+		numStr = number.toFixed(getNumberPrecision(numStr));
+	}
+	return trimNumber(numStr).fullStr;
+}
+function validateNumber(num) {
+	if (typeof num === "number") return !Number.isNaN(num);
+	if (!num) return false;
+	return /^\s*-?\d+(\.\d+)?\s*$/.test(num) || /^\s*-?\d+\.\s*$/.test(num) || /^\s*-?\.\d+\s*$/.test(num);
+}
+//#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-number/src/utils/MiniDecimal.js
+function isEmpty(value) {
+	return !value && value !== 0 && !Number.isNaN(value) || !String(value).trim();
+}
+/**
+* We can remove this when IE not support anymore
+*/
+var NumberDecimal = class NumberDecimal {
+	constructor(value) {
+		this.origin = "";
+		if (isEmpty(value)) {
+			this.empty = true;
+			return;
+		}
+		this.origin = String(value);
+		this.number = Number(value);
+	}
+	negate() {
+		return new NumberDecimal(-this.toNumber());
+	}
+	add(value) {
+		if (this.isInvalidate()) return new NumberDecimal(value);
+		const target = Number(value);
+		if (Number.isNaN(target)) return this;
+		const number = this.number + target;
+		if (number > Number.MAX_SAFE_INTEGER) return new NumberDecimal(Number.MAX_SAFE_INTEGER);
+		if (number < Number.MIN_SAFE_INTEGER) return new NumberDecimal(Number.MIN_SAFE_INTEGER);
+		const maxPrecision = Math.max(getNumberPrecision(this.number), getNumberPrecision(target));
+		return new NumberDecimal(number.toFixed(maxPrecision));
+	}
+	isEmpty() {
+		return this.empty;
+	}
+	isNaN() {
+		return Number.isNaN(this.number);
+	}
+	isInvalidate() {
+		return this.isEmpty() || this.isNaN();
+	}
+	equals(target) {
+		return this.toNumber() === (target === null || target === void 0 ? void 0 : target.toNumber());
+	}
+	lessEquals(target) {
+		return this.add(target.negate().toString()).toNumber() <= 0;
+	}
+	toNumber() {
+		return this.number;
+	}
+	toString() {
+		if (!(arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true)) return this.origin;
+		if (this.isInvalidate()) return "";
+		return num2str(this.number);
+	}
+};
+var BigIntDecimal = class BigIntDecimal {
+	constructor(value) {
+		this.origin = "";
+		if (isEmpty(value)) {
+			this.empty = true;
+			return;
+		}
+		this.origin = String(value);
+		if (value === "-" || Number.isNaN(value)) {
+			this.nan = true;
+			return;
+		}
+		let mergedValue = value;
+		if (isE(mergedValue)) mergedValue = Number(mergedValue);
+		mergedValue = typeof mergedValue === "string" ? mergedValue : num2str(mergedValue);
+		if (validateNumber(mergedValue)) {
+			const trimRet = trimNumber(mergedValue);
+			this.negative = trimRet.negative;
+			const numbers = trimRet.trimStr.split(".");
+			this.integer = BigInt(numbers[0]);
+			const decimalStr = numbers[1] || "0";
+			this.decimal = BigInt(decimalStr);
+			this.decimalLen = decimalStr.length;
+		} else this.nan = true;
+	}
+	getMark() {
+		return this.negative ? "-" : "";
+	}
+	getIntegerStr() {
+		return this.integer.toString();
+	}
+	getDecimalStr() {
+		return this.decimal.toString().padStart(this.decimalLen, "0");
+	}
+	/**
+	* Align BigIntDecimal with same decimal length. e.g. 12.3 + 5 = 1230000
+	* This is used for add function only.
+	*/
+	alignDecimal(decimalLength) {
+		const str = `${this.getMark()}${this.getIntegerStr()}${this.getDecimalStr().padEnd(decimalLength, "0")}`;
+		return BigInt(str);
+	}
+	negate() {
+		const clone = new BigIntDecimal(this.toString());
+		clone.negative = !clone.negative;
+		return clone;
+	}
+	add(value) {
+		if (this.isInvalidate()) return new BigIntDecimal(value);
+		const offset = new BigIntDecimal(value);
+		if (offset.isInvalidate()) return this;
+		const maxDecimalLength = Math.max(this.getDecimalStr().length, offset.getDecimalStr().length);
+		const { negativeStr, trimStr } = trimNumber((this.alignDecimal(maxDecimalLength) + offset.alignDecimal(maxDecimalLength)).toString());
+		const hydrateValueStr = `${negativeStr}${trimStr.padStart(maxDecimalLength + 1, "0")}`;
+		return new BigIntDecimal(`${hydrateValueStr.slice(0, -maxDecimalLength)}.${hydrateValueStr.slice(-maxDecimalLength)}`);
+	}
+	isEmpty() {
+		return this.empty;
+	}
+	isNaN() {
+		return this.nan;
+	}
+	isInvalidate() {
+		return this.isEmpty() || this.isNaN();
+	}
+	equals(target) {
+		return this.toString() === (target === null || target === void 0 ? void 0 : target.toString());
+	}
+	lessEquals(target) {
+		return this.add(target.negate().toString()).toNumber() <= 0;
+	}
+	toNumber() {
+		if (this.isNaN()) return NaN;
+		return Number(this.toString());
+	}
+	toString() {
+		if (!(arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true)) return this.origin;
+		if (this.isInvalidate()) return "";
+		return trimNumber(`${this.getMark()}${this.getIntegerStr()}.${this.getDecimalStr()}`).fullStr;
+	}
+};
+function getMiniDecimal(value) {
+	if (supportBigInt()) return new BigIntDecimal(value);
+	return new NumberDecimal(value);
+}
+/**
+* Align the logic of toFixed to around like 1.5 => 2.
+* If set `cutOnly`, will just remove the over decimal part.
+*/
+function toFixed(numStr, separatorStr, precision) {
+	let cutOnly = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+	if (numStr === "") return "";
+	const { negativeStr, integerStr, decimalStr } = trimNumber(numStr);
+	const precisionDecimalStr = `${separatorStr}${decimalStr}`;
+	const numberWithoutDecimal = `${negativeStr}${integerStr}`;
+	if (precision >= 0) {
+		const advancedNum = Number(decimalStr[precision]);
+		if (advancedNum >= 5 && !cutOnly) return toFixed(getMiniDecimal(numStr).add(`${negativeStr}0.${"0".repeat(precision)}${10 - advancedNum}`).toString(), separatorStr, precision, cutOnly);
+		if (precision === 0) return numberWithoutDecimal;
+		return `${numberWithoutDecimal}${separatorStr}${decimalStr.padEnd(precision, "0").slice(0, precision)}`;
+	}
+	if (precisionDecimalStr === ".0") return numberWithoutDecimal;
+	return `${numberWithoutDecimal}${precisionDecimalStr}`;
+}
+//#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-number/src/StepHandler.js
+/**
+* When click and hold on a button - the speed of auto changing the value.
+*/
+var STEP_INTERVAL = 200;
+/**
+* When click and hold on a button - the delay before auto changing the value.
+*/
+var STEP_DELAY = 600;
+var StepHandler_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "StepHandler",
+	inheritAttrs: false,
+	props: {
+		prefixCls: String,
+		upDisabled: Boolean,
+		downDisabled: Boolean,
+		onStep: functionType()
+	},
+	slots: Object,
+	setup(props, _ref) {
+		let { slots, emit } = _ref;
+		const stepTimeoutRef = ref();
+		const onStepMouseDown = (e, up) => {
+			e.preventDefault();
+			emit("step", up);
+			function loopStep() {
+				emit("step", up);
+				stepTimeoutRef.value = setTimeout(loopStep, STEP_INTERVAL);
+			}
+			stepTimeoutRef.value = setTimeout(loopStep, STEP_DELAY);
+		};
+		const onStopStep = () => {
+			clearTimeout(stepTimeoutRef.value);
+		};
+		return () => {
+			const { prefixCls, upDisabled, downDisabled } = props;
+			const handlerClassName = `${prefixCls}-handler`;
+			const upClassName = classNames(handlerClassName, `${handlerClassName}-up`, { [`${handlerClassName}-up-disabled`]: upDisabled });
+			const downClassName = classNames(handlerClassName, `${handlerClassName}-down`, { [`${handlerClassName}-down-disabled`]: downDisabled });
+			const sharedHandlerProps = {
+				unselectable: "on",
+				role: "button",
+				onMouseup: onStopStep,
+				onMouseleave: onStopStep
+			};
+			const { upNode, downNode } = slots;
+			return createVNode("div", { "class": `${handlerClassName}-wrap` }, [createVNode("span", _objectSpread2(_objectSpread2({}, sharedHandlerProps), {}, {
+				"onMousedown": (e) => {
+					onStepMouseDown(e, true);
+				},
+				"aria-label": "Increase Value",
+				"aria-disabled": upDisabled,
+				"class": upClassName
+			}), [(upNode === null || upNode === void 0 ? void 0 : upNode()) || createVNode("span", {
+				"unselectable": "on",
+				"class": `${prefixCls}-handler-up-inner`
+			}, null)]), createVNode("span", _objectSpread2(_objectSpread2({}, sharedHandlerProps), {}, {
+				"onMousedown": (e) => {
+					onStepMouseDown(e, false);
+				},
+				"aria-label": "Decrease Value",
+				"aria-disabled": downDisabled,
+				"class": downClassName
+			}), [(downNode === null || downNode === void 0 ? void 0 : downNode()) || createVNode("span", {
+				"unselectable": "on",
+				"class": `${prefixCls}-handler-down-inner`
+			}, 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/input-number/src/hooks/useCursor.js
+/**
+* Keep input cursor in the correct position if possible.
+* Is this necessary since we have `formatter` which may mass the content?
+*/
+function useCursor(inputRef, focused) {
+	const selectionRef = ref(null);
+	function recordCursor() {
+		try {
+			const { selectionStart: start, selectionEnd: end, value } = inputRef.value;
+			const beforeTxt = value.substring(0, start);
+			const afterTxt = value.substring(end);
+			selectionRef.value = {
+				start,
+				end,
+				value,
+				beforeTxt,
+				afterTxt
+			};
+		} catch (e) {}
+	}
+	/**
+	* Restore logic:
+	*  1. back string same
+	*  2. start string same
+	*/
+	function restoreCursor() {
+		if (inputRef.value && selectionRef.value && focused.value) try {
+			const { value } = inputRef.value;
+			const { beforeTxt, afterTxt, start } = selectionRef.value;
+			let startPos = value.length;
+			if (value.endsWith(afterTxt)) startPos = value.length - selectionRef.value.afterTxt.length;
+			else if (value.startsWith(beforeTxt)) startPos = beforeTxt.length;
+			else {
+				const beforeLastChar = beforeTxt[start - 1];
+				const newIndex = value.indexOf(beforeLastChar, start - 1);
+				if (newIndex !== -1) startPos = newIndex + 1;
+			}
+			inputRef.value.setSelectionRange(startPos, startPos);
+		} catch (e) {
+			`${e.message}`;
+		}
+	}
+	return [recordCursor, restoreCursor];
+}
+//#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-number/src/hooks/useFrame.js
+/**
+* Always trigger latest once when call multiple time
+*/
+var useFrame_default = (() => {
+	const idRef = shallowRef(0);
+	const cleanUp = () => {
+		wrapperRaf.cancel(idRef.value);
+	};
+	return (callback) => {
+		cleanUp();
+		idRef.value = wrapperRaf(() => {
+			callback();
+		});
+	};
+});
+//#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-number/src/InputNumber.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;
+};
+/**
+* We support `stringMode` which need handle correct type when user call in onChange
+* format max or min value
+* 1. if isInvalid return null
+* 2. if precision is undefined, return decimal
+* 3. format with precision
+*    I. if max > 0, round down with precision. Example: max= 3.5, precision=0  afterFormat: 3
+*    II. if max < 0, round up with precision. Example: max= -3.5, precision=0  afterFormat: -4
+*    III. if min > 0, round up with precision. Example: min= 3.5, precision=0  afterFormat: 4
+*    IV. if min < 0, round down with precision. Example: max= -3.5, precision=0  afterFormat: -3
+*/
+var getDecimalValue = (stringMode, decimalValue) => {
+	if (stringMode || decimalValue.isEmpty()) return decimalValue.toString();
+	return decimalValue.toNumber();
+};
+var getDecimalIfValidate = (value) => {
+	const decimal = getMiniDecimal(value);
+	return decimal.isInvalidate() ? null : decimal;
+};
+var inputNumberProps$1 = () => ({
+	/** value will show as string */
+	stringMode: booleanType(),
+	defaultValue: someType([String, Number]),
+	value: someType([String, Number]),
+	prefixCls: stringType(),
+	min: someType([String, Number]),
+	max: someType([String, Number]),
+	step: someType([String, Number], 1),
+	tabindex: Number,
+	controls: booleanType(true),
+	readonly: booleanType(),
+	disabled: booleanType(),
+	autofocus: booleanType(),
+	keyboard: booleanType(true),
+	/** Parse display value to validate number */
+	parser: functionType(),
+	/** Transform `value` to display value show in input */
+	formatter: functionType(),
+	/** Syntactic sugar of `formatter`. Config precision of display. */
+	precision: Number,
+	/** Syntactic sugar of `formatter`. Config decimal separator of display. */
+	decimalSeparator: String,
+	onInput: functionType(),
+	onChange: functionType(),
+	onPressEnter: functionType(),
+	onStep: functionType(),
+	onBlur: functionType(),
+	onFocus: functionType()
+});
+var InputNumber_default = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "InnerInputNumber",
+	inheritAttrs: false,
+	props: _extends(_extends({}, inputNumberProps$1()), { lazy: Boolean }),
+	slots: Object,
+	setup(props, _ref) {
+		let { attrs, slots, emit, expose } = _ref;
+		const inputRef = shallowRef();
+		const focus = shallowRef(false);
+		const userTypingRef = shallowRef(false);
+		const compositionRef = shallowRef(false);
+		const decimalValue = shallowRef(getMiniDecimal(props.value));
+		function setUncontrolledDecimalValue(newDecimal) {
+			if (props.value === void 0) decimalValue.value = newDecimal;
+		}
+		/**
+		* `precision` is used for formatter & onChange.
+		* It will auto generate by `value` & `step`.
+		* But it will not block user typing.
+		*
+		* Note: Auto generate `precision` is used for legacy logic.
+		* We should remove this since we already support high precision with BigInt.
+		*
+		* @param number  Provide which number should calculate precision
+		* @param userTyping  Change by user typing
+		*/
+		const getPrecision = (numStr, userTyping) => {
+			if (userTyping) return;
+			if (props.precision >= 0) return props.precision;
+			return Math.max(getNumberPrecision(numStr), getNumberPrecision(props.step));
+		};
+		const mergedParser = (num) => {
+			const numStr = String(num);
+			if (props.parser) return props.parser(numStr);
+			let parsedStr = numStr;
+			if (props.decimalSeparator) parsedStr = parsedStr.replace(props.decimalSeparator, ".");
+			return parsedStr.replace(/[^\w.-]+/g, "");
+		};
+		const inputValue = shallowRef("");
+		const mergedFormatter = (number, userTyping) => {
+			if (props.formatter) return props.formatter(number, {
+				userTyping,
+				input: String(inputValue.value)
+			});
+			let str = typeof number === "number" ? num2str(number) : number;
+			if (!userTyping) {
+				const mergedPrecision = getPrecision(str, userTyping);
+				if (validateNumber(str) && (props.decimalSeparator || mergedPrecision >= 0)) {
+					const separatorStr = props.decimalSeparator || ".";
+					str = toFixed(str, separatorStr, mergedPrecision);
+				}
+			}
+			return str;
+		};
+		inputValue.value = (() => {
+			const initValue = props.value;
+			if (decimalValue.value.isInvalidate() && ["string", "number"].includes(typeof initValue)) return Number.isNaN(initValue) ? "" : initValue;
+			return mergedFormatter(decimalValue.value.toString(), false);
+		})();
+		function setInputValue(newValue, userTyping) {
+			inputValue.value = mergedFormatter(newValue.isInvalidate() ? newValue.toString(false) : newValue.toString(!userTyping), userTyping);
+		}
+		const maxDecimal = computed(() => getDecimalIfValidate(props.max));
+		const minDecimal = computed(() => getDecimalIfValidate(props.min));
+		const upDisabled = computed(() => {
+			if (!maxDecimal.value || !decimalValue.value || decimalValue.value.isInvalidate()) return false;
+			return maxDecimal.value.lessEquals(decimalValue.value);
+		});
+		const downDisabled = computed(() => {
+			if (!minDecimal.value || !decimalValue.value || decimalValue.value.isInvalidate()) return false;
+			return decimalValue.value.lessEquals(minDecimal.value);
+		});
+		const [recordCursor, restoreCursor] = useCursor(inputRef, focus);
+		/**
+		* Find target value closet within range.
+		* e.g. [11, 28]:
+		*    3  => 11
+		*    23 => 23
+		*    99 => 28
+		*/
+		const getRangeValue = (target) => {
+			if (maxDecimal.value && !target.lessEquals(maxDecimal.value)) return maxDecimal.value;
+			if (minDecimal.value && !minDecimal.value.lessEquals(target)) return minDecimal.value;
+			return null;
+		};
+		/**
+		* Check value is in [min, max] range
+		*/
+		const isInRange = (target) => !getRangeValue(target);
+		/**
+		* Trigger `onChange` if value validated and not equals of origin.
+		* Return the value that re-align in range.
+		*/
+		const triggerValueUpdate = (newValue, userTyping) => {
+			var _a;
+			let updateValue = newValue;
+			let isRangeValidate = isInRange(updateValue) || updateValue.isEmpty();
+			if (!updateValue.isEmpty() && !userTyping) {
+				updateValue = getRangeValue(updateValue) || updateValue;
+				isRangeValidate = true;
+			}
+			if (!props.readonly && !props.disabled && isRangeValidate) {
+				const numStr = updateValue.toString();
+				const mergedPrecision = getPrecision(numStr, userTyping);
+				if (mergedPrecision >= 0) updateValue = getMiniDecimal(toFixed(numStr, ".", mergedPrecision));
+				if (!updateValue.equals(decimalValue.value)) {
+					setUncontrolledDecimalValue(updateValue);
+					(_a = props.onChange) === null || _a === void 0 || _a.call(props, updateValue.isEmpty() ? null : getDecimalValue(props.stringMode, updateValue));
+					if (props.value === void 0) setInputValue(updateValue, userTyping);
+				}
+				return updateValue;
+			}
+			return decimalValue.value;
+		};
+		const onNextPromise = useFrame_default();
+		const collectInputValue = (inputStr) => {
+			var _a;
+			recordCursor();
+			inputValue.value = inputStr;
+			if (!compositionRef.value) {
+				const finalDecimal = getMiniDecimal(mergedParser(inputStr));
+				if (!finalDecimal.isNaN()) triggerValueUpdate(finalDecimal, true);
+			}
+			(_a = props.onInput) === null || _a === void 0 || _a.call(props, inputStr);
+			onNextPromise(() => {
+				let nextInputStr = inputStr;
+				if (!props.parser) nextInputStr = inputStr.replace(/。/g, ".");
+				if (nextInputStr !== inputStr) collectInputValue(nextInputStr);
+			});
+		};
+		const onCompositionStart = () => {
+			compositionRef.value = true;
+		};
+		const onCompositionEnd = () => {
+			compositionRef.value = false;
+			collectInputValue(inputRef.value.value);
+		};
+		const onInternalInput = (e) => {
+			collectInputValue(e.target.value);
+		};
+		const onInternalStep = (up) => {
+			var _a, _b;
+			if (up && upDisabled.value || !up && downDisabled.value) return;
+			userTypingRef.value = false;
+			let stepDecimal = getMiniDecimal(props.step);
+			if (!up) stepDecimal = stepDecimal.negate();
+			const target = (decimalValue.value || getMiniDecimal(0)).add(stepDecimal.toString());
+			const updatedValue = triggerValueUpdate(target, false);
+			(_a = props.onStep) === null || _a === void 0 || _a.call(props, getDecimalValue(props.stringMode, updatedValue), {
+				offset: props.step,
+				type: up ? "up" : "down"
+			});
+			(_b = inputRef.value) === null || _b === void 0 || _b.focus();
+		};
+		/**
+		* Flush current input content to trigger value change & re-formatter input if needed
+		*/
+		const flushInputValue = (userTyping) => {
+			const parsedValue = getMiniDecimal(mergedParser(inputValue.value));
+			let formatValue = parsedValue;
+			if (!parsedValue.isNaN()) formatValue = triggerValueUpdate(parsedValue, userTyping);
+			else formatValue = decimalValue.value;
+			if (props.value !== void 0) setInputValue(decimalValue.value, false);
+			else if (!formatValue.isNaN()) setInputValue(formatValue, false);
+		};
+		const onBeforeInput = () => {
+			userTypingRef.value = true;
+		};
+		const onKeyDown = (event) => {
+			var _a;
+			const { which } = event;
+			userTypingRef.value = true;
+			if (which === KeyCode.ENTER) {
+				if (!compositionRef.value) userTypingRef.value = false;
+				flushInputValue(false);
+				(_a = props.onPressEnter) === null || _a === void 0 || _a.call(props, event);
+			}
+			if (props.keyboard === false) return;
+			if (!compositionRef.value && [KeyCode.UP, KeyCode.DOWN].includes(which)) {
+				onInternalStep(KeyCode.UP === which);
+				event.preventDefault();
+			}
+		};
+		const onKeyUp = () => {
+			userTypingRef.value = false;
+		};
+		const onBlur = (e) => {
+			flushInputValue(false);
+			focus.value = false;
+			userTypingRef.value = false;
+			emit("blur", e);
+		};
+		watch(() => props.precision, () => {
+			if (!decimalValue.value.isInvalidate()) setInputValue(decimalValue.value, false);
+		}, { flush: "post" });
+		watch(() => props.value, () => {
+			const newValue = getMiniDecimal(props.value);
+			decimalValue.value = newValue;
+			const currentParsedValue = getMiniDecimal(mergedParser(inputValue.value));
+			if (!newValue.equals(currentParsedValue) || !userTypingRef.value || props.formatter) setInputValue(newValue, userTypingRef.value);
+		}, { flush: "post" });
+		watch(inputValue, () => {
+			if (props.formatter) restoreCursor();
+		}, { flush: "post" });
+		watch(() => props.disabled, (val) => {
+			if (val) focus.value = false;
+		});
+		expose({
+			focus: () => {
+				var _a;
+				(_a = inputRef.value) === null || _a === void 0 || _a.focus();
+			},
+			blur: () => {
+				var _a;
+				(_a = inputRef.value) === null || _a === void 0 || _a.blur();
+			}
+		});
+		return () => {
+			const _a = _extends(_extends({}, attrs), props), { prefixCls = "rc-input-number", min, max, step = 1, defaultValue, value, disabled, readonly, keyboard, controls = true, autofocus, stringMode, parser, formatter, precision, decimalSeparator, onChange, onInput, onPressEnter, onStep, lazy, class: className, style } = _a, inputProps = __rest$1(_a, [
+				"prefixCls",
+				"min",
+				"max",
+				"step",
+				"defaultValue",
+				"value",
+				"disabled",
+				"readonly",
+				"keyboard",
+				"controls",
+				"autofocus",
+				"stringMode",
+				"parser",
+				"formatter",
+				"precision",
+				"decimalSeparator",
+				"onChange",
+				"onInput",
+				"onPressEnter",
+				"onStep",
+				"lazy",
+				"class",
+				"style"
+			]);
+			const { upHandler, downHandler } = slots;
+			const inputClassName = `${prefixCls}-input`;
+			const eventProps = {};
+			if (lazy) eventProps.onChange = onInternalInput;
+			else eventProps.onInput = onInternalInput;
+			return createVNode("div", {
+				"class": classNames(prefixCls, className, {
+					[`${prefixCls}-focused`]: focus.value,
+					[`${prefixCls}-disabled`]: disabled,
+					[`${prefixCls}-readonly`]: readonly,
+					[`${prefixCls}-not-a-number`]: decimalValue.value.isNaN(),
+					[`${prefixCls}-out-of-range`]: !decimalValue.value.isInvalidate() && !isInRange(decimalValue.value)
+				}),
+				"style": style,
+				"onKeydown": onKeyDown,
+				"onKeyup": onKeyUp
+			}, [controls && createVNode(StepHandler_default, {
+				"prefixCls": prefixCls,
+				"upDisabled": upDisabled.value,
+				"downDisabled": downDisabled.value,
+				"onStep": onInternalStep
+			}, {
+				upNode: upHandler,
+				downNode: downHandler
+			}), createVNode("div", { "class": `${inputClassName}-wrap` }, [createVNode("input", _objectSpread2(_objectSpread2(_objectSpread2({
+				"autofocus": autofocus,
+				"autocomplete": "off",
+				"role": "spinbutton",
+				"aria-valuemin": min,
+				"aria-valuemax": max,
+				"aria-valuenow": decimalValue.value.isInvalidate() ? null : decimalValue.value.toString(),
+				"step": step
+			}, inputProps), {}, {
+				"ref": inputRef,
+				"class": inputClassName,
+				"value": inputValue.value,
+				"disabled": disabled,
+				"readonly": readonly,
+				"onFocus": (e) => {
+					focus.value = true;
+					emit("focus", e);
+				}
+			}, eventProps), {}, {
+				"onBlur": onBlur,
+				"onCompositionstart": onCompositionStart,
+				"onCompositionend": onCompositionEnd,
+				"onBeforeinput": onBeforeInput
+			}), 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/_util/isValidValue.js
+function isValidValue_default(val) {
+	return val !== void 0 && val !== 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/input-number/style/index.js
+var genInputNumberStyles = (token) => {
+	const { componentCls, lineWidth, lineType, colorBorder, borderRadius, fontSizeLG, controlHeightLG, controlHeightSM, colorError, inputPaddingHorizontalSM, colorTextDescription, motionDurationMid, colorPrimary, controlHeight, inputPaddingHorizontal, colorBgContainer, colorTextDisabled, borderRadiusSM, borderRadiusLG, controlWidth, handleVisible } = token;
+	return [
+		{ [componentCls]: _extends(_extends(_extends(_extends({}, resetComponent(token)), genBasicInputStyle(token)), genStatusStyle(token, componentCls)), {
+			display: "inline-block",
+			width: controlWidth,
+			margin: 0,
+			padding: 0,
+			border: `${lineWidth}px ${lineType} ${colorBorder}`,
+			borderRadius,
+			"&-rtl": {
+				direction: "rtl",
+				[`${componentCls}-input`]: { direction: "rtl" }
+			},
+			"&-lg": {
+				padding: 0,
+				fontSize: fontSizeLG,
+				borderRadius: borderRadiusLG,
+				[`input${componentCls}-input`]: { height: controlHeightLG - 2 * lineWidth }
+			},
+			"&-sm": {
+				padding: 0,
+				borderRadius: borderRadiusSM,
+				[`input${componentCls}-input`]: {
+					height: controlHeightSM - 2 * lineWidth,
+					padding: `0 ${inputPaddingHorizontalSM}px`
+				}
+			},
+			"&:hover": _extends({}, genHoverStyle(token)),
+			"&-focused": _extends({}, genActiveStyle(token)),
+			"&-disabled": _extends(_extends({}, genDisabledStyle(token)), { [`${componentCls}-input`]: { cursor: "not-allowed" } }),
+			"&-out-of-range": { input: { color: colorError } },
+			"&-group": _extends(_extends(_extends({}, resetComponent(token)), genInputGroupStyle(token)), { "&-wrapper": {
+				display: "inline-block",
+				textAlign: "start",
+				verticalAlign: "top",
+				[`${componentCls}-affix-wrapper`]: { width: "100%" },
+				"&-lg": { [`${componentCls}-group-addon`]: { borderRadius: borderRadiusLG } },
+				"&-sm": { [`${componentCls}-group-addon`]: { borderRadius: borderRadiusSM } }
+			} }),
+			[componentCls]: { "&-input": _extends(_extends({
+				width: "100%",
+				height: controlHeight - 2 * lineWidth,
+				padding: `0 ${inputPaddingHorizontal}px`,
+				textAlign: "start",
+				backgroundColor: "transparent",
+				border: 0,
+				borderRadius,
+				outline: 0,
+				transition: `all ${motionDurationMid} linear`,
+				appearance: "textfield",
+				color: token.colorText,
+				fontSize: "inherit",
+				verticalAlign: "top"
+			}, genPlaceholderStyle(token.colorTextPlaceholder)), { "&[type=\"number\"]::-webkit-inner-spin-button, &[type=\"number\"]::-webkit-outer-spin-button": {
+				margin: 0,
+				webkitAppearance: "none",
+				appearance: "none"
+			} }) }
+		}) },
+		{ [componentCls]: {
+			[`&:hover ${componentCls}-handler-wrap, &-focused ${componentCls}-handler-wrap`]: { opacity: 1 },
+			[`${componentCls}-handler-wrap`]: {
+				position: "absolute",
+				insetBlockStart: 0,
+				insetInlineEnd: 0,
+				width: token.handleWidth,
+				height: "100%",
+				background: colorBgContainer,
+				borderStartStartRadius: 0,
+				borderStartEndRadius: borderRadius,
+				borderEndEndRadius: borderRadius,
+				borderEndStartRadius: 0,
+				opacity: handleVisible === true ? 1 : 0,
+				display: "flex",
+				flexDirection: "column",
+				alignItems: "stretch",
+				transition: `opacity ${motionDurationMid} linear ${motionDurationMid}`,
+				[`${componentCls}-handler`]: {
+					display: "flex",
+					alignItems: "center",
+					justifyContent: "center",
+					flex: "auto",
+					height: "40%",
+					[`
+              ${componentCls}-handler-up-inner,
+              ${componentCls}-handler-down-inner
+            `]: {
+						marginInlineEnd: 0,
+						fontSize: token.handleFontSize
+					}
+				}
+			},
+			[`${componentCls}-handler`]: {
+				height: "50%",
+				overflow: "hidden",
+				color: colorTextDescription,
+				fontWeight: "bold",
+				lineHeight: 0,
+				textAlign: "center",
+				cursor: "pointer",
+				borderInlineStart: `${lineWidth}px ${lineType} ${colorBorder}`,
+				transition: `all ${motionDurationMid} linear`,
+				"&:active": { background: token.colorFillAlter },
+				"&:hover": {
+					height: `60%`,
+					[`
+              ${componentCls}-handler-up-inner,
+              ${componentCls}-handler-down-inner
+            `]: { color: colorPrimary }
+				},
+				"&-up-inner, &-down-inner": _extends(_extends({}, resetIcon()), {
+					color: colorTextDescription,
+					transition: `all ${motionDurationMid} linear`,
+					userSelect: "none"
+				})
+			},
+			[`${componentCls}-handler-up`]: { borderStartEndRadius: borderRadius },
+			[`${componentCls}-handler-down`]: {
+				borderBlockStart: `${lineWidth}px ${lineType} ${colorBorder}`,
+				borderEndEndRadius: borderRadius
+			},
+			"&-disabled, &-readonly": {
+				[`${componentCls}-handler-wrap`]: { display: "none" },
+				[`${componentCls}-input`]: { color: "inherit" }
+			},
+			[`
+          ${componentCls}-handler-up-disabled,
+          ${componentCls}-handler-down-disabled
+        `]: { cursor: "not-allowed" },
+			[`
+          ${componentCls}-handler-up-disabled:hover &-handler-up-inner,
+          ${componentCls}-handler-down-disabled:hover &-handler-down-inner
+        `]: { color: colorTextDisabled }
+		} },
+		{ [`${componentCls}-borderless`]: {
+			borderColor: "transparent",
+			boxShadow: "none",
+			[`${componentCls}-handler-down`]: { borderBlockStartWidth: 0 }
+		} }
+	];
+};
+var genAffixWrapperStyles = (token) => {
+	const { componentCls, inputPaddingHorizontal, inputAffixPadding, controlWidth, borderRadiusLG, borderRadiusSM } = token;
+	return { [`${componentCls}-affix-wrapper`]: _extends(_extends(_extends({}, genBasicInputStyle(token)), genStatusStyle(token, `${componentCls}-affix-wrapper`)), {
+		position: "relative",
+		display: "inline-flex",
+		width: controlWidth,
+		padding: 0,
+		paddingInlineStart: inputPaddingHorizontal,
+		"&-lg": { borderRadius: borderRadiusLG },
+		"&-sm": { borderRadius: borderRadiusSM },
+		[`&:not(${componentCls}-affix-wrapper-disabled):hover`]: _extends(_extends({}, genHoverStyle(token)), { zIndex: 1 }),
+		"&-focused, &:focus": { zIndex: 1 },
+		"&-disabled": { [`${componentCls}[disabled]`]: { background: "transparent" } },
+		[`> div${componentCls}`]: {
+			width: "100%",
+			border: "none",
+			outline: "none",
+			[`&${componentCls}-focused`]: { boxShadow: "none !important" }
+		},
+		[`input${componentCls}-input`]: { padding: 0 },
+		"&::before": {
+			width: 0,
+			visibility: "hidden",
+			content: "\"\\a0\""
+		},
+		[`${componentCls}-handler-wrap`]: { zIndex: 2 },
+		[componentCls]: {
+			"&-prefix, &-suffix": {
+				display: "flex",
+				flex: "none",
+				alignItems: "center",
+				pointerEvents: "none"
+			},
+			"&-prefix": { marginInlineEnd: inputAffixPadding },
+			"&-suffix": {
+				position: "absolute",
+				insetBlockStart: 0,
+				insetInlineEnd: 0,
+				zIndex: 1,
+				height: "100%",
+				marginInlineEnd: inputPaddingHorizontal,
+				marginInlineStart: inputAffixPadding
+			}
+		}
+	}) };
+};
+var style_default = genComponentStyleHook("InputNumber", (token) => {
+	const inputNumberToken = initInputToken(token);
+	return [
+		genInputNumberStyles(inputNumberToken),
+		genAffixWrapperStyles(inputNumberToken),
+		genCompactItemStyle(inputNumberToken)
+	];
+}, (token) => ({
+	controlWidth: 90,
+	handleWidth: token.controlHeightSM - token.lineWidth * 2,
+	handleFontSize: token.fontSize / 2,
+	handleVisible: "auto"
+}));
+//#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-number/index.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 baseProps = inputNumberProps$1();
+var inputNumberProps = () => _extends(_extends({}, baseProps), {
+	size: stringType(),
+	bordered: booleanType(true),
+	placeholder: String,
+	name: String,
+	id: String,
+	type: String,
+	addonBefore: PropTypes.any,
+	addonAfter: PropTypes.any,
+	prefix: PropTypes.any,
+	"onUpdate:value": baseProps.onChange,
+	valueModifiers: Object,
+	status: stringType()
+});
+var InputNumber = defineComponent({
+	compatConfig: { MODE: 3 },
+	name: "AInputNumber",
+	inheritAttrs: false,
+	props: inputNumberProps(),
+	slots: Object,
+	setup(props, _ref) {
+		let { emit, expose, attrs, slots } = _ref;
+		var _a;
+		const formItemContext = useInjectFormItemContext();
+		const formItemInputContext = FormItemInputContext.useInject();
+		const mergedStatus = computed(() => getMergedStatus(formItemInputContext.status, props.status));
+		const { prefixCls, size, direction, disabled } = useConfigInject_default("input-number", props);
+		const { compactSize, compactItemClassnames } = useCompactItemContext(prefixCls, direction);
+		const disabledContext = useInjectDisabled();
+		const mergedDisabled = computed(() => {
+			var _a;
+			return (_a = disabled.value) !== null && _a !== void 0 ? _a : disabledContext.value;
+		});
+		const [wrapSSR, hashId] = style_default(prefixCls);
+		const mergedSize = computed(() => compactSize.value || size.value);
+		const mergedValue = shallowRef((_a = props.value) !== null && _a !== void 0 ? _a : props.defaultValue);
+		const focused = shallowRef(false);
+		watch(() => props.value, () => {
+			mergedValue.value = props.value;
+		});
+		const inputNumberRef = shallowRef(null);
+		const focus = () => {
+			var _a;
+			(_a = inputNumberRef.value) === null || _a === void 0 || _a.focus();
+		};
+		const blur = () => {
+			var _a;
+			(_a = inputNumberRef.value) === null || _a === void 0 || _a.blur();
+		};
+		expose({
+			focus,
+			blur
+		});
+		const handleChange = (val) => {
+			if (props.value === void 0) mergedValue.value = val;
+			emit("update:value", val);
+			emit("change", val);
+			formItemContext.onFieldChange();
+		};
+		const handleBlur = (e) => {
+			focused.value = false;
+			emit("blur", e);
+			formItemContext.onFieldBlur();
+		};
+		const handleFocus = (e) => {
+			focused.value = true;
+			emit("focus", e);
+		};
+		return () => {
+			var _a, _b, _c, _d;
+			const { hasFeedback, isFormItemInput, feedbackIcon } = formItemInputContext;
+			const id = (_a = props.id) !== null && _a !== void 0 ? _a : formItemContext.id.value;
+			const _e = _extends(_extends(_extends({}, attrs), props), {
+				id,
+				disabled: mergedDisabled.value
+			}), { class: className, bordered, readonly, style, addonBefore = (_b = slots.addonBefore) === null || _b === void 0 ? void 0 : _b.call(slots), addonAfter = (_c = slots.addonAfter) === null || _c === void 0 ? void 0 : _c.call(slots), prefix = (_d = slots.prefix) === null || _d === void 0 ? void 0 : _d.call(slots), valueModifiers = {} } = _e, others = __rest(_e, [
+				"class",
+				"bordered",
+				"readonly",
+				"style",
+				"addonBefore",
+				"addonAfter",
+				"prefix",
+				"valueModifiers"
+			]);
+			const preCls = prefixCls.value;
+			const inputNumberClass = classNames({
+				[`${preCls}-lg`]: mergedSize.value === "large",
+				[`${preCls}-sm`]: mergedSize.value === "small",
+				[`${preCls}-rtl`]: direction.value === "rtl",
+				[`${preCls}-readonly`]: readonly,
+				[`${preCls}-borderless`]: !bordered,
+				[`${preCls}-in-form-item`]: isFormItemInput
+			}, getStatusClassNames(preCls, mergedStatus.value), className, compactItemClassnames.value, hashId.value);
+			let element = createVNode(InputNumber_default, _objectSpread2(_objectSpread2({}, omit(others, ["size", "defaultValue"])), {}, {
+				"ref": inputNumberRef,
+				"lazy": !!valueModifiers.lazy,
+				"value": mergedValue.value,
+				"class": inputNumberClass,
+				"prefixCls": preCls,
+				"readonly": readonly,
+				"onChange": handleChange,
+				"onBlur": handleBlur,
+				"onFocus": handleFocus
+			}), {
+				upHandler: slots.upIcon ? () => createVNode("span", { "class": `${preCls}-handler-up-inner` }, [slots.upIcon()]) : () => createVNode(UpOutlined, { "class": `${preCls}-handler-up-inner` }, null),
+				downHandler: slots.downIcon ? () => createVNode("span", { "class": `${preCls}-handler-down-inner` }, [slots.downIcon()]) : () => createVNode(DownOutlined, { "class": `${preCls}-handler-down-inner` }, null)
+			});
+			const hasAddon = isValidValue_default(addonBefore) || isValidValue_default(addonAfter);
+			const hasPrefix = isValidValue_default(prefix);
+			if (hasPrefix || hasFeedback) {
+				const affixWrapperCls = classNames(`${preCls}-affix-wrapper`, getStatusClassNames(`${preCls}-affix-wrapper`, mergedStatus.value, hasFeedback), {
+					[`${preCls}-affix-wrapper-focused`]: focused.value,
+					[`${preCls}-affix-wrapper-disabled`]: mergedDisabled.value,
+					[`${preCls}-affix-wrapper-sm`]: mergedSize.value === "small",
+					[`${preCls}-affix-wrapper-lg`]: mergedSize.value === "large",
+					[`${preCls}-affix-wrapper-rtl`]: direction.value === "rtl",
+					[`${preCls}-affix-wrapper-readonly`]: readonly,
+					[`${preCls}-affix-wrapper-borderless`]: !bordered,
+					[`${className}`]: !hasAddon && className
+				}, hashId.value);
+				element = createVNode("div", {
+					"class": affixWrapperCls,
+					"style": style,
+					"onClick": focus
+				}, [
+					hasPrefix && createVNode("span", { "class": `${preCls}-prefix` }, [prefix]),
+					element,
+					hasFeedback && createVNode("span", { "class": `${preCls}-suffix` }, [feedbackIcon])
+				]);
+			}
+			if (hasAddon) {
+				const wrapperClassName = `${preCls}-group`;
+				const addonClassName = `${wrapperClassName}-addon`;
+				const addonBeforeNode = addonBefore ? createVNode("div", { "class": addonClassName }, [addonBefore]) : null;
+				const addonAfterNode = addonAfter ? createVNode("div", { "class": addonClassName }, [addonAfter]) : null;
+				const mergedWrapperClassName = classNames(`${preCls}-wrapper`, wrapperClassName, { [`${wrapperClassName}-rtl`]: direction.value === "rtl" }, hashId.value);
+				const mergedGroupClassName = classNames(`${preCls}-group-wrapper`, {
+					[`${preCls}-group-wrapper-sm`]: mergedSize.value === "small",
+					[`${preCls}-group-wrapper-lg`]: mergedSize.value === "large",
+					[`${preCls}-group-wrapper-rtl`]: direction.value === "rtl"
+				}, getStatusClassNames(`${prefixCls}-group-wrapper`, mergedStatus.value, hasFeedback), className, hashId.value);
+				element = createVNode("div", {
+					"class": mergedGroupClassName,
+					"style": style
+				}, [createVNode("div", { "class": mergedWrapperClassName }, [
+					addonBeforeNode && createVNode(NoCompactStyle, null, { default: () => [createVNode(NoFormStatus, null, { default: () => [addonBeforeNode] })] }),
+					element,
+					addonAfterNode && createVNode(NoCompactStyle, null, { default: () => [createVNode(NoFormStatus, null, { default: () => [addonAfterNode] })] })
+				])]);
+			}
+			return wrapSSR(cloneElement(element, { style }));
+		};
+	}
+});
+var input_number_default = _extends(InputNumber, { install: (app) => {
+	app.component(InputNumber.name, InputNumber);
+	return app;
+} });
+
+export { input_number_default as i };
+//# sourceMappingURL=input-number-BNlNDK7H.mjs.map