@v-c/input-number 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 antdv-community
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/InputNumber.cjs

@@ -0,0 +1,693 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("./_virtual/rolldown_runtime.cjs");
+const require_useCursor = require("./hooks/useCursor.cjs");
+const require_useFrame = require("./hooks/useFrame.cjs");
+const require_StepHandler = require("./StepHandler.cjs");
+const require_numberUtil = require("./utils/numberUtil.cjs");
+let vue = require("vue");
+let __v_c_mini_decimal = require("@v-c/mini-decimal");
+__v_c_mini_decimal = require_rolldown_runtime.__toESM(__v_c_mini_decimal);
+let __v_c_util = require("@v-c/util");
+let __v_c_util_dist_Dom_focus = require("@v-c/util/dist/Dom/focus");
+let __v_c_util_dist_omit = require("@v-c/util/dist/omit");
+__v_c_util_dist_omit = require_rolldown_runtime.__toESM(__v_c_util_dist_omit);
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !(0, vue.isVNode)(s);
+}
+var defaults = {
+	prefixCls: "vc-input-number",
+	step: 1,
+	controls: true,
+	changeOnWheel: false,
+	mode: "input",
+	stringMode: false
+};
+function getDecimalValue(stringMode, decimalValue) {
+	if (stringMode || decimalValue.isEmpty()) return decimalValue.toString();
+	return decimalValue.toNumber();
+}
+function getDecimalIfValidate(value) {
+	const decimal = (0, __v_c_mini_decimal.default)(value);
+	return decimal.isInvalidate() ? null : decimal;
+}
+var InputNumber = /* @__PURE__ */ (0, vue.defineComponent)((props, { attrs, slots, expose, emit }) => {
+	const focus = (0, vue.shallowRef)(false);
+	const userTypingRef = (0, vue.shallowRef)(false);
+	const compositionRef = (0, vue.shallowRef)(false);
+	const shiftKeyRef = (0, vue.shallowRef)(false);
+	const rootRef = (0, vue.shallowRef)();
+	const inputRef = (0, vue.shallowRef)();
+	expose({
+		focus: (option) => {
+			if (inputRef.value) (0, __v_c_util_dist_Dom_focus.triggerFocus)(inputRef.value, option);
+		},
+		blur: () => {
+			inputRef.value?.blur?.();
+		},
+		nativeElement: (0, vue.computed)(() => rootRef.value || inputRef.value || null),
+		input: inputRef
+	});
+	const decimalValue = (0, vue.shallowRef)((0, __v_c_mini_decimal.default)(props.value ?? props.defaultValue ?? ""));
+	const setUncontrolledDecimalValue = (newDecimal) => {
+		if (props.value === void 0) decimalValue.value = newDecimal;
+	};
+	const getPrecision = (numStr, userTyping) => {
+		if (userTyping) return;
+		if (props.precision !== void 0 && props.precision >= 0) return props.precision;
+		return Math.max((0, __v_c_mini_decimal.getNumberPrecision)(numStr), (0, __v_c_mini_decimal.getNumberPrecision)(props.step ?? 1));
+	};
+	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 = (0, vue.shallowRef)("");
+	const inputValueRef = (0, vue.shallowRef)("");
+	const mergedFormatter = (number, userTyping) => {
+		if (props.formatter) return props.formatter(number, {
+			userTyping,
+			input: String(inputValueRef.value)
+		});
+		let str = typeof number === "number" ? (0, __v_c_mini_decimal.num2str)(number) : number;
+		if (!userTyping) {
+			const mergedPrecision = getPrecision(str, userTyping);
+			if ((0, __v_c_mini_decimal.validateNumber)(str) && (props.decimalSeparator || mergedPrecision !== void 0 && mergedPrecision >= 0)) {
+				const separatorStr = props.decimalSeparator || ".";
+				str = (0, __v_c_mini_decimal.toFixed)(str, separatorStr, mergedPrecision);
+			}
+		}
+		return str;
+	};
+	const syncInputValue = () => {
+		const initValue = props.defaultValue ?? props.value;
+		if (decimalValue.value.isInvalidate() && ["string", "number"].includes(typeof initValue)) inputValue.value = Number.isNaN(initValue) ? "" : initValue;
+		else inputValue.value = mergedFormatter(decimalValue.value.toString(), false);
+		inputValueRef.value = inputValue.value;
+	};
+	syncInputValue();
+	(0, vue.watch)(inputValue, (val) => {
+		inputValueRef.value = val;
+	});
+	const setInputValue = (newValue, userTyping) => {
+		inputValue.value = mergedFormatter(newValue.isInvalidate() ? newValue.toString(false) : newValue.toString(!userTyping), userTyping);
+	};
+	const maxDecimal = (0, vue.computed)(() => props.max !== void 0 ? getDecimalIfValidate(props.max) : null);
+	const minDecimal = (0, vue.computed)(() => props.min !== void 0 ? getDecimalIfValidate(props.min) : null);
+	const upDisabled = (0, vue.computed)(() => {
+		if (!maxDecimal.value || !decimalValue.value || decimalValue.value.isInvalidate()) return false;
+		return maxDecimal.value.lessEquals(decimalValue.value);
+	});
+	const downDisabled = (0, vue.computed)(() => {
+		if (!minDecimal.value || !decimalValue.value || decimalValue.value.isInvalidate()) return false;
+		return decimalValue.value.lessEquals(minDecimal.value);
+	});
+	const recordCursorRef = (0, vue.shallowRef)(() => {});
+	const restoreCursorRef = (0, vue.shallowRef)(() => {});
+	(0, vue.watchEffect)(() => {
+		if (inputRef.value) {
+			const [record, restore] = require_useCursor.default(inputRef.value, focus.value);
+			recordCursorRef.value = record;
+			restoreCursorRef.value = restore;
+		}
+	});
+	const recordCursor = () => recordCursorRef.value?.();
+	const restoreCursor = () => restoreCursorRef.value?.();
+	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;
+	};
+	const isInRange = (target) => !getRangeValue(target);
+	const triggerValueUpdate = (newValue, userTyping) => {
+		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 !== void 0 && mergedPrecision >= 0) {
+				updateValue = (0, __v_c_mini_decimal.default)((0, __v_c_mini_decimal.toFixed)(numStr, ".", mergedPrecision));
+				if (!isInRange(updateValue)) updateValue = (0, __v_c_mini_decimal.default)((0, __v_c_mini_decimal.toFixed)(numStr, ".", mergedPrecision, true));
+			}
+			if (!updateValue.equals(decimalValue.value)) {
+				setUncontrolledDecimalValue(updateValue);
+				const outValue = updateValue.isEmpty() ? null : getDecimalValue(props.stringMode, updateValue);
+				props.onChange?.(outValue);
+				emit("change", outValue);
+				if (props.value === void 0) setInputValue(updateValue, userTyping);
+				emit("update:value", outValue);
+			}
+			return updateValue;
+		}
+		return decimalValue.value;
+	};
+	const onNextPromise = require_useFrame.default();
+	const collectInputValue = (inputStr) => {
+		recordCursor();
+		inputValueRef.value = inputStr;
+		inputValue.value = inputStr;
+		if (!compositionRef.value) {
+			const finalDecimal = (0, __v_c_mini_decimal.default)(mergedParser(inputStr));
+			if (!finalDecimal.isNaN()) triggerValueUpdate(finalDecimal, true);
+		}
+		props.onInput?.(inputStr);
+		emit("input", inputStr);
+		onNextPromise(() => {
+			let nextInputStr = inputStr;
+			if (!props.parser) nextInputStr = inputStr.replace(/。/g, ".");
+			if (nextInputStr !== inputStr) collectInputValue(nextInputStr);
+		});
+	};
+	const onCompositionStart = (e) => {
+		compositionRef.value = true;
+		emit("compositionstart", e);
+		props.onCompositionStart?.(e);
+	};
+	const onCompositionEnd = (e) => {
+		compositionRef.value = false;
+		emit("compositionend", e);
+		props.onCompositionEnd?.(e);
+		if (inputRef.value) collectInputValue(inputRef.value.value);
+	};
+	const onInternalInput = (e) => {
+		collectInputValue(e.target.value);
+	};
+	const onInternalStep = (up, emitter) => {
+		if (up && upDisabled.value || !up && downDisabled.value) return;
+		userTypingRef.value = false;
+		let stepDecimal = (0, __v_c_mini_decimal.default)(shiftKeyRef.value ? require_numberUtil.getDecupleSteps(props.step ?? 1) : props.step ?? 1);
+		if (!up) stepDecimal = stepDecimal.negate();
+		const updatedValue = triggerValueUpdate((decimalValue.value || (0, __v_c_mini_decimal.default)(0)).add(stepDecimal.toString()), false);
+		const outValue = getDecimalValue(props.stringMode, updatedValue);
+		props.onStep?.(outValue, {
+			offset: shiftKeyRef.value ? require_numberUtil.getDecupleSteps(props.step ?? 1) : props.step ?? 1,
+			type: up ? "up" : "down",
+			emitter
+		});
+		emit("step", outValue, {
+			offset: shiftKeyRef.value ? require_numberUtil.getDecupleSteps(props.step ?? 1) : props.step ?? 1,
+			type: up ? "up" : "down",
+			emitter
+		});
+		inputRef.value?.focus();
+	};
+	const flushInputValue = (userTyping) => {
+		const parsedValue = (0, __v_c_mini_decimal.default)(mergedParser(inputValue.value));
+		let formatValue;
+		if (!parsedValue.isNaN()) formatValue = triggerValueUpdate(parsedValue, userTyping);
+		else formatValue = triggerValueUpdate(decimalValue.value, userTyping);
+		if (props.value !== void 0) setInputValue(decimalValue.value, false);
+		else if (!formatValue.isNaN()) setInputValue(formatValue, false);
+	};
+	const onBeforeInput = (e) => {
+		userTypingRef.value = true;
+		emit("beforeinput", e);
+		props.onBeforeInput?.(e);
+	};
+	const onKeyDown = (event) => {
+		const { key, shiftKey } = event;
+		userTypingRef.value = true;
+		shiftKeyRef.value = shiftKey;
+		if (key === "Enter") {
+			if (!compositionRef.value) userTypingRef.value = false;
+			flushInputValue(false);
+			emit("pressEnter", event);
+			props.onPressEnter?.(event);
+		}
+		if (props.keyboard === false) {
+			props.onKeyDown?.(event);
+			emit("keydown", event);
+			return;
+		}
+		if (!compositionRef.value && [
+			"Up",
+			"ArrowUp",
+			"Down",
+			"ArrowDown"
+		].includes(key)) {
+			onInternalStep(key === "Up" || key === "ArrowUp", "keyboard");
+			event.preventDefault();
+		}
+		props.onKeyDown?.(event);
+		emit("keydown", event);
+	};
+	const onKeyUp = (event) => {
+		userTypingRef.value = false;
+		shiftKeyRef.value = false;
+		emit("keyup", event);
+		props.onKeyUp?.(event);
+	};
+	(0, vue.watchEffect)((onCleanup) => {
+		if (props.changeOnWheel && focus.value && inputRef.value) {
+			const onWheel = (event) => {
+				onInternalStep(event.deltaY < 0, "wheel");
+				event.preventDefault();
+			};
+			inputRef.value.addEventListener("wheel", onWheel, { passive: false });
+			onCleanup(() => inputRef.value?.removeEventListener("wheel", onWheel));
+		}
+	});
+	const onBlur = (e) => {
+		if (props.changeOnBlur ?? true) flushInputValue(false);
+		focus.value = false;
+		userTypingRef.value = false;
+		emit("blur", e);
+		props.onBlur?.(e);
+	};
+	const onFocus = (e) => {
+		focus.value = true;
+		emit("focus", e);
+		props.onFocus?.(e);
+	};
+	const onInternalMouseDown = (event) => {
+		if (inputRef.value && event.target !== inputRef.value) {
+			inputRef.value.focus();
+			event.preventDefault();
+		}
+		emit("mousedown", event);
+		props.onMouseDown?.(event);
+	};
+	(0, vue.watch)([
+		() => props.precision,
+		() => props.formatter,
+		() => props.decimalSeparator
+	], () => {
+		if (!decimalValue.value.isInvalidate()) setInputValue(decimalValue.value, false);
+	});
+	(0, vue.watch)(() => props.value, (newVal) => {
+		const newValue = (0, __v_c_mini_decimal.default)(newVal ?? "");
+		decimalValue.value = newValue;
+		const currentParsedValue = (0, __v_c_mini_decimal.default)(mergedParser(inputValue.value));
+		if (!newValue.equals(currentParsedValue) || !userTypingRef.value || props.formatter) setInputValue(newValue, userTypingRef.value);
+	});
+	(0, vue.watch)(() => inputValue.value, () => {
+		if (props.formatter) restoreCursor();
+	});
+	return () => {
+		const { prefixCls = defaults.prefixCls, classNames, styles, step = defaults.step, disabled, readOnly, controls = defaults.controls, mode = defaults.mode } = props;
+		const mergedPrefixCls = prefixCls || defaults.prefixCls;
+		const { class: className, style,...restAttrs } = attrs;
+		const mergedClassName = props.className || className;
+		const mergedStyle = {
+			...styles?.root,
+			...props.style,
+			...style
+		};
+		const prefixNode = slots.prefix?.() ?? props.prefix;
+		const suffixNode = slots.suffix?.() ?? props.suffix;
+		const upNode = slots.upHandler?.() ?? props.upHandler;
+		const downNode = slots.downHandler?.() ?? props.downHandler;
+		const upHandlerNode = (0, vue.createVNode)(require_StepHandler.default, {
+			"prefixCls": mergedPrefixCls,
+			"action": "up",
+			"disabled": upDisabled.value,
+			"onStep": onInternalStep,
+			"className": classNames?.action,
+			"style": styles?.action
+		}, _isSlot(upNode) ? upNode : { default: () => [upNode] });
+		const downHandlerNode = (0, vue.createVNode)(require_StepHandler.default, {
+			"prefixCls": mergedPrefixCls,
+			"action": "down",
+			"disabled": downDisabled.value,
+			"onStep": onInternalStep,
+			"className": classNames?.action,
+			"style": styles?.action
+		}, _isSlot(downNode) ? downNode : { default: () => [downNode] });
+		const inputAttrs = (0, __v_c_util_dist_omit.default)({ ...restAttrs }, [
+			"prefixCls",
+			"classNames",
+			"styles",
+			"defaultValue",
+			"value",
+			"prefix",
+			"suffix",
+			"upHandler",
+			"downHandler",
+			"keyboard",
+			"changeOnWheel",
+			"controls",
+			"mode",
+			"parser",
+			"formatter",
+			"precision",
+			"decimalSeparator",
+			"onChange",
+			"onInput",
+			"onPressEnter",
+			"onStep",
+			"changeOnBlur",
+			"class",
+			"style",
+			"onMouseDown",
+			"onClick",
+			"onMouseUp",
+			"onMouseLeave",
+			"onMouseMove",
+			"onMouseEnter",
+			"onMouseOut",
+			"onFocus",
+			"onBlur",
+			"onKeyDown",
+			"onKeyUp",
+			"onCompositionStart",
+			"onCompositionEnd",
+			"onBeforeInput"
+		]);
+		return (0, vue.createVNode)("div", {
+			"ref": rootRef,
+			"class": (0, __v_c_util.clsx)(mergedPrefixCls, `${mergedPrefixCls}-mode-${mode}`, mergedClassName, classNames?.root, {
+				[`${mergedPrefixCls}-focused`]: focus.value,
+				[`${mergedPrefixCls}-disabled`]: disabled,
+				[`${mergedPrefixCls}-readonly`]: readOnly,
+				[`${mergedPrefixCls}-not-a-number`]: decimalValue.value.isNaN(),
+				[`${mergedPrefixCls}-out-of-range`]: !decimalValue.value.isInvalidate() && !isInRange(decimalValue.value)
+			}),
+			"style": mergedStyle,
+			"onMousedown": onInternalMouseDown,
+			"onMouseup": (e) => {
+				emit("mouseup", e);
+				props.onMouseUp?.(e);
+			},
+			"onMouseleave": (e) => {
+				emit("mouseleave", e);
+				props.onMouseLeave?.(e);
+			},
+			"onMousemove": (e) => {
+				emit("mousemove", e);
+				props.onMouseMove?.(e);
+			},
+			"onMouseenter": (e) => {
+				emit("mouseenter", e);
+				props.onMouseEnter?.(e);
+			},
+			"onMouseout": (e) => {
+				emit("mouseout", e);
+				props.onMouseOut?.(e);
+			},
+			"onClick": (e) => {
+				emit("click", e);
+				props.onClick?.(e);
+			}
+		}, [
+			mode === "spinner" && controls && downHandlerNode,
+			prefixNode !== void 0 && (0, vue.createVNode)("div", {
+				"class": (0, __v_c_util.clsx)(`${mergedPrefixCls}-prefix`, classNames?.prefix),
+				"style": styles?.prefix
+			}, [prefixNode]),
+			(0, vue.createVNode)("input", (0, vue.mergeProps)({
+				"autocomplete": "off",
+				"role": "spinbutton",
+				"aria-valuemin": props.min,
+				"aria-valuemax": props.max,
+				"aria-valuenow": decimalValue.value.isInvalidate() ? null : decimalValue.value.toString(),
+				"step": step,
+				"ref": inputRef,
+				"class": (0, __v_c_util.clsx)(`${mergedPrefixCls}-input`, classNames?.input),
+				"style": styles?.input,
+				"value": inputValue.value,
+				"onChange": onInternalInput,
+				"disabled": disabled,
+				"readonly": readOnly,
+				"onFocus": onFocus,
+				"onBlur": onBlur,
+				"onKeydown": onKeyDown,
+				"onKeyup": onKeyUp,
+				"onCompositionstart": onCompositionStart,
+				"onCompositionend": onCompositionEnd,
+				"onBeforeinput": onBeforeInput
+			}, inputAttrs), null),
+			suffixNode !== void 0 && (0, vue.createVNode)("div", {
+				"class": (0, __v_c_util.clsx)(`${mergedPrefixCls}-suffix`, classNames?.suffix),
+				"style": styles?.suffix
+			}, [suffixNode]),
+			mode === "spinner" && controls && upHandlerNode,
+			mode === "input" && controls && (0, vue.createVNode)("div", {
+				"class": (0, __v_c_util.clsx)(`${mergedPrefixCls}-actions`, classNames?.actions),
+				"style": styles?.actions
+			}, [upHandlerNode, downHandlerNode])
+		]);
+	};
+}, {
+	props: /* @__PURE__ */ (0, vue.mergeDefaults)({
+		mode: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		prefixCls: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		class: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		className: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		style: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		classNames: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		styles: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		min: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		max: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		step: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		defaultValue: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		value: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		readOnly: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		prefix: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		suffix: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		upHandler: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		downHandler: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		keyboard: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		changeOnWheel: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		controls: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		parser: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		formatter: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		precision: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		decimalSeparator: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		onInput: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onChange: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onPressEnter: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onStep: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		changeOnBlur: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		tabIndex: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		onMouseDown: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onClick: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onMouseUp: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onMouseLeave: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onMouseMove: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onMouseEnter: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onMouseOut: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onFocus: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onBlur: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onKeyDown: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onKeyUp: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onCompositionStart: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onCompositionEnd: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onBeforeInput: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		stringMode: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		}
+	}, defaults),
+	name: "InputNumber",
+	inheritAttrs: false,
+	emits: [
+		"change",
+		"update:value",
+		"input",
+		"pressEnter",
+		"step",
+		"mousedown",
+		"click",
+		"mouseup",
+		"mouseleave",
+		"mousemove",
+		"mouseenter",
+		"mouseout",
+		"focus",
+		"blur",
+		"keydown",
+		"keyup",
+		"compositionstart",
+		"compositionend",
+		"beforeinput"
+	]
+});
+var InputNumber_default = InputNumber;
+exports.default = InputNumber_default;