@zag-js/number-input 0.20.0 → 0.22.0

package/dist/index.mjs

@@ -13,7 +13,7 @@ var parts = anatomy.build();
 
 // src/number-input.connect.ts
 import { getEventPoint, getEventStep, getNativeEvent, isLeftClick } from "@zag-js/dom-event";
-import { ariaAttr, dataAttr } from "@zag-js/dom-query";
+import { ariaAttr, dataAttr, isHTMLElement } from "@zag-js/dom-query";
 import { roundToDevicePixel as roundToDevicePixel2 } from "@zag-js/number-utils";
 
 // src/number-input.dom.ts
@@ -114,54 +114,15 @@ var dom = createScope({
   }
 });
 
-// src/number-input.utils.ts
-import { isModifiedEvent } from "@zag-js/dom-event";
-import { clamp, decrement, formatDecimal, increment } from "@zag-js/number-utils";
-var utils = {
-  isValidNumericEvent: (ctx, event) => {
-    if (event.key == null)
-      return true;
-    const isModifier = isModifiedEvent(event);
-    const isSingleKey = event.key.length === 1;
-    if (isModifier || !isSingleKey)
-      return true;
-    return ctx.validateCharacter?.(event.key) ?? utils.isFloatingPoint(event.key);
-  },
-  isFloatingPoint: (v) => /^[0-9+\-.]$/.test(v),
-  sanitize: (ctx, value) => {
-    return value.split("").filter(ctx.validateCharacter ?? utils.isFloatingPoint).join("");
-  },
-  increment: (ctx, step) => {
-    const value = increment(ctx.value, step ?? ctx.step);
-    return formatDecimal(clamp(value, ctx), ctx);
-  },
-  decrement: (ctx, step) => {
-    const value = decrement(ctx.value, step ?? ctx.step);
-    return formatDecimal(clamp(value, ctx), ctx);
-  },
-  clamp: (ctx) => {
-    return formatDecimal(clamp(ctx.value, ctx), ctx);
-  },
-  parse: (ctx, value) => {
-    return ctx.parse?.(value) ?? value;
-  },
-  format: (ctx, value) => {
-    const _val = value.toString();
-    return ctx.format?.(_val) ?? _val;
-  },
-  round: (ctx) => {
-    return formatDecimal(ctx.value, ctx);
-  }
-};
-
 // src/number-input.connect.ts
 function connect(state, send, normalize) {
   const isFocused = state.hasTag("focus");
   const isInvalid = state.context.isOutOfRange || !!state.context.invalid;
-  const isDisabled = !!state.context.disabled;
   const isValueEmpty = state.context.isValueEmpty;
-  const isIncrementDisabled = isDisabled || !state.context.canIncrement;
-  const isDecrementDisabled = isDisabled || !state.context.canDecrement;
+  const isDisabled = state.context.isDisabled;
+  const isReadOnly = state.context.readOnly;
+  const isIncrementDisabled = isDisabled || !state.context.canIncrement || isReadOnly;
+  const isDecrementDisabled = isDisabled || !state.context.canDecrement || isReadOnly;
   const translations = state.context.translations;
   return {
     isFocused,
@@ -170,38 +131,37 @@ function connect(state, send, normalize) {
     value: state.context.formattedValue,
     valueAsNumber: state.context.valueAsNumber,
     setValue(value) {
-      send({ type: "SET_VALUE", value: value.toString() });
+      send({ type: "VALUE.SET", value: value.toString() });
     },
     clearValue() {
-      send("CLEAR_VALUE");
+      send("VALUE.CLEAR");
     },
     increment() {
-      send("INCREMENT");
+      send("VALUE.INCREMENT");
     },
     decrement() {
-      send("DECREMENT");
+      send("VALUE.DECREMENT");
     },
     setToMax() {
-      send({ type: "SET_VALUE", value: state.context.max });
+      send({ type: "VALUE.SET", value: state.context.max });
     },
     setToMin() {
-      send({ type: "SET_VALUE", value: state.context.min });
+      send({ type: "VALUE.SET", value: state.context.min });
     },
     focus() {
       dom.getInputEl(state.context)?.focus();
     },
-    blur() {
-      dom.getInputEl(state.context)?.blur();
-    },
     rootProps: normalize.element({
       id: dom.getRootId(state.context),
       ...parts.root.attrs,
+      dir: state.context.dir,
       "data-disabled": dataAttr(isDisabled),
       "data-focus": dataAttr(isFocused),
       "data-invalid": dataAttr(isInvalid)
     }),
     labelProps: normalize.label({
       ...parts.label.attrs,
+      dir: state.context.dir,
       "data-disabled": dataAttr(isDisabled),
       "data-focus": dataAttr(isFocused),
       "data-invalid": dataAttr(isInvalid),
@@ -210,6 +170,7 @@ function connect(state, send, normalize) {
     }),
     controlProps: normalize.element({
       ...parts.control.attrs,
+      dir: state.context.dir,
       role: "group",
       "aria-disabled": isDisabled,
       "data-focus": dataAttr(isFocused),
@@ -219,6 +180,7 @@ function connect(state, send, normalize) {
     }),
     inputProps: normalize.input({
       ...parts.input.attrs,
+      dir: state.context.dir,
       name: state.context.name,
       form: state.context.form,
       id: dom.getInputId(state.context),
@@ -238,48 +200,68 @@ function connect(state, send, normalize) {
       "aria-roledescription": "numberfield",
       "aria-valuemin": state.context.min,
       "aria-valuemax": state.context.max,
-      "aria-valuenow": isNaN(state.context.valueAsNumber) ? void 0 : state.context.valueAsNumber,
+      "aria-valuenow": Number.isNaN(state.context.valueAsNumber) ? void 0 : state.context.valueAsNumber,
       "aria-valuetext": state.context.valueText,
+      onCompositionStart() {
+        send("INPUT.COMPOSITION_START");
+      },
+      onCompositionEnd() {
+        send("INPUT.COMPOSITION_END");
+      },
       onFocus() {
-        send("FOCUS");
+        send("INPUT.FOCUS");
       },
       onBlur() {
-        send("BLUR");
+        send({ type: "INPUT.COMMIT", src: "blur" });
       },
       onChange(event) {
-        send({ type: "CHANGE", target: event.currentTarget, hint: "set" });
+        send({ type: "INPUT.CHANGE", target: event.currentTarget, hint: "set" });
+      },
+      onBeforeInput(event) {
+        try {
+          const { selectionStart, selectionEnd, value } = event.currentTarget;
+          const nextValue = value.slice(0, selectionStart) + event.data + value.slice(selectionEnd);
+          const isValid = state.context.parser.isValidPartialNumber(nextValue);
+          if (!isValid) {
+            event.preventDefault();
+          }
+        } catch {
+        }
       },
       onKeyDown(event) {
-        const evt = getNativeEvent(event);
-        if (evt.isComposing)
+        if (state.context.readOnly)
           return;
-        if (!utils.isValidNumericEvent(state.context, event)) {
-          event.preventDefault();
-        }
         const step = getEventStep(event) * state.context.step;
         const keyMap = {
           ArrowUp() {
-            send({ type: "ARROW_UP", step });
+            send({ type: "INPUT.ARROW_UP", step });
+            event.preventDefault();
           },
           ArrowDown() {
-            send({ type: "ARROW_DOWN", step });
+            send({ type: "INPUT.ARROW_DOWN", step });
+            event.preventDefault();
           },
           Home() {
-            send("HOME");
+            send("INPUT.HOME");
+            event.preventDefault();
           },
           End() {
-            send("END");
+            send("INPUT.END");
+            event.preventDefault();
+          },
+          Enter() {
+            if (state.context.composing)
+              return;
+            send({ type: "INPUT.COMMIT", src: "enter" });
           }
         };
         const exec = keyMap[event.key];
-        if (exec) {
-          exec(event);
-          event.preventDefault();
-        }
+        exec?.(event);
       }
     }),
     decrementTriggerProps: normalize.button({
       ...parts.decrementTrigger.attrs,
+      dir: state.context.dir,
       id: dom.getDecrementTriggerId(state.context),
       disabled: isDecrementDisabled,
       "data-disabled": dataAttr(isDecrementDisabled),
@@ -288,22 +270,28 @@ function connect(state, send, normalize) {
       tabIndex: -1,
       "aria-controls": dom.getInputId(state.context),
       onPointerDown(event) {
-        if (isDecrementDisabled)
+        if (isDecrementDisabled || !isLeftClick(event))
           return;
-        send(isLeftClick(event) ? { type: "PRESS_DOWN", hint: "decrement" } : { type: "FOCUS" });
-        event.preventDefault();
+        if (event.pointerType === "mouse") {
+          send({ type: "TRIGGER.PRESS_DOWN", hint: "decrement" });
+          return event.preventDefault();
+        }
+        if (isHTMLElement(event.target)) {
+          event.target?.focus();
+        }
       },
       onPointerUp() {
-        send({ type: "PRESS_UP", hint: "decrement" });
+        send({ type: "TRIGGER.PRESS_UP", hint: "decrement" });
       },
       onPointerLeave() {
         if (isDecrementDisabled)
           return;
-        send({ type: "PRESS_UP", hint: "decrement" });
+        send({ type: "TRIGGER.PRESS_UP", hint: "decrement" });
       }
     }),
     incrementTriggerProps: normalize.button({
       ...parts.incrementTrigger.attrs,
+      dir: state.context.dir,
       id: dom.getIncrementTriggerId(state.context),
       disabled: isIncrementDisabled,
       "data-disabled": dataAttr(isIncrementDisabled),
@@ -312,16 +300,21 @@ function connect(state, send, normalize) {
       tabIndex: -1,
       "aria-controls": dom.getInputId(state.context),
       onPointerDown(event) {
-        if (isIncrementDisabled)
+        if (isIncrementDisabled || !isLeftClick(event))
           return;
-        send(isLeftClick(event) ? { type: "PRESS_DOWN", hint: "increment" } : { type: "FOCUS" });
-        event.preventDefault();
+        if (event.pointerType === "mouse") {
+          send({ type: "TRIGGER.PRESS_DOWN", hint: "increment" });
+          return event.preventDefault();
+        }
+        if (isHTMLElement(event.target)) {
+          event.target?.focus();
+        }
       },
       onPointerUp() {
-        send({ type: "PRESS_UP", hint: "increment" });
+        send({ type: "TRIGGER.PRESS_UP", hint: "increment" });
       },
       onPointerLeave() {
-        send({ type: "PRESS_UP", hint: "increment" });
+        send({ type: "TRIGGER.PRESS_UP", hint: "increment" });
       }
     }),
     scrubberProps: normalize.element({
@@ -336,7 +329,7 @@ function connect(state, send, normalize) {
         const point = getEventPoint(evt);
         point.x = point.x - roundToDevicePixel2(7.5);
         point.y = point.y - roundToDevicePixel2(7.5);
-        send({ type: "PRESS_DOWN_SCRUBBER", point });
+        send({ type: "SCRUBBER.PRESS_DOWN", point });
         event.preventDefault();
       },
       style: {
@@ -347,12 +340,57 @@ function connect(state, send, normalize) {
 }
 
 // src/number-input.machine.ts
-import { choose, createMachine, guards } from "@zag-js/core";
+import { NumberParser } from "@internationalized/number";
+import { choose, createMachine, guards, ref } from "@zag-js/core";
 import { addDomEvent, requestPointerLock } from "@zag-js/dom-event";
 import { isSafari as isSafari2, raf } from "@zag-js/dom-query";
+import { trackFormControl } from "@zag-js/form-utils";
 import { observeAttributes } from "@zag-js/mutation-observer";
-import { isAtMax, isAtMin, isWithinRange, valueOf } from "@zag-js/number-utils";
-import { callAll, compact, isEqual, match } from "@zag-js/utils";
+import { clamp, decrement, increment, isAtMax, isAtMin, isWithinRange } from "@zag-js/number-utils";
+import { callAll, compact, isEqual } from "@zag-js/utils";
+
+// src/cursor.ts
+function recordCursor(inputEl) {
+  if (inputEl.ownerDocument.activeElement !== inputEl)
+    return;
+  try {
+    const { selectionStart: start, selectionEnd: end, value } = inputEl;
+    const beforeTxt = value.substring(0, start);
+    const afterTxt = value.substring(end);
+    return {
+      start,
+      end,
+      value,
+      beforeTxt,
+      afterTxt
+    };
+  } catch {
+  }
+}
+function restoreCursor(inputEl, selection) {
+  if (inputEl.ownerDocument.activeElement !== inputEl || !selection)
+    return;
+  try {
+    const { value } = inputEl;
+    const { beforeTxt = "", afterTxt = "", start } = selection;
+    let startPos = value.length;
+    if (value.endsWith(afterTxt)) {
+      startPos = value.length - afterTxt.length;
+    } else if (value.startsWith(beforeTxt)) {
+      startPos = beforeTxt.length;
+    } else if (start != null) {
+      const beforeLastChar = beforeTxt[start - 1];
+      const newIndex = value.indexOf(beforeLastChar, start - 1);
+      if (newIndex !== -1) {
+        startPos = newIndex + 1;
+      }
+    }
+    inputEl.setSelectionRange(startPos, startPos);
+  } catch {
+  }
+}
+
+// src/number-input.machine.ts
 var { not, and } = guards;
 function machine(userContext) {
   const ctx = compact(userContext);
@@ -362,20 +400,25 @@ function machine(userContext) {
       initial: "idle",
       context: {
         dir: "ltr",
+        locale: "en-US",
         focusInputOnChange: true,
         clampValueOnBlur: true,
         allowOverflow: false,
         inputMode: "decimal",
         pattern: "[0-9]*(.[0-9]+)?",
-        hint: null,
         value: "",
         step: 1,
         min: Number.MIN_SAFE_INTEGER,
         max: Number.MAX_SAFE_INTEGER,
-        scrubberCursorPoint: null,
         invalid: false,
         spinOnPress: true,
         ...ctx,
+        hint: null,
+        scrubberCursorPoint: null,
+        composing: false,
+        fieldsetDisabled: false,
+        formatter: createFormatter(ctx.locale || "en-US", ctx.formatOptions),
+        parser: createParser(ctx.locale || "en-US", ctx.formatOptions),
         translations: {
           incrementLabel: "increment value",
           decrementLabel: "decrease value",
@@ -384,48 +427,56 @@ function machine(userContext) {
       },
       computed: {
         isRtl: (ctx2) => ctx2.dir === "rtl",
-        valueAsNumber: (ctx2) => valueOf(ctx2.value),
+        valueAsNumber: (ctx2) => ctx2.parser.parse(String(ctx2.value)) ?? 0,
         isAtMin: (ctx2) => isAtMin(ctx2.value, ctx2),
         isAtMax: (ctx2) => isAtMax(ctx2.value, ctx2),
         isOutOfRange: (ctx2) => !isWithinRange(ctx2.value, ctx2),
         isValueEmpty: (ctx2) => ctx2.value === "",
+        isDisabled: (ctx2) => !!ctx2.disabled || ctx2.fieldsetDisabled,
         canIncrement: (ctx2) => ctx2.allowOverflow || !ctx2.isAtMax,
         canDecrement: (ctx2) => ctx2.allowOverflow || !ctx2.isAtMin,
         valueText: (ctx2) => ctx2.translations.valueText?.(ctx2.value),
-        formattedValue: (ctx2) => ctx2.format?.(ctx2.value).toString() ?? ctx2.value
+        formattedValue: (ctx2) => {
+          if (Number.isNaN(ctx2.valueAsNumber))
+            return ctx2.value;
+          return ctx2.formatter.format(ctx2.valueAsNumber);
+        }
       },
       watch: {
+        formatOptions: ["setFormatterAndParser", "syncInputElement"],
+        locale: ["setFormatterAndParser", "syncInputElement"],
         value: ["syncInputElement"],
         isOutOfRange: ["invokeOnInvalid"],
         scrubberCursorPoint: ["setVirtualCursorPosition"]
       },
       entry: ["syncInputValue"],
+      activities: ["trackFormControl"],
       on: {
-        SET_VALUE: {
+        "VALUE.SET": {
           actions: ["setValue", "clampValue", "setHintToSet"]
         },
-        CLEAR_VALUE: {
+        "VALUE.CLEAR": {
           actions: ["clearValue"]
         },
-        INCREMENT: {
+        "VALUE.INCREMENT": {
           actions: ["increment"]
         },
-        DECREMENT: {
+        "VALUE.DECREMENT": {
           actions: ["decrement"]
         }
       },
       states: {
         idle: {
           on: {
-            PRESS_DOWN: {
+            "TRIGGER.PRESS_DOWN": {
               target: "before:spin",
               actions: ["focusInput", "invokeOnFocus", "setHint"]
             },
-            PRESS_DOWN_SCRUBBER: {
+            "SCRUBBER.PRESS_DOWN": {
               target: "scrubbing",
               actions: ["focusInput", "invokeOnFocus", "setHint", "setCursorPoint"]
             },
-            FOCUS: {
+            "INPUT.FOCUS": {
               target: "focused",
               actions: ["focusInput", "invokeOnFocus"]
             }
@@ -436,45 +487,46 @@ function machine(userContext) {
           entry: "focusInput",
           activities: "attachWheelListener",
           on: {
-            PRESS_DOWN: {
+            "TRIGGER.PRESS_DOWN": {
               target: "before:spin",
               actions: ["focusInput", "setHint"]
             },
-            PRESS_DOWN_SCRUBBER: {
+            "SCRUBBER.PRESS_DOWN": {
               target: "scrubbing",
               actions: ["focusInput", "setHint", "setCursorPoint"]
             },
-            ARROW_UP: {
+            "INPUT.ARROW_UP": {
               actions: "increment"
             },
-            ARROW_DOWN: {
+            "INPUT.ARROW_DOWN": {
               actions: "decrement"
             },
-            HOME: {
-              actions: "setToMin"
+            "INPUT.HOME": {
+              actions: "decrementToMin"
             },
-            END: {
-              actions: "setToMax"
+            "INPUT.END": {
+              actions: "incrementToMax"
             },
-            CHANGE: {
+            "INPUT.CHANGE": {
               actions: ["setValue", "setHint"]
             },
-            BLUR: [
-              {
-                guard: "isInvalidExponential",
-                target: "idle",
-                actions: ["clearValue", "clearHint", "invokeOnBlur"]
-              },
+            "INPUT.COMMIT": [
               {
-                guard: and("clampOnBlur", not("isInRange"), not("isEmptyValue")),
+                guard: and("clampValueOnBlur", not("isInRange")),
                 target: "idle",
-                actions: ["clampValue", "clearHint", "invokeOnBlur"]
+                actions: ["clampValue", "syncInputElement", "clearHint", "invokeOnBlur"]
               },
               {
                 target: "idle",
-                actions: ["roundValue", "invokeOnBlur"]
+                actions: ["syncInputElement", "invokeOnBlur"]
               }
-            ]
+            ],
+            "INPUT.COMPOSITION_START": {
+              actions: "setComposing"
+            },
+            "INPUT.COMPOSITION_END": {
+              actions: "clearComposing"
+            }
           }
         },
         "before:spin": {
@@ -491,7 +543,7 @@ function machine(userContext) {
             }
           },
           on: {
-            PRESS_UP: {
+            "TRIGGER.PRESS_UP": {
               target: "focused",
               actions: "clearHint"
             }
@@ -513,7 +565,7 @@ function machine(userContext) {
             }
           ],
           on: {
-            PRESS_UP: {
+            "TRIGGER.PRESS_UP": {
               target: "focused",
               actions: "clearHint"
             }
@@ -524,8 +576,8 @@ function machine(userContext) {
           exit: "clearCursorPoint",
           activities: ["activatePointerLock", "trackMousemove", "setupVirtualCursor", "preventTextSelection"],
           on: {
-            POINTER_UP_SCRUBBER: "focused",
-            POINTER_MOVE_SCRUBBER: [
+            "SCRUBBER.POINTER_UP": "focused",
+            "SCRUBBER.POINTER_MOVE": [
               {
                 guard: "isIncrementHint",
                 actions: ["increment", "setCursorPoint"]
@@ -545,17 +597,26 @@ function machine(userContext) {
         CHANGE_DELAY: 300
       },
       guards: {
-        clampOnBlur: (ctx2) => !!ctx2.clampValueOnBlur,
+        clampValueOnBlur: (ctx2) => ctx2.clampValueOnBlur,
         isAtMin: (ctx2) => ctx2.isAtMin,
         spinOnPress: (ctx2) => !!ctx2.spinOnPress,
         isAtMax: (ctx2) => ctx2.isAtMax,
         isInRange: (ctx2) => !ctx2.isOutOfRange,
         isDecrementHint: (ctx2, evt) => (evt.hint ?? ctx2.hint) === "decrement",
-        isEmptyValue: (ctx2) => ctx2.isValueEmpty,
-        isIncrementHint: (ctx2, evt) => (evt.hint ?? ctx2.hint) === "increment",
-        isInvalidExponential: (ctx2) => ctx2.value.toString().startsWith("e")
+        isIncrementHint: (ctx2, evt) => (evt.hint ?? ctx2.hint) === "increment"
       },
       activities: {
+        trackFormControl(ctx2, _evt, { initialContext }) {
+          const inputEl = dom.getInputEl(ctx2);
+          return trackFormControl(inputEl, {
+            onFieldsetDisabledChange(disabled) {
+              ctx2.fieldsetDisabled = disabled;
+            },
+            onFormReset() {
+              set.value(ctx2, initialContext.value);
+            }
+          });
+        },
         setupVirtualCursor(ctx2) {
           return dom.setupVirtualCursor(ctx2);
         },
@@ -565,26 +626,23 @@ function machine(userContext) {
         trackButtonDisabled(ctx2, _evt, { send }) {
           const btn = dom.getPressedTriggerEl(ctx2, ctx2.hint);
           return observeAttributes(btn, ["disabled"], () => {
-            send("PRESS_UP");
+            send({ type: "TRIGGER.PRESS_UP", src: "attr" });
           });
         },
         attachWheelListener(ctx2, _evt, { send }) {
-          const input = dom.getInputEl(ctx2);
-          if (!input)
+          const inputEl = dom.getInputEl(ctx2);
+          if (!inputEl || !dom.isActiveElement(ctx2, inputEl) || !ctx2.allowMouseWheel)
             return;
           function onWheel(event) {
-            const isInputFocused = dom.getDoc(ctx2).activeElement === input;
-            if (!ctx2.allowMouseWheel || !isInputFocused)
-              return;
             event.preventDefault();
             const dir = Math.sign(event.deltaY) * -1;
             if (dir === 1) {
-              send("INCREMENT");
+              send("VALUE.INCREMENT");
             } else if (dir === -1) {
-              send("DECREMENT");
+              send("VALUE.DECREMENT");
             }
           }
-          return addDomEvent(input, "wheel", onWheel, { passive: false });
+          return addDomEvent(inputEl, "wheel", onWheel, { passive: false });
         },
         activatePointerLock(ctx2) {
           if (isSafari2())
@@ -600,13 +658,13 @@ function machine(userContext) {
             if (!value.hint)
               return;
             send({
-              type: "POINTER_MOVE_SCRUBBER",
+              type: "SCRUBBER.POINTER_MOVE",
               hint: value.hint,
               point: value.point
             });
           }
           function onMouseup() {
-            send("POINTER_UP_SCRUBBER");
+            send("SCRUBBER.POINTER_UP");
           }
           return callAll(
             addDomEvent(doc, "mousemove", onMousemove, false),
@@ -619,37 +677,34 @@ function machine(userContext) {
           if (!ctx2.focusInputOnChange)
             return;
           const inputEl = dom.getInputEl(ctx2);
-          raf(() => {
-            inputEl?.focus();
-          });
+          if (dom.isActiveElement(ctx2, inputEl))
+            return;
+          raf(() => inputEl?.focus({ preventScroll: true }));
         },
         increment(ctx2, evt) {
-          set.value(ctx2, utils.increment(ctx2, evt.step));
+          const nextValue = increment(ctx2.value, evt.step ?? ctx2.step);
+          set.value(ctx2, String(clamp(nextValue, ctx2)));
         },
         decrement(ctx2, evt) {
-          set.value(ctx2, utils.decrement(ctx2, evt.step));
+          const nextValue = decrement(ctx2.value, evt.step ?? ctx2.step);
+          set.value(ctx2, String(clamp(nextValue, ctx2)));
         },
         clampValue(ctx2) {
-          set.value(ctx2, utils.clamp(ctx2));
-        },
-        roundValue(ctx2) {
-          if (ctx2.value === "")
-            return;
-          set.value(ctx2, utils.round(ctx2));
+          const nextValue = clamp(ctx2.value, ctx2);
+          set.value(ctx2, String(nextValue));
         },
         setValue(ctx2, evt) {
-          let value = evt.target?.value ?? evt.value;
-          value = utils.sanitize(ctx2, utils.parse(ctx2, value.toString()));
+          const value = evt.target?.value ?? evt.value;
           set.value(ctx2, value);
         },
         clearValue(ctx2) {
           set.value(ctx2, "");
         },
-        setToMax(ctx2) {
-          set.value(ctx2, ctx2.max.toString());
+        incrementToMax(ctx2) {
+          set.value(ctx2, String(ctx2.max));
         },
-        setToMin(ctx2) {
-          set.value(ctx2, ctx2.min.toString());
+        decrementToMin(ctx2) {
+          set.value(ctx2, String(ctx2.min));
         },
         setHint(ctx2, evt) {
           ctx2.hint = evt.hint;
@@ -660,15 +715,9 @@ function machine(userContext) {
         setHintToSet(ctx2) {
           ctx2.hint = "set";
         },
-        invokeOnFocus(ctx2, evt) {
-          const srcElement = match(evt.type, {
-            PRESS_DOWN: dom.getPressedTriggerEl(ctx2, evt.hint),
-            FOCUS: dom.getInputEl(ctx2),
-            PRESS_DOWN_SCRUBBER: dom.getScrubberEl(ctx2)
-          });
+        invokeOnFocus(ctx2) {
           ctx2.onFocusChange?.({
             focused: true,
-            srcElement,
             value: ctx2.formattedValue,
             valueAsNumber: ctx2.valueAsNumber
           });
@@ -690,16 +739,20 @@ function machine(userContext) {
             valueAsNumber: ctx2.valueAsNumber
           });
         },
-        syncInputElement(ctx2) {
+        syncInputElement(ctx2, evt) {
           const inputEl = dom.getInputEl(ctx2);
-          dom.setValue(inputEl, ctx2.formattedValue);
+          const inputValue = evt.type.endsWith("CHANGE") ? ctx2.value : ctx2.formattedValue;
+          const sel = recordCursor(inputEl);
+          dom.setValue(inputEl, inputValue);
+          raf(() => {
+            restoreCursor(inputEl, sel);
+          });
         },
         syncInputValue(ctx2) {
           const inputEl = dom.getInputEl(ctx2);
           if (!inputEl || inputEl.value == ctx2.value)
             return;
-          const value = utils.parse(ctx2, inputEl.value);
-          set.value(ctx2, utils.sanitize(ctx2, value));
+          set.value(ctx2, ctx2.formattedValue);
         },
         setCursorPoint(ctx2, evt) {
           ctx2.scrubberCursorPoint = evt.point;
@@ -708,19 +761,50 @@ function machine(userContext) {
           ctx2.scrubberCursorPoint = null;
         },
         setVirtualCursorPosition(ctx2) {
-          const cursor = dom.getCursorEl(ctx2);
-          if (!cursor || !ctx2.scrubberCursorPoint)
+          const cursorEl = dom.getCursorEl(ctx2);
+          if (!cursorEl || !ctx2.scrubberCursorPoint)
             return;
           const { x, y } = ctx2.scrubberCursorPoint;
-          cursor.style.transform = `translate3d(${x}px, ${y}px, 0px)`;
+          cursorEl.style.transform = `translate3d(${x}px, ${y}px, 0px)`;
+        },
+        setComposing(ctx2) {
+          ctx2.composing = true;
+        },
+        clearComposing(ctx2) {
+          ctx2.composing = false;
+        },
+        setFormatterAndParser(ctx2) {
+          if (!ctx2.locale)
+            return;
+          ctx2.formatter = createFormatter(ctx2.locale, ctx2.formatOptions);
+          ctx2.parser = createParser(ctx2.locale, ctx2.formatOptions);
         }
+      },
+      compareFns: {
+        formatOptions: (a, b) => isEqual(a, b)
       }
     }
   );
 }
+var defaultFormatOptions = {
+  style: "decimal",
+  minimumFractionDigits: 0,
+  maximumFractionDigits: 20
+};
+var createFormatter = (locale, options = {}) => {
+  const formatOptions = Object.assign({}, defaultFormatOptions, options);
+  return ref(new Intl.NumberFormat(locale, formatOptions));
+};
+var createParser = (locale, options = {}) => {
+  const formatOptions = Object.assign({}, defaultFormatOptions, options);
+  return ref(new NumberParser(locale, formatOptions));
+};
 var invoke = {
   onChange: (ctx) => {
-    ctx.onValueChange?.({ value: ctx.value, valueAsNumber: ctx.valueAsNumber });
+    ctx.onValueChange?.({
+      value: ctx.value,
+      valueAsNumber: ctx.valueAsNumber
+    });
   }
 };
 var set = {