@zag-js/number-input 0.0.0-20220802150625

package/dist/index.mjs

@@ -0,0 +1,970 @@
+// ../../utilities/dom/dist/index.mjs
+var dataAttr = (guard) => {
+  return guard ? "" : void 0;
+};
+var ariaAttr = (guard) => {
+  return guard ? "true" : void 0;
+};
+var MAX_Z_INDEX = 2147483647;
+var runIfFn = (v, ...a) => {
+  const res = typeof v === "function" ? v(...a) : v;
+  return res ?? void 0;
+};
+var callAll = (...fns) => (...a) => {
+  fns.forEach(function(fn) {
+    fn == null ? void 0 : fn(...a);
+  });
+};
+var isArray = (v) => Array.isArray(v);
+var isObject = (v) => !(v == null || typeof v !== "object" || isArray(v));
+var hasProp = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+var isDom = () => typeof window !== "undefined";
+function getPlatform() {
+  const agent = navigator.userAgentData;
+  return (agent == null ? void 0 : agent.platform) ?? navigator.platform;
+}
+var pt = (v) => isDom() && v.test(getPlatform());
+var vn = (v) => isDom() && v.test(navigator.vendor);
+var isTouchDevice = () => isDom() && !!navigator.maxTouchPoints;
+var isMac = () => pt(/^Mac/) && !isTouchDevice;
+var isSafari = () => isApple() && vn(/apple/i);
+var isApple = () => pt(/mac|iphone|ipad|ipod/i);
+var isIos = () => isApple() && !isMac();
+function isDocument(el) {
+  return el.nodeType === Node.DOCUMENT_NODE;
+}
+function isWindow(value) {
+  return (value == null ? void 0 : value.toString()) === "[object Window]";
+}
+function getDocument(el) {
+  if (isWindow(el))
+    return el.document;
+  if (isDocument(el))
+    return el;
+  return (el == null ? void 0 : el.ownerDocument) ?? document;
+}
+function defineDomHelpers(helpers) {
+  const dom2 = {
+    getRootNode: (ctx) => {
+      var _a;
+      return ((_a = ctx.getRootNode) == null ? void 0 : _a.call(ctx)) ?? document;
+    },
+    getDoc: (ctx) => getDocument(dom2.getRootNode(ctx)),
+    getWin: (ctx) => dom2.getDoc(ctx).defaultView ?? window,
+    getActiveElement: (ctx) => dom2.getDoc(ctx).activeElement,
+    getById: (ctx, id) => dom2.getRootNode(ctx).getElementById(id)
+  };
+  return {
+    ...dom2,
+    ...helpers
+  };
+}
+function getNativeEvent(e) {
+  return e.nativeEvent ?? e;
+}
+var supportsPointerEvent = () => isDom() && window.onpointerdown === null;
+var isTouchEvent = (v) => isObject(v) && hasProp(v, "touches");
+var isLeftClick = (v) => v.button === 0;
+var isModifiedEvent = (v) => v.ctrlKey || v.altKey || v.metaKey;
+function observeAttributes(node, attributes, fn) {
+  if (!node)
+    return;
+  const attrs = Array.isArray(attributes) ? attributes : [attributes];
+  const win = node.ownerDocument.defaultView || window;
+  const obs = new win.MutationObserver((changes) => {
+    for (const change of changes) {
+      if (change.type === "attributes" && change.attributeName && attrs.includes(change.attributeName)) {
+        fn(change);
+      }
+    }
+  });
+  obs.observe(node, { attributes: true, attributeFilter: attrs });
+  return () => obs.disconnect();
+}
+var fallback = {
+  pageX: 0,
+  pageY: 0,
+  clientX: 0,
+  clientY: 0
+};
+function getEventPoint(event, type = "page") {
+  const point = isTouchEvent(event) ? event.touches[0] ?? event.changedTouches[0] ?? fallback : event;
+  return { x: point[`${type}X`], y: point[`${type}Y`] };
+}
+var PAGE_KEYS = /* @__PURE__ */ new Set(["PageUp", "PageDown"]);
+var ARROW_KEYS = /* @__PURE__ */ new Set(["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"]);
+function getEventStep(event) {
+  if (event.ctrlKey || event.metaKey) {
+    return 0.1;
+  } else {
+    const isPageKey = PAGE_KEYS.has(event.key);
+    const isSkipKey = isPageKey || event.shiftKey && ARROW_KEYS.has(event.key);
+    return isSkipKey ? 10 : 1;
+  }
+}
+var isRef = (v) => hasProp(v, "current");
+function addDomEvent(target, eventName, handler, options) {
+  const node = isRef(target) ? target.current : runIfFn(target);
+  node == null ? void 0 : node.addEventListener(eventName, handler, options);
+  return () => {
+    node == null ? void 0 : node.removeEventListener(eventName, handler, options);
+  };
+}
+function raf(fn) {
+  const id = globalThis.requestAnimationFrame(fn);
+  return function cleanup() {
+    globalThis.cancelAnimationFrame(id);
+  };
+}
+function addPointerlockChangeListener(doc, fn) {
+  return addDomEvent(doc, "pointerlockchange", fn, false);
+}
+function addPointerlockErrorListener(doc, fn) {
+  doc.addEventListener("pointerlockerror", fn, false);
+  return function cleanup() {
+    doc.removeEventListener("pointerlockerror", fn, false);
+  };
+}
+function requestPointerLock(doc, handlers = {}) {
+  const { onPointerLock, onPointerUnlock } = handlers;
+  const body = doc.body;
+  const supported = "pointerLockElement" in doc || "mozPointerLockElement" in doc;
+  const locked = !!doc.pointerLockElement;
+  function onPointerChange() {
+    if (locked)
+      onPointerLock == null ? void 0 : onPointerLock();
+    else
+      onPointerUnlock == null ? void 0 : onPointerUnlock();
+  }
+  function onPointerError(event) {
+    if (locked)
+      onPointerUnlock == null ? void 0 : onPointerUnlock();
+    console.error("PointerLock error occured:", event);
+    exit();
+  }
+  function exit() {
+    doc.exitPointerLock();
+  }
+  if (!supported)
+    return;
+  body.requestPointerLock();
+  const cleanup = callAll(
+    addPointerlockChangeListener(doc, onPointerChange),
+    addPointerlockErrorListener(doc, onPointerError)
+  );
+  return function dispose() {
+    if (!supported)
+      return;
+    cleanup();
+    exit();
+  };
+}
+
+// ../../utilities/number/dist/index.mjs
+function wrap(num, max) {
+  return (num % max + max) % max;
+}
+function roundToDevicePixel(num) {
+  if (typeof window === "undefined")
+    return Math.round(num);
+  const dp = window.devicePixelRatio;
+  return Math.floor(num * dp + 0.5) / dp;
+}
+function clamp(v, o) {
+  return Math.min(Math.max(valueOf(v), o.min), o.max);
+}
+function countDecimals(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  let e = 1, p = 0;
+  while (Math.round(value * e) / e !== value) {
+    e *= 10;
+    p += 1;
+  }
+  return p;
+}
+var increment = (v, s) => decimalOperation(valueOf(v), "+", s);
+var decrement = (v, s) => decimalOperation(valueOf(v), "-", s);
+function valueOf(v) {
+  if (typeof v === "number")
+    return v;
+  const num = parseFloat(v.toString().replace(/[^\w.-]+/g, ""));
+  return !Number.isNaN(num) ? num : 0;
+}
+function formatDecimal(v, o) {
+  return new Intl.NumberFormat("en-US", {
+    useGrouping: false,
+    style: "decimal",
+    minimumFractionDigits: o.minFractionDigits,
+    maximumFractionDigits: o.maxFractionDigits
+  }).format(valueOf(v));
+}
+function isAtMax(v, o) {
+  const val = valueOf(v);
+  return val >= o.max;
+}
+function isAtMin(v, o) {
+  const val = valueOf(v);
+  return val <= o.min;
+}
+function isWithinRange(v, o) {
+  const val = valueOf(v);
+  return val >= o.min && val <= o.max;
+}
+function decimalOperation(a, op, b) {
+  let result = op === "+" ? a + b : a - b;
+  if (a % 1 !== 0 || b % 1 !== 0) {
+    const multiplier = 10 ** Math.max(countDecimals(a), countDecimals(b));
+    a = Math.round(a * multiplier);
+    b = Math.round(b * multiplier);
+    result = op === "+" ? a + b : a - b;
+    result /= multiplier;
+  }
+  return result;
+}
+var nf = new Intl.NumberFormat("en-US", { style: "decimal", maximumFractionDigits: 20 });
+
+// src/number-input.dom.ts
+var dom = defineDomHelpers({
+  getRootId: (ctx) => {
+    var _a;
+    return ((_a = ctx.ids) == null ? void 0 : _a.root) ?? `number-input:${ctx.id}`;
+  },
+  getInputId: (ctx) => {
+    var _a;
+    return ((_a = ctx.ids) == null ? void 0 : _a.input) ?? `number-input:${ctx.id}:input`;
+  },
+  getIncButtonId: (ctx) => {
+    var _a;
+    return ((_a = ctx.ids) == null ? void 0 : _a.incBtn) ?? `number-input:${ctx.id}:inc-btn`;
+  },
+  getDecButtonId: (ctx) => {
+    var _a;
+    return ((_a = ctx.ids) == null ? void 0 : _a.decBtn) ?? `number-input:${ctx.id}:dec-btn`;
+  },
+  getScrubberId: (ctx) => {
+    var _a;
+    return ((_a = ctx.ids) == null ? void 0 : _a.scrubber) ?? `number-input:${ctx.id}:scrubber`;
+  },
+  getCursorId: (ctx) => `number-input:${ctx.id}:cursor`,
+  getLabelId: (ctx) => {
+    var _a;
+    return ((_a = ctx.ids) == null ? void 0 : _a.label) ?? `number-input:${ctx.id}:label`;
+  },
+  getInputEl: (ctx) => dom.getById(ctx, dom.getInputId(ctx)),
+  getIncButtonEl: (ctx) => dom.getById(ctx, dom.getIncButtonId(ctx)),
+  getDecButtonEl: (ctx) => dom.getById(ctx, dom.getDecButtonId(ctx)),
+  getScrubberEl: (ctx) => dom.getById(ctx, dom.getScrubberId(ctx)),
+  getCursorEl: (ctx) => dom.getDoc(ctx).getElementById(dom.getCursorId(ctx)),
+  getActiveButton: (ctx, hint = ctx.hint) => {
+    let btnEl = null;
+    if (hint === "increment") {
+      btnEl = dom.getIncButtonEl(ctx);
+    }
+    if (hint === "decrement") {
+      btnEl = dom.getDecButtonEl(ctx);
+    }
+    return btnEl;
+  },
+  setupVirtualCursor(ctx) {
+    if (isSafari() || !supportsPointerEvent())
+      return;
+    dom.createVirtualCursor(ctx);
+    return () => {
+      var _a;
+      (_a = dom.getCursorEl(ctx)) == null ? void 0 : _a.remove();
+    };
+  },
+  preventTextSelection(ctx) {
+    const doc = dom.getDoc(ctx);
+    const html = doc.documentElement;
+    const body = doc.body;
+    body.style.pointerEvents = "none";
+    html.style.userSelect = "none";
+    html.style.cursor = "ew-resize";
+    return () => {
+      body.style.pointerEvents = "";
+      html.style.userSelect = "";
+      html.style.cursor = "";
+      if (!html.style.length) {
+        html.removeAttribute("style");
+      }
+      if (!body.style.length) {
+        body.removeAttribute("style");
+      }
+    };
+  },
+  getMousementValue(ctx, event) {
+    const x = roundToDevicePixel(event.movementX);
+    const y = roundToDevicePixel(event.movementY);
+    let hint = x > 0 ? "increment" : x < 0 ? "decrement" : null;
+    if (ctx.isRtl && hint === "increment")
+      hint = "decrement";
+    if (ctx.isRtl && hint === "decrement")
+      hint = "increment";
+    const point = {
+      x: ctx.scrubberCursorPoint.x + x,
+      y: ctx.scrubberCursorPoint.y + y
+    };
+    const win = dom.getWin(ctx);
+    const width = win.innerWidth;
+    const half = roundToDevicePixel(7.5);
+    point.x = wrap(point.x + half, width) - half;
+    return { hint, point };
+  },
+  createVirtualCursor(ctx) {
+    const doc = dom.getDoc(ctx);
+    const el = doc.createElement("div");
+    el.className = "scrubber--cursor";
+    el.id = dom.getCursorId(ctx);
+    Object.assign(el.style, {
+      width: "15px",
+      height: "15px",
+      position: "fixed",
+      pointerEvents: "none",
+      left: "0px",
+      top: "0px",
+      zIndex: MAX_Z_INDEX,
+      transform: ctx.scrubberCursorPoint ? `translate3d(${ctx.scrubberCursorPoint.x}px, ${ctx.scrubberCursorPoint.y}px, 0px)` : void 0,
+      willChange: "transform"
+    });
+    el.innerHTML = `
+        <svg width="46" height="15" style="left: -15.5px; position: absolute; top: 0; filter: drop-shadow(rgba(0, 0, 0, 0.4) 0px 1px 1.1px);">
+          <g transform="translate(2 3)">
+            <path fill-rule="evenodd" d="M 15 4.5L 15 2L 11.5 5.5L 15 9L 15 6.5L 31 6.5L 31 9L 34.5 5.5L 31 2L 31 4.5Z" style="stroke-width: 2px; stroke: white;"></path>
+            <path fill-rule="evenodd" d="M 15 4.5L 15 2L 11.5 5.5L 15 9L 15 6.5L 31 6.5L 31 9L 34.5 5.5L 31 2L 31 4.5Z"></path>
+          </g>
+        </svg>`;
+    doc.body.appendChild(el);
+  }
+});
+
+// src/number-input.utils.ts
+var utils = {
+  isValidNumericEvent: (ctx, event) => {
+    var _a;
+    if (event.key == null)
+      return true;
+    const isModifier = isModifiedEvent(event);
+    const isSingleKey = event.key.length === 1;
+    if (isModifier || !isSingleKey)
+      return true;
+    return ((_a = ctx.validateCharacter) == null ? void 0 : _a.call(ctx, event.key)) ?? utils.isFloatingPoint(event.key);
+  },
+  isFloatingPoint: (v) => /^[Ee0-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) => {
+    var _a;
+    return ((_a = ctx.parse) == null ? void 0 : _a.call(ctx, value)) ?? value;
+  },
+  format: (ctx, value) => {
+    var _a;
+    const _val = value.toString();
+    return ((_a = ctx.format) == null ? void 0 : _a.call(ctx, _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 messages = state.context.messages;
+  return {
+    isFocused,
+    isInvalid,
+    isValueEmpty,
+    value: state.context.formattedValue,
+    valueAsNumber: state.context.valueAsNumber,
+    setValue(value) {
+      send({ type: "SET_VALUE", value: value.toString() });
+    },
+    clearValue() {
+      send("CLEAR_VALUE");
+    },
+    increment() {
+      send("INCREMENT");
+    },
+    decrement() {
+      send("DECREMENT");
+    },
+    setToMax() {
+      send({ type: "SET_VALUE", value: state.context.max });
+    },
+    setToMin() {
+      send({ type: "SET_VALUE", value: state.context.min });
+    },
+    focus() {
+      var _a;
+      (_a = dom.getInputEl(state.context)) == null ? void 0 : _a.focus();
+    },
+    blur() {
+      var _a;
+      (_a = dom.getInputEl(state.context)) == null ? void 0 : _a.blur();
+    },
+    rootProps: normalize.element({
+      id: dom.getRootId(state.context),
+      "data-part": "root",
+      "data-disabled": dataAttr(isDisabled)
+    }),
+    labelProps: normalize.label({
+      "data-part": "label",
+      "data-disabled": dataAttr(isDisabled),
+      "data-invalid": dataAttr(isInvalid),
+      id: dom.getLabelId(state.context),
+      htmlFor: dom.getInputId(state.context)
+    }),
+    groupProps: normalize.element({
+      "data-part": "group",
+      role: "group",
+      "aria-disabled": isDisabled,
+      "data-disabled": dataAttr(isDisabled),
+      "data-invalid": dataAttr(isInvalid),
+      "aria-invalid": ariaAttr(state.context.invalid)
+    }),
+    inputProps: normalize.input({
+      "data-part": "input",
+      name: state.context.name,
+      id: dom.getInputId(state.context),
+      role: "spinbutton",
+      value: state.context.formattedValue,
+      pattern: state.context.pattern,
+      inputMode: state.context.inputMode,
+      "aria-invalid": isInvalid || void 0,
+      "data-invalid": dataAttr(isInvalid),
+      disabled: isDisabled,
+      "data-disabled": dataAttr(isDisabled),
+      readOnly: !!state.context.readonly,
+      autoComplete: "off",
+      autoCorrect: "off",
+      spellCheck: "false",
+      type: "text",
+      "aria-roledescription": !isIos() ? "number field" : void 0,
+      "aria-valuemin": state.context.min,
+      "aria-valuemax": state.context.max,
+      "aria-valuenow": isNaN(state.context.valueAsNumber) ? void 0 : state.context.valueAsNumber,
+      "aria-valuetext": state.context.valueText,
+      onFocus() {
+        send("FOCUS");
+      },
+      onBlur() {
+        send("BLUR");
+      },
+      onChange(event) {
+        const evt = getNativeEvent(event);
+        if (evt.isComposing)
+          return;
+        send({ type: "CHANGE", target: event.currentTarget, hint: "set" });
+      },
+      onKeyDown(event) {
+        const evt = getNativeEvent(event);
+        if (evt.isComposing)
+          return;
+        if (!utils.isValidNumericEvent(state.context, event)) {
+          event.preventDefault();
+        }
+        const step = getEventStep(event) * state.context.step;
+        const keyMap = {
+          ArrowUp() {
+            send({ type: "ARROW_UP", step });
+          },
+          ArrowDown() {
+            send({ type: "ARROW_DOWN", step });
+          },
+          Home() {
+            send("HOME");
+          },
+          End() {
+            send("END");
+          }
+        };
+        const exec = keyMap[event.key];
+        if (exec) {
+          exec(event);
+          event.preventDefault();
+        }
+      }
+    }),
+    decrementButtonProps: normalize.button({
+      "data-part": "spin-button",
+      "data-type": "decrement",
+      id: dom.getDecButtonId(state.context),
+      disabled: isDecrementDisabled,
+      "data-disabled": dataAttr(isDecrementDisabled),
+      "aria-label": messages.decrementLabel,
+      type: "button",
+      tabIndex: -1,
+      "aria-controls": dom.getInputId(state.context),
+      onPointerDown(event) {
+        if (isDecrementDisabled)
+          return;
+        send(isLeftClick(event) ? { type: "PRESS_DOWN", hint: "decrement" } : { type: "FOCUS" });
+        event.preventDefault();
+      },
+      onPointerUp() {
+        send({ type: "PRESS_UP", hint: "decrement" });
+      },
+      onPointerLeave() {
+        if (isDecrementDisabled)
+          return;
+        send({ type: "PRESS_UP", hint: "decrement" });
+      }
+    }),
+    incrementButtonProps: normalize.button({
+      "data-part": "spin-button",
+      "data-type": "increment",
+      id: dom.getIncButtonId(state.context),
+      disabled: isIncrementDisabled,
+      "data-disabled": dataAttr(isIncrementDisabled),
+      "aria-label": messages.incrementLabel,
+      type: "button",
+      tabIndex: -1,
+      "aria-controls": dom.getInputId(state.context),
+      onPointerDown(event) {
+        if (isIncrementDisabled)
+          return;
+        send(isLeftClick(event) ? { type: "PRESS_DOWN", hint: "increment" } : { type: "FOCUS" });
+        event.preventDefault();
+      },
+      onPointerUp() {
+        send({ type: "PRESS_UP", hint: "increment" });
+      },
+      onPointerLeave() {
+        send({ type: "PRESS_UP", hint: "increment" });
+      }
+    }),
+    scrubberProps: normalize.element({
+      "data-disabled": dataAttr(isDisabled),
+      "data-part": "scrubber",
+      id: dom.getScrubberId(state.context),
+      role: "presentation",
+      onMouseDown(event) {
+        if (isDisabled)
+          return;
+        const evt = getNativeEvent(event);
+        event.preventDefault();
+        const point = getEventPoint(evt);
+        point.x = point.x - roundToDevicePixel(7.5);
+        point.y = point.y - roundToDevicePixel(7.5);
+        send({ type: "PRESS_DOWN_SCRUBBER", point });
+      },
+      style: {
+        cursor: isDisabled ? void 0 : "ew-resize"
+      }
+    })
+  };
+}
+
+// src/number-input.machine.ts
+import { choose, createMachine, guards } from "@zag-js/core";
+
+// ../../utilities/core/dist/index.mjs
+var callAll2 = (...fns) => (...a) => {
+  fns.forEach(function(fn) {
+    fn == null ? void 0 : fn(...a);
+  });
+};
+
+// src/number-input.machine.ts
+var { not, and } = guards;
+function machine(ctx) {
+  return createMachine(
+    {
+      id: "number-input",
+      initial: "unknown",
+      context: {
+        dir: "ltr",
+        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,
+        messages: {
+          incrementLabel: "increment value",
+          decrementLabel: "decrease value",
+          ...ctx.messages
+        }
+      },
+      computed: {
+        isRtl: (ctx2) => ctx2.dir === "rtl",
+        valueAsNumber: (ctx2) => valueOf(ctx2.value),
+        isAtMin: (ctx2) => isAtMin(ctx2.value, ctx2),
+        isAtMax: (ctx2) => isAtMax(ctx2.value, ctx2),
+        isOutOfRange: (ctx2) => !isWithinRange(ctx2.value, ctx2),
+        isValueEmpty: (ctx2) => ctx2.value === "",
+        canIncrement: (ctx2) => ctx2.allowOverflow || !ctx2.isAtMax,
+        canDecrement: (ctx2) => ctx2.allowOverflow || !ctx2.isAtMin,
+        valueText: (ctx2) => {
+          var _a, _b;
+          return (_b = (_a = ctx2.messages).valueText) == null ? void 0 : _b.call(_a, ctx2.value);
+        },
+        formattedValue: (ctx2) => {
+          var _a;
+          return ((_a = ctx2.format) == null ? void 0 : _a.call(ctx2, ctx2.value).toString()) ?? ctx2.value;
+        }
+      },
+      watch: {
+        value: ["invokeOnChange"],
+        isOutOfRange: ["invokeOnInvalid"],
+        scrubberCursorPoint: ["setVirtualCursorPosition"]
+      },
+      on: {
+        SET_VALUE: {
+          actions: ["setValue", "setHintToSet"]
+        },
+        CLEAR_VALUE: {
+          actions: ["clearValue"]
+        },
+        INCREMENT: {
+          actions: ["increment"]
+        },
+        DECREMENT: {
+          actions: ["decrement"]
+        }
+      },
+      states: {
+        unknown: {
+          on: {
+            SETUP: {
+              target: "idle",
+              actions: "syncInputValue"
+            }
+          }
+        },
+        idle: {
+          exit: "invokeOnFocus",
+          on: {
+            PRESS_DOWN: {
+              target: "before:spin",
+              actions: ["focusInput", "setHint"]
+            },
+            PRESS_DOWN_SCRUBBER: {
+              target: "scrubbing",
+              actions: ["focusInput", "setHint", "setCursorPoint"]
+            },
+            FOCUS: "focused"
+          }
+        },
+        focused: {
+          tags: "focus",
+          entry: "focusInput",
+          activities: "attachWheelListener",
+          on: {
+            PRESS_DOWN: {
+              target: "before:spin",
+              actions: ["focusInput", "setHint"]
+            },
+            PRESS_DOWN_SCRUBBER: {
+              target: "scrubbing",
+              actions: ["focusInput", "setHint", "setCursorPoint"]
+            },
+            ARROW_UP: {
+              actions: "increment"
+            },
+            ARROW_DOWN: {
+              actions: "decrement"
+            },
+            HOME: {
+              actions: "setToMin"
+            },
+            END: {
+              actions: "setToMax"
+            },
+            CHANGE: {
+              actions: ["setValue", "setHint"]
+            },
+            BLUR: [
+              {
+                guard: "isInvalidExponential",
+                target: "idle",
+                actions: ["clearValue", "clearHint", "invokeOnBlur"]
+              },
+              {
+                guard: and("clampOnBlur", not("isInRange"), not("isEmptyValue")),
+                target: "idle",
+                actions: ["clampValue", "clearHint", "invokeOnBlur"]
+              },
+              {
+                target: "idle",
+                actions: ["roundValue", "invokeOnBlur"]
+              }
+            ]
+          }
+        },
+        "before:spin": {
+          tags: "focus",
+          activities: "trackButtonDisabled",
+          entry: choose([
+            { guard: "isIncrementHint", actions: "increment" },
+            { guard: "isDecrementHint", actions: "decrement" }
+          ]),
+          after: {
+            CHANGE_DELAY: {
+              target: "spinning",
+              guard: and("isInRange", "spinOnPress")
+            }
+          },
+          on: {
+            PRESS_UP: {
+              target: "focused",
+              actions: "clearHint"
+            }
+          }
+        },
+        spinning: {
+          tags: "focus",
+          activities: "trackButtonDisabled",
+          every: [
+            {
+              delay: "CHANGE_INTERVAL",
+              guard: and(not("isAtMin"), "isIncrementHint"),
+              actions: "increment"
+            },
+            {
+              delay: "CHANGE_INTERVAL",
+              guard: and(not("isAtMax"), "isDecrementHint"),
+              actions: "decrement"
+            }
+          ],
+          on: {
+            PRESS_UP: {
+              target: "focused",
+              actions: "clearHint"
+            }
+          }
+        },
+        scrubbing: {
+          tags: "focus",
+          exit: "clearCursorPoint",
+          activities: ["activatePointerLock", "trackMousemove", "setupVirtualCursor", "preventTextSelection"],
+          on: {
+            POINTER_UP_SCRUBBER: "focused",
+            POINTER_MOVE_SCRUBBER: [
+              {
+                guard: "isIncrementHint",
+                actions: ["increment", "setCursorPoint"]
+              },
+              {
+                guard: "isDecrementHint",
+                actions: ["decrement", "setCursorPoint"]
+              }
+            ]
+          }
+        }
+      }
+    },
+    {
+      delays: {
+        CHANGE_INTERVAL: 50,
+        CHANGE_DELAY: 300
+      },
+      guards: {
+        clampOnBlur: (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")
+      },
+      activities: {
+        setupVirtualCursor(ctx2) {
+          return dom.setupVirtualCursor(ctx2);
+        },
+        preventTextSelection(ctx2) {
+          return dom.preventTextSelection(ctx2);
+        },
+        trackButtonDisabled(ctx2, _evt, { send }) {
+          const btn = dom.getActiveButton(ctx2, ctx2.hint);
+          return observeAttributes(btn, "disabled", () => send("PRESS_UP"));
+        },
+        attachWheelListener(ctx2, _evt, { send }) {
+          const input = dom.getInputEl(ctx2);
+          if (!input)
+            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");
+            } else if (dir === -1) {
+              send("DECREMENT");
+            }
+          }
+          return addDomEvent(input, "wheel", onWheel, { passive: false });
+        },
+        activatePointerLock(ctx2) {
+          if (isSafari() || !supportsPointerEvent())
+            return;
+          return requestPointerLock(dom.getDoc(ctx2));
+        },
+        trackMousemove(ctx2, _evt, { send }) {
+          const doc = dom.getDoc(ctx2);
+          function onMousemove(event) {
+            if (!ctx2.scrubberCursorPoint)
+              return;
+            const value = dom.getMousementValue(ctx2, event);
+            if (!value.hint)
+              return;
+            send({
+              type: "POINTER_MOVE_SCRUBBER",
+              hint: value.hint,
+              point: value.point
+            });
+          }
+          function onMouseup() {
+            send("POINTER_UP_SCRUBBER");
+          }
+          return callAll2(
+            addDomEvent(doc, "mousemove", onMousemove, false),
+            addDomEvent(doc, "mouseup", onMouseup, false)
+          );
+        }
+      },
+      actions: {
+        focusInput(ctx2) {
+          if (!ctx2.focusInputOnChange)
+            return;
+          const input = dom.getInputEl(ctx2);
+          raf(() => input == null ? void 0 : input.focus());
+        },
+        increment(ctx2, evt) {
+          ctx2.value = utils.increment(ctx2, evt.step);
+        },
+        decrement(ctx2, evt) {
+          ctx2.value = utils.decrement(ctx2, evt.step);
+        },
+        clampValue(ctx2) {
+          ctx2.value = utils.clamp(ctx2);
+        },
+        roundValue(ctx2) {
+          if (ctx2.value !== "") {
+            ctx2.value = utils.round(ctx2);
+          }
+        },
+        setValue(ctx2, evt) {
+          var _a;
+          const value = ((_a = evt.target) == null ? void 0 : _a.value) ?? evt.value;
+          ctx2.value = utils.sanitize(ctx2, utils.parse(ctx2, value.toString()));
+        },
+        clearValue(ctx2) {
+          ctx2.value = "";
+        },
+        setToMax(ctx2) {
+          ctx2.value = ctx2.max.toString();
+        },
+        setToMin(ctx2) {
+          ctx2.value = ctx2.min.toString();
+        },
+        setHint(ctx2, evt) {
+          ctx2.hint = evt.hint;
+        },
+        clearHint(ctx2) {
+          ctx2.hint = null;
+        },
+        setHintToSet(ctx2) {
+          ctx2.hint = "set";
+        },
+        invokeOnChange(ctx2) {
+          var _a;
+          (_a = ctx2.onChange) == null ? void 0 : _a.call(ctx2, {
+            value: ctx2.value,
+            valueAsNumber: ctx2.valueAsNumber
+          });
+        },
+        invokeOnFocus(ctx2, evt) {
+          var _a;
+          let srcElement = null;
+          if (evt.type === "PRESS_DOWN") {
+            srcElement = dom.getActiveButton(ctx2, evt.hint);
+          } else if (evt.type === "FOCUS") {
+            srcElement = dom.getInputEl(ctx2);
+          } else if (evt.type === "PRESS_DOWN_SCRUBBER") {
+            srcElement = dom.getScrubberEl(ctx2);
+          }
+          (_a = ctx2.onFocus) == null ? void 0 : _a.call(ctx2, {
+            value: ctx2.value,
+            valueAsNumber: ctx2.valueAsNumber,
+            srcElement
+          });
+        },
+        invokeOnBlur(ctx2) {
+          var _a;
+          (_a = ctx2.onBlur) == null ? void 0 : _a.call(ctx2, {
+            value: ctx2.value,
+            valueAsNumber: ctx2.valueAsNumber
+          });
+        },
+        invokeOnInvalid(ctx2) {
+          var _a;
+          if (!ctx2.isOutOfRange)
+            return;
+          const reason = ctx2.valueAsNumber > ctx2.max ? "rangeOverflow" : "rangeUnderflow";
+          (_a = ctx2.onInvalid) == null ? void 0 : _a.call(ctx2, {
+            reason,
+            value: ctx2.formattedValue,
+            valueAsNumber: ctx2.valueAsNumber
+          });
+        },
+        syncInputValue(ctx2) {
+          const input = dom.getInputEl(ctx2);
+          if (!input || input.value == ctx2.value)
+            return;
+          const value = utils.parse(ctx2, input.value);
+          ctx2.value = utils.sanitize(ctx2, value);
+        },
+        setCursorPoint(ctx2, evt) {
+          ctx2.scrubberCursorPoint = evt.point;
+        },
+        clearCursorPoint(ctx2) {
+          ctx2.scrubberCursorPoint = null;
+        },
+        setVirtualCursorPosition(ctx2) {
+          const cursor = dom.getCursorEl(ctx2);
+          if (!cursor || !ctx2.scrubberCursorPoint)
+            return;
+          const { x, y } = ctx2.scrubberCursorPoint;
+          cursor.style.transform = `translate3d(${x}px, ${y}px, 0px)`;
+        }
+      },
+      hookSync: true
+    }
+  );
+}
+export {
+  connect,
+  machine
+};