base-ui-vue 0.2.0 → 0.4.0

package/dist/decrement/NumberFieldDecrement.js

@@ -0,0 +1,700 @@
+import { mergeProps as mergeProps$1, useButton, useRenderElement } from "../button/Button.js";
+import { REASONS, createChangeEventDetails, createGenericEventDetails } from "../checkbox/index.js";
+import { fieldValidityMapping } from "../checkbox-group/CheckboxGroup.js";
+import { ownerWindow } from "../control/SliderControl.js";
+import { computed, createBlock, createCommentVNode, defineComponent, inject, mergeProps, onUnmounted, openBlock, renderSlot, resolveDynamicComponent, toValue, unref, useAttrs, withCtx } from "vue";
+
+//#region src/utils/useTimeout.ts
+const EMPTY$1 = 0;
+var Timeout = class Timeout {
+	currentId = EMPTY$1;
+	static create() {
+		return new Timeout();
+	}
+	/**
+	* Executes `fn` after `delay`, clearing any previously scheduled call.
+	*/
+	start(delay, fn) {
+		this.clear();
+		this.currentId = setTimeout(() => {
+			this.currentId = EMPTY$1;
+			fn();
+		}, delay);
+	}
+	isStarted() {
+		return this.currentId !== EMPTY$1;
+	}
+	clear = () => {
+		if (this.currentId !== EMPTY$1) {
+			clearTimeout(this.currentId);
+			this.currentId = EMPTY$1;
+		}
+	};
+};
+/**
+* A `setTimeout` with automatic cleanup on unmount.
+*/
+function useTimeout() {
+	const timeout = Timeout.create();
+	onUnmounted(() => {
+		timeout.clear();
+	});
+	return timeout;
+}
+
+//#endregion
+//#region src/utils/formatNumber.ts
+const formatterCache = /* @__PURE__ */ new Map();
+/**
+* Returns a memoized `Intl.NumberFormat` for the given locale/options.
+*/
+function getFormatter(locale, options) {
+	const optionsString = JSON.stringify({
+		locale,
+		options
+	});
+	const cachedFormatter = formatterCache.get(optionsString);
+	if (cachedFormatter) return cachedFormatter;
+	const formatter = new Intl.NumberFormat(locale, options);
+	formatterCache.set(optionsString, formatter);
+	return formatter;
+}
+function formatNumber(value, locale, options) {
+	if (value == null) return "";
+	return getFormatter(locale, options).format(value);
+}
+function formatNumberMaxPrecision(value, locale, options) {
+	return formatNumber(value, locale, {
+		...options,
+		maximumFractionDigits: 20
+	});
+}
+/**
+* Formats a numeric value for display inside Base UI Vue components.
+*
+* When no `format` is provided, the value is interpreted as a percentage
+* in the 0-100 range (matching React's Base UI semantics for
+* `<Meter.Root>` / `<Progress.Root>`).
+*
+* Returns an empty string when the value is `null`.
+*/
+function formatNumberValue(value, locale, format) {
+	if (value == null) return "";
+	if (!format) return formatNumber(value / 100, locale, { style: "percent" });
+	return formatNumber(value, locale, format);
+}
+
+//#endregion
+//#region src/number-field/root/NumberFieldRootContext.ts
+const numberFieldRootContextKey = Symbol("NumberFieldRootContext");
+function useNumberFieldRootContext() {
+	const context = inject(numberFieldRootContextKey, void 0);
+	if (context === void 0) throw new Error("Base UI Vue: NumberFieldRootContext is missing. NumberField parts must be placed within <NumberFieldRoot>.");
+	return context;
+}
+
+//#endregion
+//#region src/utils/useInterval.ts
+const EMPTY = 0;
+var Interval = class Interval {
+	currentId = EMPTY;
+	static create() {
+		return new Interval();
+	}
+	/**
+	* Repeatedly executes `fn` every `delay` ms, clearing any previously scheduled interval.
+	*/
+	start(delay, fn) {
+		this.clear();
+		this.currentId = setInterval(fn, delay);
+	}
+	isStarted() {
+		return this.currentId !== EMPTY;
+	}
+	clear = () => {
+		if (this.currentId !== EMPTY) {
+			clearInterval(this.currentId);
+			this.currentId = EMPTY;
+		}
+	};
+};
+/**
+* A `setInterval` with automatic cleanup on unmount.
+*/
+function useInterval() {
+	const interval = Interval.create();
+	onUnmounted(() => {
+		interval.clear();
+	});
+	return interval;
+}
+
+//#endregion
+//#region src/utils/usePressAndHold.ts
+const DEFAULT_TICK_DELAY = 60;
+const DEFAULT_START_DELAY = 400;
+const DEFAULT_SCROLL_DISTANCE = 8;
+const TOUCH_TIMEOUT = 50;
+const MAX_POINTER_MOVES_AFTER_TOUCH = 3;
+function isTouchLikePointerType$1(pointerType) {
+	return pointerType === "touch" || pointerType === "pen";
+}
+/**
+* Adds press-and-hold behavior to a button element.
+* On pointer down, performs one action immediately, then after a delay starts
+* continuous repeated actions at a fixed interval. Handles mouse, touch, and pen inputs.
+*/
+function usePressAndHold(params) {
+	const { tick, onStop, tickDelay = DEFAULT_TICK_DELAY, startDelay = DEFAULT_START_DELAY, scrollDistance = DEFAULT_SCROLL_DISTANCE, elementRef } = params;
+	const isDisabled = () => toValue(params.disabled);
+	const isReadOnly = () => toValue(params.readOnly ?? false);
+	const startTickTimeout = useTimeout();
+	const tickInterval = useInterval();
+	const intentionalTouchCheckTimeout = useTimeout();
+	let isPressed = false;
+	let movesAfterTouch = 0;
+	let downCoords = {
+		x: 0,
+		y: 0
+	};
+	let isTouchingButton = false;
+	let ignoreClick = false;
+	let pointerType = "";
+	let unsubscribeFromGlobalContextMenu = () => {};
+	function stopAutoChange() {
+		intentionalTouchCheckTimeout.clear();
+		startTickTimeout.clear();
+		tickInterval.clear();
+		unsubscribeFromGlobalContextMenu();
+		unsubscribeFromGlobalContextMenu = () => {};
+		movesAfterTouch = 0;
+	}
+	function startAutoChange(triggerNativeEvent) {
+		stopAutoChange();
+		const element = elementRef.value;
+		if (!element) return;
+		const win = ownerWindow(element);
+		function handleContextMenu(event) {
+			event.preventDefault();
+		}
+		win.addEventListener("contextmenu", handleContextMenu);
+		unsubscribeFromGlobalContextMenu = () => {
+			win.removeEventListener("contextmenu", handleContextMenu);
+		};
+		function handlePointerUp(event) {
+			isPressed = false;
+			stopAutoChange();
+			onStop?.(event);
+		}
+		win.addEventListener("pointerup", handlePointerUp, { once: true });
+		if (!tick(triggerNativeEvent)) {
+			stopAutoChange();
+			return;
+		}
+		startTickTimeout.start(startDelay, () => {
+			tickInterval.start(tickDelay, () => {
+				if (!tick(triggerNativeEvent)) stopAutoChange();
+			});
+		});
+	}
+	onUnmounted(() => stopAutoChange());
+	const pointerHandlers = {
+		onTouchstart() {
+			isTouchingButton = true;
+		},
+		onTouchend() {
+			isTouchingButton = false;
+		},
+		onPointerdown(event) {
+			const isMainButton = !event.button || event.button === 0;
+			if (event.defaultPrevented || !isMainButton || isDisabled() || isReadOnly()) return;
+			pointerType = event.pointerType;
+			ignoreClick = false;
+			isPressed = true;
+			downCoords = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			if (!isTouchLikePointerType$1(event.pointerType)) {
+				event.preventDefault();
+				startAutoChange(event);
+			} else intentionalTouchCheckTimeout.start(TOUCH_TIMEOUT, () => {
+				const moves = movesAfterTouch;
+				movesAfterTouch = 0;
+				if (isPressed && moves < MAX_POINTER_MOVES_AFTER_TOUCH) {
+					startAutoChange(event);
+					ignoreClick = true;
+				} else {
+					ignoreClick = false;
+					stopAutoChange();
+				}
+			});
+		},
+		onPointerup(event) {
+			if (isTouchLikePointerType$1(event.pointerType)) isPressed = false;
+		},
+		onPointermove(event) {
+			if (isDisabled() || isReadOnly() || !isTouchLikePointerType$1(event.pointerType) || !isPressed) return;
+			movesAfterTouch += 1;
+			const { x, y } = downCoords;
+			const dx = x - event.clientX;
+			const dy = y - event.clientY;
+			if (dx ** 2 + dy ** 2 > scrollDistance ** 2) stopAutoChange();
+		},
+		onMouseenter(event) {
+			if (event.defaultPrevented || isDisabled() || isReadOnly() || !isPressed || isTouchingButton || isTouchLikePointerType$1(pointerType)) return;
+			startAutoChange(event);
+		},
+		onMouseleave() {
+			if (isTouchingButton) return;
+			stopAutoChange();
+		},
+		onMouseup() {
+			if (isTouchingButton) return;
+			stopAutoChange();
+		}
+	};
+	function shouldSkipClick(event) {
+		if (event.defaultPrevented) return true;
+		if (isTouchLikePointerType$1(pointerType)) return ignoreClick;
+		return event.detail !== 0;
+	}
+	return {
+		pointerHandlers,
+		shouldSkipClick
+	};
+}
+
+//#endregion
+//#region src/number-field/utils/constants.ts
+const CHANGE_VALUE_TICK_DELAY = 60;
+const START_AUTO_CHANGE_DELAY = 400;
+const SCROLLING_POINTER_MOVE_DISTANCE = 8;
+const DEFAULT_STEP = 1;
+
+//#endregion
+//#region src/number-field/utils/parse.ts
+const HAN_NUMERALS = [
+	"零",
+	"〇",
+	"一",
+	"二",
+	"三",
+	"四",
+	"五",
+	"六",
+	"七",
+	"八",
+	"九"
+];
+const HAN_NUMERAL_TO_DIGIT = {
+	零: "0",
+	〇: "0",
+	一: "1",
+	二: "2",
+	三: "3",
+	四: "4",
+	五: "5",
+	六: "6",
+	七: "7",
+	八: "8",
+	九: "9"
+};
+const ARABIC_NUMERALS = [
+	"٠",
+	"١",
+	"٢",
+	"٣",
+	"٤",
+	"٥",
+	"٦",
+	"٧",
+	"٨",
+	"٩"
+];
+const PERSIAN_NUMERALS = [
+	"۰",
+	"۱",
+	"۲",
+	"۳",
+	"۴",
+	"۵",
+	"۶",
+	"۷",
+	"۸",
+	"۹"
+];
+const FULLWIDTH_NUMERALS = [
+	"０",
+	"１",
+	"２",
+	"３",
+	"４",
+	"５",
+	"６",
+	"７",
+	"８",
+	"９"
+];
+const PERCENTAGES = [
+	"%",
+	"٪",
+	"％",
+	"﹪"
+];
+const PERMILLE = ["‰", "؉"];
+const UNICODE_MINUS_SIGNS = [
+	"−",
+	"－",
+	"‒",
+	"–",
+	"—",
+	"﹣"
+];
+const UNICODE_PLUS_SIGNS = ["＋", "﹢"];
+const FULLWIDTH_DECIMAL = "．";
+const FULLWIDTH_GROUP = "，";
+const ARABIC_RE = new RegExp(`[${ARABIC_NUMERALS.join("")}]`, "g");
+const PERSIAN_RE = new RegExp(`[${PERSIAN_NUMERALS.join("")}]`, "g");
+const FULLWIDTH_RE = new RegExp(`[${FULLWIDTH_NUMERALS.join("")}]`, "g");
+const HAN_RE = new RegExp(`[${HAN_NUMERALS.join("")}]`, "g");
+const PERCENT_RE = new RegExp(`[${PERCENTAGES.join("")}]`);
+const PERMILLE_RE = new RegExp(`[${PERMILLE.join("")}]`);
+const PERCENT_GLOBAL_RE = new RegExp(PERCENT_RE.source, "g");
+const PERMILLE_GLOBAL_RE = new RegExp(PERMILLE_RE.source, "g");
+const ARABIC_DETECT_RE = /[٠١٢٣٤٥٦٧٨٩]/;
+const PERSIAN_DETECT_RE = /[۰۱۲۳۴۵۶۷۸۹]/;
+const HAN_DETECT_RE = /[零〇一二三四五六七八九]/;
+const FULLWIDTH_DETECT_RE = new RegExp(`[${FULLWIDTH_NUMERALS.join("")}]`);
+const BASE_NON_NUMERIC_SYMBOLS = [
+	".",
+	",",
+	FULLWIDTH_DECIMAL,
+	FULLWIDTH_GROUP,
+	"٫",
+	"٬"
+];
+const SPACE_SEPARATOR_RE = /\p{Zs}/u;
+const PLUS_SIGNS_WITH_ASCII = ["+", ...UNICODE_PLUS_SIGNS];
+const MINUS_SIGNS_WITH_ASCII = ["-", ...UNICODE_MINUS_SIGNS];
+function escapeRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeClassChar(s) {
+	return s.replace(/[-\\\]^]/g, (m) => `\\${m}`);
+}
+function shiftDecimal(value, exponentDelta) {
+	const [coefficient, exponent = "0"] = String(value).split("e");
+	return Number(`${coefficient}e${Number(exponent) + exponentDelta}`);
+}
+function charClassFrom(chars) {
+	return `[${chars.map(escapeClassChar).join("")}]`;
+}
+const ANY_MINUS_CLASS = charClassFrom(["-"].concat(UNICODE_MINUS_SIGNS));
+const ANY_PLUS_CLASS = charClassFrom(["+"].concat(UNICODE_PLUS_SIGNS));
+const ANY_MINUS_RE = new RegExp(ANY_MINUS_CLASS, "gu");
+const ANY_PLUS_RE = new RegExp(ANY_PLUS_CLASS, "gu");
+const ANY_MINUS_DETECT_RE = new RegExp(ANY_MINUS_CLASS);
+const ANY_PLUS_DETECT_RE = new RegExp(ANY_PLUS_CLASS);
+function getNumberLocaleDetails(locale, options) {
+	const parts = getFormatter(locale, options).formatToParts(11111.1);
+	const result = {};
+	parts.forEach((part) => {
+		result[part.type] = part.value;
+	});
+	getFormatter(locale).formatToParts(.1).forEach((part) => {
+		if (part.type === "decimal") result[part.type] = part.value;
+	});
+	return result;
+}
+function parseNumber(formattedNumber, locale, options) {
+	if (formattedNumber == null) return null;
+	let input = String(formattedNumber).replace(/\p{Cf}/gu, "").trim();
+	input = input.replace(ANY_MINUS_RE, "-").replace(ANY_PLUS_RE, "+");
+	let isNegative = false;
+	const trailing = input.match(/([+-])\s*$/);
+	if (trailing) {
+		if (trailing[1] === "-") isNegative = true;
+		input = input.replace(/([+-])\s*$/, "");
+	}
+	const leading = input.match(/^\s*([+-])/);
+	if (leading) {
+		if (leading[1] === "-") isNegative = true;
+		input = input.replace(/^\s*[+-]/, "");
+	}
+	let computedLocale = locale;
+	if (computedLocale === void 0) {
+		if (ARABIC_DETECT_RE.test(input) || PERSIAN_DETECT_RE.test(input)) computedLocale = "ar";
+		else if (HAN_DETECT_RE.test(input)) computedLocale = "zh";
+	}
+	const { group, decimal, currency, exponentSeparator } = getNumberLocaleDetails(computedLocale, options);
+	const unitParts = getFormatter(computedLocale, options).formatToParts(1).filter((p) => p.type === "unit").map((p) => escapeRegExp(p.value));
+	const unitRegex = unitParts.length ? new RegExp(unitParts.join("|"), "g") : null;
+	let groupRegex = null;
+	if (group) {
+		const isSpaceGroup = /\p{Zs}/u.test(group);
+		const isApostropheGroup = group === "'" || group === "’";
+		if (isSpaceGroup) groupRegex = /\p{Zs}/gu;
+		else if (isApostropheGroup) groupRegex = /['’]/g;
+		else groupRegex = new RegExp(escapeRegExp(group), "g");
+	}
+	let unformatted = [
+		{
+			regex: group ? groupRegex : null,
+			replacement: ""
+		},
+		{
+			regex: decimal ? new RegExp(escapeRegExp(decimal), "g") : null,
+			replacement: "."
+		},
+		{
+			regex: /．/g,
+			replacement: "."
+		},
+		{
+			regex: /，/g,
+			replacement: ""
+		},
+		{
+			regex: /٫/g,
+			replacement: "."
+		},
+		{
+			regex: /٬/g,
+			replacement: ""
+		},
+		{
+			regex: currency ? new RegExp(escapeRegExp(currency), "g") : null,
+			replacement: ""
+		},
+		{
+			regex: unitRegex,
+			replacement: ""
+		},
+		{
+			regex: PERCENT_GLOBAL_RE,
+			replacement: ""
+		},
+		{
+			regex: PERMILLE_GLOBAL_RE,
+			replacement: ""
+		},
+		{
+			regex: exponentSeparator ? new RegExp(escapeRegExp(exponentSeparator), "g") : null,
+			replacement: "e"
+		},
+		{
+			regex: ARABIC_RE,
+			replacement: (ch) => String(ARABIC_NUMERALS.indexOf(ch))
+		},
+		{
+			regex: PERSIAN_RE,
+			replacement: (ch) => String(PERSIAN_NUMERALS.indexOf(ch))
+		},
+		{
+			regex: FULLWIDTH_RE,
+			replacement: (ch) => String(FULLWIDTH_NUMERALS.indexOf(ch))
+		},
+		{
+			regex: HAN_RE,
+			replacement: (ch) => HAN_NUMERAL_TO_DIGIT[ch]
+		}
+	].reduce((acc, { regex, replacement }) => {
+		return regex ? acc.replace(regex, replacement) : acc;
+	}, input);
+	const lastDot = unformatted.lastIndexOf(".");
+	if (lastDot !== -1) unformatted = `${unformatted.slice(0, lastDot).replace(/\./g, "")}.${unformatted.slice(lastDot + 1).replace(/\./g, "")}`;
+	if (/^[+-]?Infinity$/i.test(input) || /∞/.test(input)) return null;
+	const parseTarget = (isNegative ? "-" : "") + unformatted;
+	let num = Number.parseFloat(parseTarget);
+	const style = options?.style;
+	const isUnitPercent = style === "unit" && options?.unit === "percent";
+	const hasPercentSymbol = PERCENT_RE.test(formattedNumber) || style === "percent";
+	if (PERMILLE_RE.test(formattedNumber)) num = shiftDecimal(num, -3);
+	else if (!isUnitPercent && hasPercentSymbol) num = shiftDecimal(num, -2);
+	if (!Number.isFinite(num)) return null;
+	return num;
+}
+
+//#endregion
+//#region src/number-field/root/useNumberFieldButton.ts
+function isTouchLikePointerType(pointerType) {
+	return pointerType === "touch" || pointerType === "pen";
+}
+function useNumberFieldButton(params) {
+	const { allowInputSyncRef, formatOptionsRef, getStepAmount, incrementValue, inputRef, inputValue, isIncrement, locale, setValue, valueRef, lastChangedValueRef, onValueCommitted } = params;
+	const disabled = () => params.disabled();
+	const readOnly = () => params.readOnly();
+	const pressReason = isIncrement ? REASONS.incrementPress : REASONS.decrementPress;
+	function commitValue(nativeEvent) {
+		allowInputSyncRef.value = true;
+		const parsedValue = parseNumber(inputValue(), locale(), formatOptionsRef.value);
+		if (parsedValue !== null) {
+			valueRef.value = parsedValue;
+			setValue(parsedValue, createChangeEventDetails(pressReason, nativeEvent, void 0, { direction: isIncrement ? 1 : -1 }));
+		}
+	}
+	const { pointerHandlers, shouldSkipClick } = usePressAndHold({
+		disabled: () => disabled() || readOnly(),
+		elementRef: inputRef,
+		tickDelay: CHANGE_VALUE_TICK_DELAY,
+		startDelay: START_AUTO_CHANGE_DELAY,
+		scrollDistance: SCROLLING_POINTER_MOVE_DISTANCE,
+		tick(triggerEvent) {
+			return incrementValue(getStepAmount(triggerEvent) ?? DEFAULT_STEP, {
+				direction: isIncrement ? 1 : -1,
+				event: triggerEvent,
+				reason: pressReason
+			});
+		},
+		onStop(nativeEvent) {
+			onValueCommitted(lastChangedValueRef.value ?? valueRef.value, createGenericEventDetails(pressReason, nativeEvent));
+		}
+	});
+	return computed(() => ({
+		"disabled": disabled(),
+		"aria-readonly": readOnly() || void 0,
+		"aria-label": isIncrement ? "Increase" : "Decrease",
+		"aria-controls": params.id(),
+		"tabindex": -1,
+		"style": {
+			WebkitUserSelect: "none",
+			userSelect: "none"
+		},
+		...pointerHandlers,
+		onClick(event) {
+			const isDisabled = disabled() || readOnly();
+			if (event.defaultPrevented || isDisabled || shouldSkipClick(event)) return;
+			commitValue(event);
+			const amount = getStepAmount(event) ?? DEFAULT_STEP;
+			const prev = valueRef.value;
+			incrementValue(amount, {
+				direction: isIncrement ? 1 : -1,
+				event,
+				reason: pressReason
+			});
+			const committed = lastChangedValueRef.value ?? valueRef.value;
+			if (committed !== prev) onValueCommitted(committed, createGenericEventDetails(pressReason, event));
+		},
+		onPointerdown(event) {
+			const isMainButton = !event.button || event.button === 0;
+			if (event.defaultPrevented || readOnly() || !isMainButton || disabled()) return;
+			commitValue(event);
+			if (!isTouchLikePointerType(event.pointerType)) inputRef.value?.focus();
+			pointerHandlers.onPointerdown(event);
+		}
+	}));
+}
+
+//#endregion
+//#region src/number-field/utils/stateAttributesMapping.ts
+const stateAttributesMapping = {
+	inputValue: () => null,
+	value: () => null,
+	...fieldValidityMapping
+};
+
+//#endregion
+//#region src/number-field/decrement/NumberFieldDecrement.vue?vue&type=script&setup=true&lang.ts
+var NumberFieldDecrement_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "NumberFieldDecrement",
+	inheritAttrs: false,
+	__name: "NumberFieldDecrement",
+	props: {
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		nativeButton: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "button"
+		},
+		class: {
+			type: Function,
+			required: false,
+			skipCheck: true
+		},
+		style: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array,
+				Function
+			],
+			required: false,
+			skipCheck: true
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const attrsObject = useAttrs();
+		const { allowInputSyncRef, disabled: contextDisabled, formatOptionsRef, getStepAmount, id, incrementValue, inputRef, inputValue, minWithDefault, readOnly, setValue, state, value, valueRef, locale, lastChangedValueRef, onValueCommitted } = useNumberFieldRootContext();
+		const isMin = computed(() => value.value != null && value.value <= minWithDefault.value);
+		const disabled = computed(() => props.disabled || contextDisabled.value || isMin.value);
+		const buttonProps = useNumberFieldButton({
+			isIncrement: false,
+			inputRef,
+			inputValue: () => inputValue.value,
+			disabled: () => disabled.value,
+			readOnly: () => readOnly.value,
+			id: () => id.value,
+			setValue,
+			getStepAmount,
+			incrementValue,
+			allowInputSyncRef,
+			formatOptionsRef,
+			valueRef,
+			locale: () => locale.value,
+			lastChangedValueRef,
+			onValueCommitted
+		});
+		const { getButtonProps, buttonRef } = useButton({
+			disabled: () => disabled.value,
+			native: () => props.nativeButton,
+			focusableWhenDisabled: true
+		});
+		const buttonState = computed(() => ({
+			...state.value,
+			disabled: disabled.value
+		}));
+		const { tag, mergedProps, renderless, ref: renderRef } = useRenderElement({
+			componentProps: props,
+			state: buttonState,
+			props: computed(() => mergeProps$1(buttonProps.value, attrsObject, getButtonProps())),
+			stateAttributesMapping,
+			defaultTagName: "button",
+			ref: buttonRef
+		});
+		return (_ctx, _cache) => {
+			return unref(renderless) ? renderSlot(_ctx.$slots, "default", {
+				key: 0,
+				ref: unref(renderRef),
+				props: unref(mergedProps),
+				state: buttonState.value
+			}) : (openBlock(), createBlock(resolveDynamicComponent(unref(tag)), mergeProps({
+				key: 1,
+				ref: unref(renderRef)
+			}, unref(mergedProps)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", { state: buttonState.value })]),
+				_: 3
+			}, 16));
+		};
+	}
+});
+
+//#endregion
+//#region src/number-field/decrement/NumberFieldDecrement.vue
+var NumberFieldDecrement_default = NumberFieldDecrement_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+export { ANY_MINUS_DETECT_RE, ANY_MINUS_RE, ANY_PLUS_DETECT_RE, ANY_PLUS_RE, ARABIC_DETECT_RE, BASE_NON_NUMERIC_SYMBOLS, DEFAULT_STEP, FULLWIDTH_DETECT_RE, HAN_DETECT_RE, MINUS_SIGNS_WITH_ASCII, NumberFieldDecrement_default, PERCENTAGES, PERMILLE, PERSIAN_DETECT_RE, PLUS_SIGNS_WITH_ASCII, SPACE_SEPARATOR_RE, formatNumber, formatNumberMaxPrecision, formatNumberValue, getFormatter, getNumberLocaleDetails, numberFieldRootContextKey, parseNumber, stateAttributesMapping, useNumberFieldButton, useNumberFieldRootContext, useTimeout };
+//# sourceMappingURL=NumberFieldDecrement.js.map