@bitrise/bitkit-v2 0.3.53 → 0.3.55

package/dist/node_modules/@zag-js/number-input/dist/index.js

@@ -0,0 +1,752 @@
+import { createAnatomy as $ } from "../../anatomy/dist/index.js";
+import { dataAttr as l, isLeftClick as O, getEventPoint as q, getWindow as X, ariaAttr as A, isComposingEvent as Y, getEventStep as Z, isModifierKey as x, raf as D, setElementValue as K, addDomEvent as C, isSafari as B, requestPointerLock as j, observeAttributes as J, trackFormControl as Q, MAX_Z_INDEX as z } from "../../dom-query/dist/index.js";
+import { roundToDpr as R, isValueAtMax as ee, isValueAtMin as te, clampValue as y, decrementValue as re, incrementValue as ne, callAll as ae, isValueWithinRange as ie, wrap as se } from "../../utils/dist/index.js";
+import { setup as oe, memo as U } from "../../core/dist/index.js";
+import { NumberParser as ue } from "../../../@internationalized/number/dist/NumberParser.js";
+import { createProps as le } from "../../types/dist/index.js";
+var ce = $("numberInput").parts(
+  "root",
+  "label",
+  "input",
+  "control",
+  "valueText",
+  "incrementTrigger",
+  "decrementTrigger",
+  "scrubber"
+), v = ce.build(), de = (e) => e.ids?.root ?? `number-input:${e.id}`, h = (e) => e.ids?.input ?? `number-input:${e.id}:input`, H = (e) => e.ids?.incrementTrigger ?? `number-input:${e.id}:inc`, k = (e) => e.ids?.decrementTrigger ?? `number-input:${e.id}:dec`, me = (e) => e.ids?.scrubber ?? `number-input:${e.id}:scrubber`, G = (e) => `number-input:${e.id}:cursor`, fe = (e) => e.ids?.label ?? `number-input:${e.id}:label`, T = (e) => e.getById(h(e)), ge = (e) => e.getById(H(e)), pe = (e) => e.getById(k(e)), _ = (e) => e.getDoc().getElementById(G(e)), ve = (e, t) => {
+  let n = null;
+  return t === "increment" && (n = ge(e)), t === "decrement" && (n = pe(e)), n;
+}, be = (e, t) => {
+  if (!B())
+    return Te(e, t), () => {
+      _(e)?.remove();
+    };
+}, Ee = (e) => {
+  const t = e.getDoc(), n = t.documentElement, r = t.body;
+  return r.style.pointerEvents = "none", n.style.userSelect = "none", n.style.cursor = "ew-resize", () => {
+    r.style.pointerEvents = "", n.style.userSelect = "", n.style.cursor = "", n.style.length || n.removeAttribute("style"), r.style.length || r.removeAttribute("style");
+  };
+}, he = (e, t) => {
+  const { point: n, isRtl: r, event: a } = t, s = e.getWin(), o = R(a.movementX, s.devicePixelRatio), d = R(a.movementY, s.devicePixelRatio);
+  let c = o > 0 ? "increment" : o < 0 ? "decrement" : null;
+  r && c === "increment" && (c = "decrement"), r && c === "decrement" && (c = "increment");
+  const u = { x: n.x + o, y: n.y + d }, g = s.innerWidth, m = R(7.5, s.devicePixelRatio);
+  return u.x = se(u.x + m, g) - m, { hint: c, point: u };
+}, Te = (e, t) => {
+  const n = e.getDoc(), r = n.createElement("div");
+  r.className = "scrubber--cursor", r.id = G(e), Object.assign(r.style, {
+    width: "15px",
+    height: "15px",
+    position: "fixed",
+    pointerEvents: "none",
+    left: "0px",
+    top: "0px",
+    zIndex: z,
+    transform: t ? `translate3d(${t.x}px, ${t.y}px, 0px)` : void 0,
+    willChange: "transform"
+  }), r.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>`, n.body.appendChild(r);
+};
+function Re(e, t) {
+  if (!(!e || !t.isActiveElement(e)))
+    try {
+      const { selectionStart: n, selectionEnd: r, value: a } = e;
+      return n == null || r == null ? void 0 : { start: n, end: r, value: a };
+    } catch {
+      return;
+    }
+}
+function Pe(e, t, n) {
+  if (!(!e || !n.isActiveElement(e))) {
+    if (!t) {
+      const r = e.value.length;
+      e.setSelectionRange(r, r);
+      return;
+    }
+    try {
+      const r = e.value, { start: a, end: s, value: o } = t;
+      if (r === o) {
+        e.setSelectionRange(a, s);
+        return;
+      }
+      const d = L(o, r, a), c = a === s ? d : L(o, r, s), u = Math.max(0, Math.min(d, r.length)), g = Math.max(u, Math.min(c, r.length));
+      e.setSelectionRange(u, g);
+    } catch {
+      const r = e.value.length;
+      e.setSelectionRange(r, r);
+    }
+  }
+}
+function L(e, t, n) {
+  const r = e.slice(0, n), a = e.slice(n);
+  let s = 0;
+  const o = Math.min(r.length, t.length);
+  for (let u = 0; u < o && r[u] === t[u]; u++)
+    s = u + 1;
+  let d = 0;
+  const c = Math.min(a.length, t.length - s);
+  for (let u = 0; u < c; u++) {
+    const g = a.length - 1 - u, m = t.length - 1 - u;
+    if (a[g] === t[m])
+      d = u + 1;
+    else
+      break;
+  }
+  if (s >= r.length)
+    return s;
+  if (d >= a.length)
+    return t.length - d;
+  if (s > 0)
+    return s;
+  if (d > 0)
+    return t.length - d;
+  if (e.length > 0) {
+    const u = n / e.length;
+    return Math.round(u * t.length);
+  }
+  return t.length;
+}
+function we(e, t) {
+  const { state: n, send: r, prop: a, scope: s, computed: o } = e, d = n.hasTag("focus"), c = o("isDisabled"), u = !!a("readOnly"), g = !!a("required"), m = n.matches("scrubbing"), F = o("isValueEmpty"), p = o("isOutOfRange") || !!a("invalid"), I = c || !o("canIncrement") || u, P = c || !o("canDecrement") || u, S = a("translations");
+  return {
+    focused: d,
+    invalid: p,
+    empty: F,
+    value: o("formattedValue"),
+    valueAsNumber: o("valueAsNumber"),
+    setValue(i) {
+      r({ type: "VALUE.SET", value: i });
+    },
+    clearValue() {
+      r({ type: "VALUE.CLEAR" });
+    },
+    increment() {
+      r({ type: "VALUE.INCREMENT" });
+    },
+    decrement() {
+      r({ type: "VALUE.DECREMENT" });
+    },
+    setToMax() {
+      r({ type: "VALUE.SET", value: a("max") });
+    },
+    setToMin() {
+      r({ type: "VALUE.SET", value: a("min") });
+    },
+    focus() {
+      T(s)?.focus();
+    },
+    getRootProps() {
+      return t.element({
+        id: de(s),
+        ...v.root.attrs,
+        dir: a("dir"),
+        "data-disabled": l(c),
+        "data-focus": l(d),
+        "data-invalid": l(p),
+        "data-scrubbing": l(m)
+      });
+    },
+    getLabelProps() {
+      return t.label({
+        ...v.label.attrs,
+        dir: a("dir"),
+        "data-disabled": l(c),
+        "data-focus": l(d),
+        "data-invalid": l(p),
+        "data-required": l(g),
+        "data-scrubbing": l(m),
+        id: fe(s),
+        htmlFor: h(s)
+      });
+    },
+    getControlProps() {
+      return t.element({
+        ...v.control.attrs,
+        dir: a("dir"),
+        role: "group",
+        "aria-disabled": c,
+        "data-focus": l(d),
+        "data-disabled": l(c),
+        "data-invalid": l(p),
+        "data-scrubbing": l(m),
+        "aria-invalid": A(p)
+      });
+    },
+    getValueTextProps() {
+      return t.element({
+        ...v.valueText.attrs,
+        dir: a("dir"),
+        "data-disabled": l(c),
+        "data-invalid": l(p),
+        "data-focus": l(d),
+        "data-scrubbing": l(m)
+      });
+    },
+    getInputProps() {
+      return t.input({
+        ...v.input.attrs,
+        dir: a("dir"),
+        name: a("name"),
+        form: a("form"),
+        id: h(s),
+        role: "spinbutton",
+        defaultValue: o("formattedValue"),
+        pattern: a("formatOptions") ? void 0 : a("pattern"),
+        inputMode: a("inputMode"),
+        "aria-invalid": A(p),
+        "data-invalid": l(p),
+        disabled: c,
+        "data-disabled": l(c),
+        readOnly: u,
+        required: a("required"),
+        autoComplete: "off",
+        autoCorrect: "off",
+        spellCheck: "false",
+        type: "text",
+        "aria-roledescription": "numberfield",
+        "aria-valuemin": a("min"),
+        "aria-valuemax": a("max"),
+        "aria-valuenow": Number.isNaN(o("valueAsNumber")) ? void 0 : o("valueAsNumber"),
+        "aria-valuetext": o("valueText"),
+        "data-scrubbing": l(m),
+        onFocus() {
+          r({ type: "INPUT.FOCUS" });
+        },
+        onBlur() {
+          r({ type: "INPUT.BLUR" });
+        },
+        onInput(i) {
+          const f = Re(i.currentTarget, s);
+          r({ type: "INPUT.CHANGE", target: i.currentTarget, hint: "set", selection: f });
+        },
+        onBeforeInput(i) {
+          try {
+            const { selectionStart: f, selectionEnd: N, value: b } = i.currentTarget, W = b.slice(0, f) + (i.data ?? "") + b.slice(N);
+            o("parser").isValidPartialNumber(W) || i.preventDefault();
+          } catch {
+          }
+        },
+        onKeyDown(i) {
+          if (i.defaultPrevented || u || Y(i)) return;
+          const f = Z(i) * a("step"), b = {
+            ArrowUp() {
+              r({ type: "INPUT.ARROW_UP", step: f }), i.preventDefault();
+            },
+            ArrowDown() {
+              r({ type: "INPUT.ARROW_DOWN", step: f }), i.preventDefault();
+            },
+            Home() {
+              x(i) || (r({ type: "INPUT.HOME" }), i.preventDefault());
+            },
+            End() {
+              x(i) || (r({ type: "INPUT.END" }), i.preventDefault());
+            },
+            Enter() {
+              r({ type: "INPUT.ENTER" });
+            }
+          }[i.key];
+          b?.(i);
+        }
+      });
+    },
+    getDecrementTriggerProps() {
+      return t.button({
+        ...v.decrementTrigger.attrs,
+        dir: a("dir"),
+        id: k(s),
+        disabled: P,
+        "data-disabled": l(P),
+        "aria-label": S.decrementLabel,
+        type: "button",
+        tabIndex: -1,
+        "aria-controls": h(s),
+        "data-scrubbing": l(m),
+        onPointerDown(i) {
+          P || O(i) && (r({ type: "TRIGGER.PRESS_DOWN", hint: "decrement", pointerType: i.pointerType }), i.pointerType === "mouse" && i.preventDefault(), i.pointerType === "touch" && i.currentTarget?.focus({ preventScroll: !0 }));
+        },
+        onPointerUp(i) {
+          r({ type: "TRIGGER.PRESS_UP", hint: "decrement", pointerType: i.pointerType });
+        },
+        onPointerLeave() {
+          P || r({ type: "TRIGGER.PRESS_UP", hint: "decrement" });
+        }
+      });
+    },
+    getIncrementTriggerProps() {
+      return t.button({
+        ...v.incrementTrigger.attrs,
+        dir: a("dir"),
+        id: H(s),
+        disabled: I,
+        "data-disabled": l(I),
+        "aria-label": S.incrementLabel,
+        type: "button",
+        tabIndex: -1,
+        "aria-controls": h(s),
+        "data-scrubbing": l(m),
+        onPointerDown(i) {
+          I || !O(i) || (r({ type: "TRIGGER.PRESS_DOWN", hint: "increment", pointerType: i.pointerType }), i.pointerType === "mouse" && i.preventDefault(), i.pointerType === "touch" && i.currentTarget?.focus({ preventScroll: !0 }));
+        },
+        onPointerUp(i) {
+          r({ type: "TRIGGER.PRESS_UP", hint: "increment", pointerType: i.pointerType });
+        },
+        onPointerLeave(i) {
+          r({ type: "TRIGGER.PRESS_UP", hint: "increment", pointerType: i.pointerType });
+        }
+      });
+    },
+    getScrubberProps() {
+      return t.element({
+        ...v.scrubber.attrs,
+        dir: a("dir"),
+        "data-disabled": l(c),
+        id: me(s),
+        role: "presentation",
+        "data-scrubbing": l(m),
+        onMouseDown(i) {
+          if (c || !O(i)) return;
+          const f = q(i), b = X(i.currentTarget).devicePixelRatio;
+          f.x = f.x - R(7.5, b), f.y = f.y - R(7.5, b), r({ type: "SCRUBBER.PRESS_DOWN", point: f }), i.preventDefault();
+        },
+        style: {
+          cursor: c ? void 0 : "ew-resize"
+        }
+      });
+    }
+  };
+}
+var ye = (e, t = {}) => new Intl.NumberFormat(e, t), Ie = (e, t = {}) => new ue(e, t), V = (e, t) => {
+  const { prop: n, computed: r } = t;
+  return n("formatOptions") ? e === "" ? Number.NaN : r("parser").parse(e) : parseFloat(e);
+}, E = (e, t) => {
+  const { prop: n, computed: r } = t;
+  return Number.isNaN(e) ? "" : n("formatOptions") ? r("formatter").format(e) : e.toString();
+}, Ne = (e, t) => {
+  let n = e !== void 0 && !Number.isNaN(e) ? e : 1;
+  return t?.style === "percent" && (e === void 0 || Number.isNaN(e)) && (n = 0.01), n;
+}, { choose: Oe, guards: Ce, createMachine: Ve } = oe(), { not: M, and: w } = Ce, Be = Ve({
+  props({ props: e }) {
+    const t = Ne(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(r) {
+          const a = n(), s = V(r, { computed: a, prop: e });
+          e("onValueChange")?.({ value: r, valueAsNumber: s });
+        }
+      })),
+      hint: t(() => ({ defaultValue: null })),
+      scrubberCursorPoint: t(() => ({
+        defaultValue: null,
+        hash(r) {
+          return r ? `x:${r.x}, y:${r.y}` : "";
+        }
+      })),
+      fieldsetDisabled: t(() => ({ defaultValue: !1 }))
+    };
+  },
+  computed: {
+    isRtl: ({ prop: e }) => e("dir") === "rtl",
+    valueAsNumber: ({ context: e, computed: t, prop: n }) => V(e.get("value"), { computed: t, prop: n }),
+    formattedValue: ({ computed: e, prop: t }) => E(e("valueAsNumber"), { computed: e, prop: t }),
+    isAtMin: ({ computed: e, prop: t }) => te(e("valueAsNumber"), t("min")),
+    isAtMax: ({ computed: e, prop: t }) => ee(e("valueAsNumber"), t("max")),
+    isOutOfRange: ({ computed: e, prop: t }) => !ie(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: U(
+      ({ prop: e }) => [e("locale"), e("formatOptions")],
+      ([e, t]) => ye(e, t)
+    ),
+    parser: U(
+      ({ prop: e }) => [e("locale"), e("formatOptions")],
+      ([e, t]) => Ie(e, t)
+    )
+  },
+  watch({ track: e, action: t, context: n, computed: r, prop: a }) {
+    e([() => n.get("value"), () => a("locale")], () => {
+      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: w("clampValueOnBlur", M("isInRange")),
+            target: "idle",
+            actions: ["setClampedValue", "clearHint", "invokeOnBlur"]
+          },
+          {
+            guard: M("isInRange"),
+            target: "idle",
+            actions: ["setFormattedValue", "clearHint", "invokeOnBlur", "invokeOnInvalid"]
+          },
+          {
+            target: "idle",
+            actions: ["setFormattedValue", "clearHint", "invokeOnBlur"]
+          }
+        ],
+        "INPUT.ENTER": {
+          actions: ["setFormattedValue", "clearHint", "invokeOnBlur"]
+        }
+      }
+    },
+    "before:spin": {
+      tags: ["focus"],
+      effects: ["trackButtonDisabled", "waitForChangeDelay"],
+      entry: Oe([
+        { guard: "isIncrementHint", actions: ["increment"] },
+        { guard: "isDecrementHint", actions: ["decrement"] }
+      ]),
+      on: {
+        CHANGE_DELAY: {
+          target: "spinning",
+          guard: w("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 = T(t);
+        return Q(n, {
+          onFieldsetDisabledChange(r) {
+            e.set("fieldsetDisabled", r);
+          },
+          onFormReset() {
+            e.set("value", e.initial("value"));
+          }
+        });
+      },
+      setupVirtualCursor({ context: e, scope: t }) {
+        const n = e.get("scrubberCursorPoint");
+        return be(t, n);
+      },
+      preventTextSelection({ scope: e }) {
+        return Ee(e);
+      },
+      trackButtonDisabled({ context: e, scope: t, send: n }) {
+        const r = e.get("hint"), a = ve(t, r);
+        return J(a, {
+          attributes: ["disabled"],
+          callback() {
+            n({ type: "TRIGGER.PRESS_UP", src: "attr" });
+          }
+        });
+      },
+      attachWheelListener({ scope: e, send: t, prop: n }) {
+        const r = T(e);
+        if (!r || !e.isActiveElement(r) || !n("allowMouseWheel")) return;
+        function a(s) {
+          s.preventDefault();
+          const o = Math.sign(s.deltaY) * -1;
+          o === 1 ? t({ type: "VALUE.INCREMENT" }) : o === -1 && t({ type: "VALUE.DECREMENT" });
+        }
+        return C(r, "wheel", a, { passive: !1 });
+      },
+      activatePointerLock({ scope: e }) {
+        if (!B())
+          return j(e.getDoc());
+      },
+      trackMousemove({ scope: e, send: t, context: n, computed: r }) {
+        const a = e.getDoc();
+        function s(d) {
+          const c = n.get("scrubberCursorPoint"), u = r("isRtl"), g = he(e, { point: c, isRtl: u, event: d });
+          g.hint && t({
+            type: "SCRUBBER.POINTER_MOVE",
+            hint: g.hint,
+            point: g.point
+          });
+        }
+        function o() {
+          t({ type: "SCRUBBER.POINTER_UP" });
+        }
+        return ae(C(a, "mousemove", s, !1), C(a, "mouseup", o, !1));
+      }
+    },
+    actions: {
+      focusInput({ scope: e, prop: t }) {
+        if (!t("focusInputOnChange")) return;
+        const n = T(e);
+        e.isActiveElement(n) || D(() => n?.focus({ preventScroll: !0 }));
+      },
+      increment({ context: e, event: t, prop: n, computed: r }) {
+        let a = ne(r("valueAsNumber"), t.step ?? n("step"));
+        n("allowOverflow") || (a = y(a, n("min"), n("max"))), e.set("value", E(a, { computed: r, prop: n }));
+      },
+      decrement({ context: e, event: t, prop: n, computed: r }) {
+        let a = re(r("valueAsNumber"), t.step ?? n("step"));
+        n("allowOverflow") || (a = y(a, n("min"), n("max"))), e.set("value", E(a, { computed: r, prop: n }));
+      },
+      setClampedValue({ context: e, prop: t, computed: n }) {
+        const r = y(n("valueAsNumber"), t("min"), t("max"));
+        e.set("value", E(r, { computed: n, prop: t }));
+      },
+      setRawValue({ context: e, event: t, prop: n, computed: r }) {
+        let a = V(t.value, { computed: r, prop: n });
+        n("allowOverflow") || (a = y(a, n("min"), n("max"))), e.set("value", E(a, { computed: r, 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 r = E(t("max"), { computed: n, prop: t });
+        e.set("value", r);
+      },
+      decrementToMin({ context: e, prop: t, computed: n }) {
+        const 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;
+        const r = e("valueAsNumber") > t("max") ? "rangeOverflow" : "rangeUnderflow";
+        t("onValueInvalid")?.({
+          reason: r,
+          value: e("formattedValue"),
+          valueAsNumber: e("valueAsNumber")
+        });
+      },
+      syncInputElement({ context: e, event: t, computed: n, scope: r }) {
+        const a = t.type.endsWith("CHANGE") ? e.get("value") : n("formattedValue"), s = T(r), o = t.selection;
+        D(() => {
+          K(s, a), Pe(s, o, r);
+        });
+      },
+      setFormattedValue({ context: e, computed: t }) {
+        e.set("value", t("formattedValue"));
+      },
+      setCursorPoint({ context: e, event: t }) {
+        e.set("scrubberCursorPoint", t.point);
+      },
+      clearCursorPoint({ context: e }) {
+        e.set("scrubberCursorPoint", null);
+      },
+      setVirtualCursorPosition({ context: e, scope: t }) {
+        const n = _(t), r = e.get("scrubberCursorPoint");
+        !n || !r || (n.style.transform = `translate3d(${r.x}px, ${r.y}px, 0px)`);
+      }
+    }
+  }
+});
+le()([
+  "allowMouseWheel",
+  "allowOverflow",
+  "clampValueOnBlur",
+  "dir",
+  "disabled",
+  "focusInputOnChange",
+  "form",
+  "formatOptions",
+  "getRootNode",
+  "id",
+  "ids",
+  "inputMode",
+  "invalid",
+  "locale",
+  "max",
+  "min",
+  "name",
+  "onFocusChange",
+  "onValueChange",
+  "onValueInvalid",
+  "pattern",
+  "required",
+  "readOnly",
+  "spinOnPress",
+  "step",
+  "translations",
+  "value",
+  "defaultValue"
+]);
+export {
+  ce as anatomy,
+  we as connect,
+  Be as machine
+};