@manafishrov/ui 1.4.4 → 1.4.6

package/dist/node_modules/.bun/@zag-js_number-input@1.35.3/node_modules/@zag-js/number-input/dist/number-input.machine.js

@@ -1,409 +1,467 @@
-import { recordCursor as C, restoreCursor as N } from "./cursor.js";
-import { getCursorEl as P, getInputEl as o, getPressedTriggerEl as b, preventTextSelection as I, setupVirtualCursor as A, getMousemoveValue as h } from "./number-input.dom.js";
-import { formatValue as i, parseValue as m, createParser as T, createFormatter as p, getDefaultStep as S } from "./number-input.utils.js";
-import { clampValue as l, decrementValue as U, incrementValue as D, isValueWithinRange as H, isValueAtMax as x, isValueAtMin as M } from "../../../../../@zag-js_utils@1.35.3/node_modules/@zag-js/utils/dist/number.js";
-import { requestPointerLock as k } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/pointer-lock.js";
-import { raf as v } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/raf.js";
-import { setElementValue as B, trackFormControl as w } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/form.js";
-import { callAll as y } from "../../../../../@zag-js_utils@1.35.3/node_modules/@zag-js/utils/dist/functions.js";
-import { addDomEvent as f } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/event.js";
-import { isSafari as F } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/platform.js";
-import { observeAttributes as _ } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/mutation-observer.js";
-import { memo as d } from "../../../../../@zag-js_core@1.35.3/node_modules/@zag-js/core/dist/memo.js";
-import { setup as G } from "../../../../../@zag-js_core@1.35.3/node_modules/@zag-js/core/dist/create-machine.js";
-var { choose: L, guards: W, createMachine: $ } = G(), { not: g, and: E } = W, re = $({
-  props({ props: e }) {
-    const t = S(e.step, e.formatOptions);
-    return {
-      dir: "ltr",
-      locale: "en-US",
-      focusInputOnChange: !0,
-      clampValueOnBlur: !e.allowOverflow,
-      allowOverflow: !1,
-      inputMode: "decimal",
-      pattern: "-?[0-9]*(.[0-9]+)?",
-      defaultValue: "",
-      step: t,
-      min: Number.MIN_SAFE_INTEGER,
-      max: Number.MAX_SAFE_INTEGER,
-      spinOnPress: !0,
-      ...e,
-      translations: {
-        incrementLabel: "increment value",
-        decrementLabel: "decrease value",
-        ...e.translations
-      }
-    };
-  },
-  initialState() {
-    return "idle";
-  },
-  context({ prop: e, bindable: t, getComputed: n }) {
-    return {
-      value: t(() => ({
-        defaultValue: e("defaultValue"),
-        value: e("value"),
-        onChange(a) {
-          const r = n(), s = m(a, { computed: r, prop: e });
-          e("onValueChange")?.({ value: a, valueAsNumber: s });
-        }
-      })),
-      hint: t(() => ({ defaultValue: null })),
-      scrubberCursorPoint: t(() => ({
-        defaultValue: null,
-        hash(a) {
-          return a ? `x:${a.x}, y:${a.y}` : "";
-        }
-      })),
-      fieldsetDisabled: t(() => ({ defaultValue: !1 }))
-    };
-  },
-  computed: {
-    isRtl: ({ prop: e }) => e("dir") === "rtl",
-    valueAsNumber: ({ context: e, computed: t, prop: n }) => m(e.get("value"), { computed: t, prop: n }),
-    formattedValue: ({ computed: e, prop: t }) => i(e("valueAsNumber"), { computed: e, prop: t }),
-    isAtMin: ({ computed: e, prop: t }) => M(e("valueAsNumber"), t("min")),
-    isAtMax: ({ computed: e, prop: t }) => x(e("valueAsNumber"), t("max")),
-    isOutOfRange: ({ computed: e, prop: t }) => !H(e("valueAsNumber"), t("min"), t("max")),
-    isValueEmpty: ({ context: e }) => e.get("value") === "",
-    isDisabled: ({ prop: e, context: t }) => !!e("disabled") || t.get("fieldsetDisabled"),
-    canIncrement: ({ prop: e, computed: t }) => e("allowOverflow") || !t("isAtMax"),
-    canDecrement: ({ prop: e, computed: t }) => e("allowOverflow") || !t("isAtMin"),
-    valueText: ({ prop: e, context: t }) => e("translations").valueText?.(t.get("value")),
-    formatter: d(
-      ({ prop: e }) => [e("locale"), e("formatOptions")],
-      ([e, t]) => p(e, t)
-    ),
-    parser: d(
-      ({ prop: e }) => [e("locale"), e("formatOptions")],
-      ([e, t]) => T(e, t)
-    )
-  },
-  watch({ track: e, action: t, context: n, computed: a, prop: r }) {
-    e([() => n.get("value"), () => r("locale"), () => JSON.stringify(r("formatOptions"))], () => {
-      t(["syncInputElement"]);
-    }), e([() => a("isOutOfRange")], () => {
-      t(["invokeOnInvalid"]);
-    }), e([() => n.hash("scrubberCursorPoint")], () => {
-      t(["setVirtualCursorPosition"]);
-    });
-  },
-  effects: ["trackFormControl"],
-  on: {
-    "VALUE.SET": {
-      actions: ["setRawValue"]
-    },
-    "VALUE.CLEAR": {
-      actions: ["clearValue"]
-    },
-    "VALUE.INCREMENT": {
-      actions: ["increment"]
-    },
-    "VALUE.DECREMENT": {
-      actions: ["decrement"]
-    }
-  },
-  states: {
-    idle: {
-      on: {
-        "TRIGGER.PRESS_DOWN": [
-          { guard: "isTouchPointer", target: "before:spin", actions: ["setHint"] },
-          {
-            target: "before:spin",
-            actions: ["focusInput", "invokeOnFocus", "setHint"]
-          }
-        ],
-        "SCRUBBER.PRESS_DOWN": {
-          target: "scrubbing",
-          actions: ["focusInput", "invokeOnFocus", "setHint", "setCursorPoint"]
-        },
-        "INPUT.FOCUS": {
-          target: "focused",
-          actions: ["focusInput", "invokeOnFocus"]
-        }
-      }
-    },
-    focused: {
-      tags: ["focus"],
-      effects: ["attachWheelListener"],
-      on: {
-        "TRIGGER.PRESS_DOWN": [
-          { guard: "isTouchPointer", target: "before:spin", actions: ["setHint"] },
-          { target: "before:spin", actions: ["focusInput", "setHint"] }
-        ],
-        "SCRUBBER.PRESS_DOWN": {
-          target: "scrubbing",
-          actions: ["focusInput", "setHint", "setCursorPoint"]
-        },
-        "INPUT.ARROW_UP": {
-          actions: ["increment"]
-        },
-        "INPUT.ARROW_DOWN": {
-          actions: ["decrement"]
-        },
-        "INPUT.HOME": {
-          actions: ["decrementToMin"]
-        },
-        "INPUT.END": {
-          actions: ["incrementToMax"]
-        },
-        "INPUT.CHANGE": {
-          actions: ["setValue", "setHint"]
-        },
-        "INPUT.BLUR": [
-          {
-            guard: E("clampValueOnBlur", g("isInRange")),
-            target: "idle",
-            actions: ["setClampedValue", "clearHint", "invokeOnBlur", "invokeOnValueCommit"]
-          },
-          {
-            guard: g("isInRange"),
-            target: "idle",
-            actions: ["setFormattedValue", "clearHint", "invokeOnBlur", "invokeOnInvalid", "invokeOnValueCommit"]
-          },
-          {
-            target: "idle",
-            actions: ["setFormattedValue", "clearHint", "invokeOnBlur", "invokeOnValueCommit"]
-          }
-        ],
-        "INPUT.ENTER": {
-          actions: ["setFormattedValue", "clearHint", "invokeOnBlur", "invokeOnValueCommit"]
-        }
-      }
-    },
-    "before:spin": {
-      tags: ["focus"],
-      effects: ["trackButtonDisabled", "waitForChangeDelay"],
-      entry: L([
-        { guard: "isIncrementHint", actions: ["increment"] },
-        { guard: "isDecrementHint", actions: ["decrement"] }
-      ]),
-      on: {
-        CHANGE_DELAY: {
-          target: "spinning",
-          guard: E("isInRange", "spinOnPress")
-        },
-        "TRIGGER.PRESS_UP": [
-          { guard: "isTouchPointer", target: "focused", actions: ["clearHint"] },
-          { target: "focused", actions: ["focusInput", "clearHint"] }
-        ]
-      }
-    },
-    spinning: {
-      tags: ["focus"],
-      effects: ["trackButtonDisabled", "spinValue"],
-      on: {
-        SPIN: [
-          {
-            guard: "isIncrementHint",
-            actions: ["increment"]
-          },
-          {
-            guard: "isDecrementHint",
-            actions: ["decrement"]
-          }
-        ],
-        "TRIGGER.PRESS_UP": {
-          target: "focused",
-          actions: ["focusInput", "clearHint"]
-        }
-      }
-    },
-    scrubbing: {
-      tags: ["focus"],
-      effects: ["activatePointerLock", "trackMousemove", "setupVirtualCursor", "preventTextSelection"],
-      on: {
-        "SCRUBBER.POINTER_UP": {
-          target: "focused",
-          actions: ["focusInput", "clearCursorPoint"]
-        },
-        "SCRUBBER.POINTER_MOVE": [
-          {
-            guard: "isIncrementHint",
-            actions: ["increment", "setCursorPoint"]
-          },
-          {
-            guard: "isDecrementHint",
-            actions: ["decrement", "setCursorPoint"]
-          }
-        ]
-      }
-    }
-  },
-  implementations: {
-    guards: {
-      clampValueOnBlur: ({ prop: e }) => e("clampValueOnBlur"),
-      spinOnPress: ({ prop: e }) => !!e("spinOnPress"),
-      isInRange: ({ computed: e }) => !e("isOutOfRange"),
-      isDecrementHint: ({ context: e, event: t }) => (t.hint ?? e.get("hint")) === "decrement",
-      isIncrementHint: ({ context: e, event: t }) => (t.hint ?? e.get("hint")) === "increment",
-      isTouchPointer: ({ event: e }) => e.pointerType === "touch"
-    },
-    effects: {
-      waitForChangeDelay({ send: e }) {
-        const t = setTimeout(() => {
-          e({ type: "CHANGE_DELAY" });
-        }, 300);
-        return () => clearTimeout(t);
-      },
-      spinValue({ send: e }) {
-        const t = setInterval(() => {
-          e({ type: "SPIN" });
-        }, 50);
-        return () => clearInterval(t);
-      },
-      trackFormControl({ context: e, scope: t }) {
-        const n = o(t);
-        return w(n, {
-          onFieldsetDisabledChange(a) {
-            e.set("fieldsetDisabled", a);
-          },
-          onFormReset() {
-            e.set("value", e.initial("value"));
-          }
-        });
-      },
-      setupVirtualCursor({ context: e, scope: t }) {
-        const n = e.get("scrubberCursorPoint");
-        return A(t, n);
-      },
-      preventTextSelection({ scope: e }) {
-        return I(e);
-      },
-      trackButtonDisabled({ context: e, scope: t, send: n }) {
-        const a = e.get("hint"), r = b(t, a);
-        return _(r, {
-          attributes: ["disabled"],
-          callback() {
-            n({ type: "TRIGGER.PRESS_UP", src: "attr" });
-          }
-        });
-      },
-      attachWheelListener({ scope: e, send: t, prop: n }) {
-        const a = o(e);
-        if (!a || !e.isActiveElement(a) || !n("allowMouseWheel")) return;
-        function r(s) {
-          s.preventDefault();
-          const u = Math.sign(s.deltaY) * -1;
-          u === 1 ? t({ type: "VALUE.INCREMENT" }) : u === -1 && t({ type: "VALUE.DECREMENT" });
-        }
-        return f(a, "wheel", r, { passive: !1 });
-      },
-      activatePointerLock({ scope: e }) {
-        if (!F())
-          return k(e.getDoc());
-      },
-      trackMousemove({ scope: e, send: t, context: n, computed: a }) {
-        const r = e.getDoc();
-        function s(V) {
-          const O = n.get("scrubberCursorPoint"), R = a("isRtl"), c = h(e, { point: O, isRtl: R, event: V });
-          c.hint && t({
-            type: "SCRUBBER.POINTER_MOVE",
-            hint: c.hint,
-            point: c.point
-          });
-        }
-        function u() {
-          t({ type: "SCRUBBER.POINTER_UP" });
-        }
-        return y(f(r, "mousemove", s, !1), f(r, "mouseup", u, !1));
-      }
-    },
-    actions: {
-      focusInput({ scope: e, prop: t }) {
-        if (!t("focusInputOnChange")) return;
-        const n = o(e);
-        e.isActiveElement(n) || v(() => n?.focus({ preventScroll: !0 }));
-      },
-      increment({ context: e, event: t, prop: n, computed: a }) {
-        let r = D(a("valueAsNumber"), t.step ?? n("step"));
-        n("allowOverflow") || (r = l(r, n("min"), n("max"))), e.set("value", i(r, { computed: a, prop: n }));
-      },
-      decrement({ context: e, event: t, prop: n, computed: a }) {
-        let r = U(a("valueAsNumber"), t.step ?? n("step"));
-        n("allowOverflow") || (r = l(r, n("min"), n("max"))), e.set("value", i(r, { computed: a, prop: n }));
-      },
-      setClampedValue({ context: e, prop: t, computed: n }) {
-        const a = l(n("valueAsNumber"), t("min"), t("max"));
-        e.set("value", i(a, { computed: n, prop: t }));
-      },
-      setRawValue({ context: e, event: t, prop: n, computed: a }) {
-        let r = m(t.value, { computed: a, prop: n });
-        n("allowOverflow") || (r = l(r, n("min"), n("max"))), e.set("value", i(r, { computed: a, prop: n }));
-      },
-      setValue({ context: e, event: t }) {
-        const n = t.target?.value ?? t.value;
-        e.set("value", n);
-      },
-      clearValue({ context: e }) {
-        e.set("value", "");
-      },
-      incrementToMax({ context: e, prop: t, computed: n }) {
-        const a = i(t("max"), { computed: n, prop: t });
-        e.set("value", a);
-      },
-      decrementToMin({ context: e, prop: t, computed: n }) {
-        const a = i(t("min"), { computed: n, prop: t });
-        e.set("value", a);
-      },
-      setHint({ context: e, event: t }) {
-        e.set("hint", t.hint);
-      },
-      clearHint({ context: e }) {
-        e.set("hint", null);
-      },
-      invokeOnFocus({ computed: e, prop: t }) {
-        t("onFocusChange")?.({
-          focused: !0,
-          value: e("formattedValue"),
-          valueAsNumber: e("valueAsNumber")
-        });
-      },
-      invokeOnBlur({ computed: e, prop: t }) {
-        t("onFocusChange")?.({
-          focused: !1,
-          value: e("formattedValue"),
-          valueAsNumber: e("valueAsNumber")
-        });
-      },
-      invokeOnInvalid({ computed: e, prop: t, event: n }) {
-        if (n.type === "INPUT.CHANGE") return;
-        const a = e("valueAsNumber") > t("max") ? "rangeOverflow" : "rangeUnderflow";
-        t("onValueInvalid")?.({
-          reason: a,
-          value: e("formattedValue"),
-          valueAsNumber: e("valueAsNumber")
-        });
-      },
-      invokeOnValueCommit({ computed: e, prop: t }) {
-        t("onValueCommit")?.({
-          value: e("formattedValue"),
-          valueAsNumber: e("valueAsNumber")
-        });
-      },
-      syncInputElement({ context: e, event: t, computed: n, scope: a }) {
-        const r = t.type.endsWith("CHANGE") ? e.get("value") : n("formattedValue"), s = o(a), u = t.selection ?? C(s, a);
-        v(() => {
-          B(s, r), N(s, u, a);
-        });
-      },
-      setFormattedValue({ context: e, computed: t, action: n }) {
-        e.set("value", t("formattedValue")), n(["syncInputElement"]);
-      },
-      setCursorPoint({ context: e, event: t }) {
-        e.set("scrubberCursorPoint", t.point);
-      },
-      clearCursorPoint({ context: e }) {
-        e.set("scrubberCursorPoint", null);
-      },
-      setVirtualCursorPosition({ context: e, scope: t }) {
-        const n = P(t), a = e.get("scrubberCursorPoint");
-        !n || !a || (n.style.transform = `translate3d(${a.x}px, ${a.y}px, 0px)`);
-      }
-    }
-  }
+import { callAll as e } from "../../../../../@zag-js_utils@1.35.3/node_modules/@zag-js/utils/dist/functions.js";
+import { clampValue as t, decrementValue as n, incrementValue as r, isValueAtMax as i, isValueAtMin as a, isValueWithinRange as o } from "../../../../../@zag-js_utils@1.35.3/node_modules/@zag-js/utils/dist/number.js";
+import { memo as s } from "../../../../../@zag-js_core@1.35.3/node_modules/@zag-js/core/dist/memo.js";
+import { setup as c } from "../../../../../@zag-js_core@1.35.3/node_modules/@zag-js/core/dist/create-machine.js";
+import { isSafari as l } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/platform.js";
+import { addDomEvent as u } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/event.js";
+import { setElementValue as d, trackFormControl as f } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/form.js";
+import { raf as p } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/raf.js";
+import { observeAttributes as m } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/mutation-observer.js";
+import { requestPointerLock as h } from "../../../../../@zag-js_dom-query@1.35.3/node_modules/@zag-js/dom-query/dist/pointer-lock.js";
+import { recordCursor as g, restoreCursor as _ } from "./cursor.js";
+import { getCursorEl as v, getInputEl as y, getMousemoveValue as b, getPressedTriggerEl as x, preventTextSelection as S, setupVirtualCursor as C } from "./number-input.dom.js";
+import { createFormatter as w, createParser as T, formatValue as E, getDefaultStep as D, parseValue as O } from "./number-input.utils.js";
+//#region ../../node_modules/.bun/@zag-js+number-input@1.35.3/node_modules/@zag-js/number-input/dist/number-input.machine.mjs
+var { choose: k, guards: A, createMachine: j } = c(), { not: M, and: N } = A, P = j({
+	props({ props: e }) {
+		let t = D(e.step, e.formatOptions);
+		return {
+			dir: "ltr",
+			locale: "en-US",
+			focusInputOnChange: !0,
+			clampValueOnBlur: !e.allowOverflow,
+			allowOverflow: !1,
+			inputMode: "decimal",
+			pattern: "-?[0-9]*(.[0-9]+)?",
+			defaultValue: "",
+			step: t,
+			min: -(2 ** 53 - 1),
+			max: 2 ** 53 - 1,
+			spinOnPress: !0,
+			...e,
+			translations: {
+				incrementLabel: "increment value",
+				decrementLabel: "decrease value",
+				...e.translations
+			}
+		};
+	},
+	initialState() {
+		return "idle";
+	},
+	context({ prop: e, bindable: t, getComputed: n }) {
+		return {
+			value: t(() => ({
+				defaultValue: e("defaultValue"),
+				value: e("value"),
+				onChange(t) {
+					let r = O(t, {
+						computed: n(),
+						prop: e
+					});
+					e("onValueChange")?.({
+						value: t,
+						valueAsNumber: r
+					});
+				}
+			})),
+			hint: t(() => ({ defaultValue: null })),
+			scrubberCursorPoint: t(() => ({
+				defaultValue: null,
+				hash(e) {
+					return e ? `x:${e.x}, y:${e.y}` : "";
+				}
+			})),
+			fieldsetDisabled: t(() => ({ defaultValue: !1 }))
+		};
+	},
+	computed: {
+		isRtl: ({ prop: e }) => e("dir") === "rtl",
+		valueAsNumber: ({ context: e, computed: t, prop: n }) => O(e.get("value"), {
+			computed: t,
+			prop: n
+		}),
+		formattedValue: ({ computed: e, prop: t }) => E(e("valueAsNumber"), {
+			computed: e,
+			prop: t
+		}),
+		isAtMin: ({ computed: e, prop: t }) => a(e("valueAsNumber"), t("min")),
+		isAtMax: ({ computed: e, prop: t }) => i(e("valueAsNumber"), t("max")),
+		isOutOfRange: ({ computed: e, prop: t }) => !o(e("valueAsNumber"), t("min"), t("max")),
+		isValueEmpty: ({ context: e }) => e.get("value") === "",
+		isDisabled: ({ prop: e, context: t }) => !!e("disabled") || t.get("fieldsetDisabled"),
+		canIncrement: ({ prop: e, computed: t }) => e("allowOverflow") || !t("isAtMax"),
+		canDecrement: ({ prop: e, computed: t }) => e("allowOverflow") || !t("isAtMin"),
+		valueText: ({ prop: e, context: t }) => e("translations").valueText?.(t.get("value")),
+		formatter: s(({ prop: e }) => [e("locale"), e("formatOptions")], ([e, t]) => w(e, t)),
+		parser: s(({ prop: e }) => [e("locale"), e("formatOptions")], ([e, t]) => T(e, t))
+	},
+	watch({ track: e, action: t, context: n, computed: r, prop: i }) {
+		e([
+			() => n.get("value"),
+			() => i("locale"),
+			() => JSON.stringify(i("formatOptions"))
+		], () => {
+			t(["syncInputElement"]);
+		}), e([() => r("isOutOfRange")], () => {
+			t(["invokeOnInvalid"]);
+		}), e([() => n.hash("scrubberCursorPoint")], () => {
+			t(["setVirtualCursorPosition"]);
+		});
+	},
+	effects: ["trackFormControl"],
+	on: {
+		"VALUE.SET": { actions: ["setRawValue"] },
+		"VALUE.CLEAR": { actions: ["clearValue"] },
+		"VALUE.INCREMENT": { actions: ["increment"] },
+		"VALUE.DECREMENT": { actions: ["decrement"] }
+	},
+	states: {
+		idle: { on: {
+			"TRIGGER.PRESS_DOWN": [{
+				guard: "isTouchPointer",
+				target: "before:spin",
+				actions: ["setHint"]
+			}, {
+				target: "before:spin",
+				actions: [
+					"focusInput",
+					"invokeOnFocus",
+					"setHint"
+				]
+			}],
+			"SCRUBBER.PRESS_DOWN": {
+				target: "scrubbing",
+				actions: [
+					"focusInput",
+					"invokeOnFocus",
+					"setHint",
+					"setCursorPoint"
+				]
+			},
+			"INPUT.FOCUS": {
+				target: "focused",
+				actions: ["focusInput", "invokeOnFocus"]
+			}
+		} },
+		focused: {
+			tags: ["focus"],
+			effects: ["attachWheelListener"],
+			on: {
+				"TRIGGER.PRESS_DOWN": [{
+					guard: "isTouchPointer",
+					target: "before:spin",
+					actions: ["setHint"]
+				}, {
+					target: "before:spin",
+					actions: ["focusInput", "setHint"]
+				}],
+				"SCRUBBER.PRESS_DOWN": {
+					target: "scrubbing",
+					actions: [
+						"focusInput",
+						"setHint",
+						"setCursorPoint"
+					]
+				},
+				"INPUT.ARROW_UP": { actions: ["increment"] },
+				"INPUT.ARROW_DOWN": { actions: ["decrement"] },
+				"INPUT.HOME": { actions: ["decrementToMin"] },
+				"INPUT.END": { actions: ["incrementToMax"] },
+				"INPUT.CHANGE": { actions: ["setValue", "setHint"] },
+				"INPUT.BLUR": [
+					{
+						guard: N("clampValueOnBlur", M("isInRange")),
+						target: "idle",
+						actions: [
+							"setClampedValue",
+							"clearHint",
+							"invokeOnBlur",
+							"invokeOnValueCommit"
+						]
+					},
+					{
+						guard: M("isInRange"),
+						target: "idle",
+						actions: [
+							"setFormattedValue",
+							"clearHint",
+							"invokeOnBlur",
+							"invokeOnInvalid",
+							"invokeOnValueCommit"
+						]
+					},
+					{
+						target: "idle",
+						actions: [
+							"setFormattedValue",
+							"clearHint",
+							"invokeOnBlur",
+							"invokeOnValueCommit"
+						]
+					}
+				],
+				"INPUT.ENTER": { actions: [
+					"setFormattedValue",
+					"clearHint",
+					"invokeOnBlur",
+					"invokeOnValueCommit"
+				] }
+			}
+		},
+		"before:spin": {
+			tags: ["focus"],
+			effects: ["trackButtonDisabled", "waitForChangeDelay"],
+			entry: k([{
+				guard: "isIncrementHint",
+				actions: ["increment"]
+			}, {
+				guard: "isDecrementHint",
+				actions: ["decrement"]
+			}]),
+			on: {
+				CHANGE_DELAY: {
+					target: "spinning",
+					guard: N("isInRange", "spinOnPress")
+				},
+				"TRIGGER.PRESS_UP": [{
+					guard: "isTouchPointer",
+					target: "focused",
+					actions: ["clearHint"]
+				}, {
+					target: "focused",
+					actions: ["focusInput", "clearHint"]
+				}]
+			}
+		},
+		spinning: {
+			tags: ["focus"],
+			effects: ["trackButtonDisabled", "spinValue"],
+			on: {
+				SPIN: [{
+					guard: "isIncrementHint",
+					actions: ["increment"]
+				}, {
+					guard: "isDecrementHint",
+					actions: ["decrement"]
+				}],
+				"TRIGGER.PRESS_UP": {
+					target: "focused",
+					actions: ["focusInput", "clearHint"]
+				}
+			}
+		},
+		scrubbing: {
+			tags: ["focus"],
+			effects: [
+				"activatePointerLock",
+				"trackMousemove",
+				"setupVirtualCursor",
+				"preventTextSelection"
+			],
+			on: {
+				"SCRUBBER.POINTER_UP": {
+					target: "focused",
+					actions: ["focusInput", "clearCursorPoint"]
+				},
+				"SCRUBBER.POINTER_MOVE": [{
+					guard: "isIncrementHint",
+					actions: ["increment", "setCursorPoint"]
+				}, {
+					guard: "isDecrementHint",
+					actions: ["decrement", "setCursorPoint"]
+				}]
+			}
+		}
+	},
+	implementations: {
+		guards: {
+			clampValueOnBlur: ({ prop: e }) => e("clampValueOnBlur"),
+			spinOnPress: ({ prop: e }) => !!e("spinOnPress"),
+			isInRange: ({ computed: e }) => !e("isOutOfRange"),
+			isDecrementHint: ({ context: e, event: t }) => (t.hint ?? e.get("hint")) === "decrement",
+			isIncrementHint: ({ context: e, event: t }) => (t.hint ?? e.get("hint")) === "increment",
+			isTouchPointer: ({ event: e }) => e.pointerType === "touch"
+		},
+		effects: {
+			waitForChangeDelay({ send: e }) {
+				let t = setTimeout(() => {
+					e({ type: "CHANGE_DELAY" });
+				}, 300);
+				return () => clearTimeout(t);
+			},
+			spinValue({ send: e }) {
+				let t = setInterval(() => {
+					e({ type: "SPIN" });
+				}, 50);
+				return () => clearInterval(t);
+			},
+			trackFormControl({ context: e, scope: t }) {
+				return f(y(t), {
+					onFieldsetDisabledChange(t) {
+						e.set("fieldsetDisabled", t);
+					},
+					onFormReset() {
+						e.set("value", e.initial("value"));
+					}
+				});
+			},
+			setupVirtualCursor({ context: e, scope: t }) {
+				return C(t, e.get("scrubberCursorPoint"));
+			},
+			preventTextSelection({ scope: e }) {
+				return S(e);
+			},
+			trackButtonDisabled({ context: e, scope: t, send: n }) {
+				return m(x(t, e.get("hint")), {
+					attributes: ["disabled"],
+					callback() {
+						n({
+							type: "TRIGGER.PRESS_UP",
+							src: "attr"
+						});
+					}
+				});
+			},
+			attachWheelListener({ scope: e, send: t, prop: n }) {
+				let r = y(e);
+				if (!r || !e.isActiveElement(r) || !n("allowMouseWheel")) return;
+				function i(e) {
+					e.preventDefault();
+					let n = Math.sign(e.deltaY) * -1;
+					n === 1 ? t({ type: "VALUE.INCREMENT" }) : n === -1 && t({ type: "VALUE.DECREMENT" });
+				}
+				return u(r, "wheel", i, { passive: !1 });
+			},
+			activatePointerLock({ scope: e }) {
+				if (!l()) return h(e.getDoc());
+			},
+			trackMousemove({ scope: t, send: n, context: r, computed: i }) {
+				let a = t.getDoc();
+				function o(e) {
+					let a = b(t, {
+						point: r.get("scrubberCursorPoint"),
+						isRtl: i("isRtl"),
+						event: e
+					});
+					a.hint && n({
+						type: "SCRUBBER.POINTER_MOVE",
+						hint: a.hint,
+						point: a.point
+					});
+				}
+				function s() {
+					n({ type: "SCRUBBER.POINTER_UP" });
+				}
+				return e(u(a, "mousemove", o, !1), u(a, "mouseup", s, !1));
+			}
+		},
+		actions: {
+			focusInput({ scope: e, prop: t }) {
+				if (!t("focusInputOnChange")) return;
+				let n = y(e);
+				e.isActiveElement(n) || p(() => n?.focus({ preventScroll: !0 }));
+			},
+			increment({ context: e, event: n, prop: i, computed: a }) {
+				let o = r(a("valueAsNumber"), n.step ?? i("step"));
+				i("allowOverflow") || (o = t(o, i("min"), i("max"))), e.set("value", E(o, {
+					computed: a,
+					prop: i
+				}));
+			},
+			decrement({ context: e, event: r, prop: i, computed: a }) {
+				let o = n(a("valueAsNumber"), r.step ?? i("step"));
+				i("allowOverflow") || (o = t(o, i("min"), i("max"))), e.set("value", E(o, {
+					computed: a,
+					prop: i
+				}));
+			},
+			setClampedValue({ context: e, prop: n, computed: r }) {
+				let i = t(r("valueAsNumber"), n("min"), n("max"));
+				e.set("value", E(i, {
+					computed: r,
+					prop: n
+				}));
+			},
+			setRawValue({ context: e, event: n, prop: r, computed: i }) {
+				let a = O(n.value, {
+					computed: i,
+					prop: r
+				});
+				r("allowOverflow") || (a = t(a, r("min"), r("max"))), e.set("value", E(a, {
+					computed: i,
+					prop: r
+				}));
+			},
+			setValue({ context: e, event: t }) {
+				let n = t.target?.value ?? t.value;
+				e.set("value", n);
+			},
+			clearValue({ context: e }) {
+				e.set("value", "");
+			},
+			incrementToMax({ context: e, prop: t, computed: n }) {
+				let r = E(t("max"), {
+					computed: n,
+					prop: t
+				});
+				e.set("value", r);
+			},
+			decrementToMin({ context: e, prop: t, computed: n }) {
+				let r = E(t("min"), {
+					computed: n,
+					prop: t
+				});
+				e.set("value", r);
+			},
+			setHint({ context: e, event: t }) {
+				e.set("hint", t.hint);
+			},
+			clearHint({ context: e }) {
+				e.set("hint", null);
+			},
+			invokeOnFocus({ computed: e, prop: t }) {
+				t("onFocusChange")?.({
+					focused: !0,
+					value: e("formattedValue"),
+					valueAsNumber: e("valueAsNumber")
+				});
+			},
+			invokeOnBlur({ computed: e, prop: t }) {
+				t("onFocusChange")?.({
+					focused: !1,
+					value: e("formattedValue"),
+					valueAsNumber: e("valueAsNumber")
+				});
+			},
+			invokeOnInvalid({ computed: e, prop: t, event: n }) {
+				if (n.type === "INPUT.CHANGE") return;
+				let r = e("valueAsNumber") > t("max") ? "rangeOverflow" : "rangeUnderflow";
+				t("onValueInvalid")?.({
+					reason: r,
+					value: e("formattedValue"),
+					valueAsNumber: e("valueAsNumber")
+				});
+			},
+			invokeOnValueCommit({ computed: e, prop: t }) {
+				t("onValueCommit")?.({
+					value: e("formattedValue"),
+					valueAsNumber: e("valueAsNumber")
+				});
+			},
+			syncInputElement({ context: e, event: t, computed: n, scope: r }) {
+				let i = t.type.endsWith("CHANGE") ? e.get("value") : n("formattedValue"), a = y(r), o = t.selection ?? g(a, r);
+				p(() => {
+					d(a, i), _(a, o, r);
+				});
+			},
+			setFormattedValue({ context: e, computed: t, action: n }) {
+				e.set("value", t("formattedValue")), n(["syncInputElement"]);
+			},
+			setCursorPoint({ context: e, event: t }) {
+				e.set("scrubberCursorPoint", t.point);
+			},
+			clearCursorPoint({ context: e }) {
+				e.set("scrubberCursorPoint", null);
+			},
+			setVirtualCursorPosition({ context: e, scope: t }) {
+				let n = v(t), r = e.get("scrubberCursorPoint");
+				!n || !r || (n.style.transform = `translate3d(${r.x}px, ${r.y}px, 0px)`);
+			}
+		}
+	}
 });
-export {
-  re as machine
-};
-//# sourceMappingURL=number-input.machine.js.map
+//#endregion
+export { P as machine };
+
+//# sourceMappingURL=number-input.machine.js.map