@serendie/ui 3.2.2-dev.202604251110 → 3.2.2-dev.202604270058

package/dist/node_modules/@zag-js/slider/dist/slider.connect.js

@@ -0,0 +1,272 @@
+import { isLeftClick as L, isModifierKey as H, getEventPoint as G, getEventStep as K, getEventKey as X } from "../../dom-query/dist/event.js";
+import { dataAttr as r, ariaAttr as Y } from "../../dom-query/dist/shared.js";
+import { parts as u } from "./slider.anatomy.js";
+import { getMarkerId as j, getControlId as q, getRangeId as J, getHiddenInputId as M, getLabelId as O, getThumbId as Q, getTrackId as Z, getValueTextId as $, getRootId as z, getFirstThumbEl as tt } from "./slider.dom.js";
+import { getThumbStyle as U, getMarkerStyle as et, getMarkerGroupStyle as at, getControlStyle as rt, getRangeStyle as nt, getRootStyle as it } from "./slider.style.js";
+import { getRangeAtIndex as E } from "./slider.utils.js";
+import { first as ot, last as dt } from "../../utils/dist/array.js";
+import { getPercentValue as lt, getValuePercent as st } from "../../utils/dist/number.js";
+function Pt(g, l) {
+  const { state: I, send: n, context: v, prop: e, computed: D, scope: o } = g, h = e("aria-label"), T = e("aria-labelledby"), c = v.get("value"), A = v.get("focusedIndex"), p = I.matches("focus"), f = I.matches("dragging"), s = D("isDisabled"), b = e("invalid"), m = D("isInteractive"), V = e("orientation") === "horizontal", w = e("orientation") === "vertical";
+  function k(t) {
+    return st(t, e("min"), e("max"));
+  }
+  function C(t) {
+    return lt(t, e("min"), e("max"), e("step"));
+  }
+  return {
+    value: c,
+    dragging: f,
+    focused: p,
+    setValue(t) {
+      n({ type: "SET_VALUE", value: t });
+    },
+    getThumbValue(t) {
+      return c[t];
+    },
+    setThumbValue(t, a) {
+      n({ type: "SET_VALUE", index: t, value: a });
+    },
+    getValuePercent: k,
+    getPercentValue: C,
+    getThumbPercent(t) {
+      return k(c[t]);
+    },
+    setThumbPercent(t, a) {
+      const i = C(a);
+      n({ type: "SET_VALUE", index: t, value: i });
+    },
+    getThumbMin(t) {
+      return E(g, t).min;
+    },
+    getThumbMax(t) {
+      return E(g, t).max;
+    },
+    increment(t) {
+      n({ type: "INCREMENT", index: t });
+    },
+    decrement(t) {
+      n({ type: "DECREMENT", index: t });
+    },
+    focus() {
+      m && n({ type: "FOCUS", index: 0 });
+    },
+    getLabelProps() {
+      return l.label({
+        ...u.label.attrs,
+        dir: e("dir"),
+        "data-disabled": r(s),
+        "data-orientation": e("orientation"),
+        "data-invalid": r(b),
+        "data-dragging": r(f),
+        "data-focus": r(p),
+        id: O(o),
+        htmlFor: M(o, 0),
+        onClick(t) {
+          var a;
+          m && (t.preventDefault(), (a = tt(o)) == null || a.focus());
+        },
+        style: {
+          userSelect: "none",
+          WebkitUserSelect: "none"
+        }
+      });
+    },
+    getRootProps() {
+      return l.element({
+        ...u.root.attrs,
+        "data-disabled": r(s),
+        "data-orientation": e("orientation"),
+        "data-dragging": r(f),
+        "data-invalid": r(b),
+        "data-focus": r(p),
+        id: z(o),
+        dir: e("dir"),
+        style: it(g)
+      });
+    },
+    getValueTextProps() {
+      return l.element({
+        ...u.valueText.attrs,
+        dir: e("dir"),
+        "data-disabled": r(s),
+        "data-orientation": e("orientation"),
+        "data-invalid": r(b),
+        "data-focus": r(p),
+        id: $(o)
+      });
+    },
+    getTrackProps() {
+      return l.element({
+        ...u.track.attrs,
+        dir: e("dir"),
+        id: Z(o),
+        "data-disabled": r(s),
+        "data-invalid": r(b),
+        "data-dragging": r(f),
+        "data-orientation": e("orientation"),
+        "data-focus": r(p),
+        style: { position: "relative" }
+      });
+    },
+    getThumbProps(t) {
+      var _;
+      const { index: a = 0, name: i } = t, N = c[a], S = E(g, a), W = (_ = e("getAriaValueText")) == null ? void 0 : _({ value: N, index: a }), F = Array.isArray(h) ? h[a] : h, B = Array.isArray(T) ? T[a] : T;
+      return l.element({
+        ...u.thumb.attrs,
+        dir: e("dir"),
+        "data-index": a,
+        "data-name": i,
+        id: Q(o, a),
+        "data-disabled": r(s),
+        "data-orientation": e("orientation"),
+        "data-focus": r(p && A === a),
+        "data-dragging": r(f && A === a),
+        draggable: !1,
+        "aria-disabled": Y(s),
+        "aria-label": F,
+        "aria-labelledby": B ?? O(o),
+        "aria-orientation": e("orientation"),
+        "aria-valuemax": S.max,
+        "aria-valuemin": S.min,
+        "aria-valuenow": c[a],
+        "aria-valuetext": W,
+        role: "slider",
+        tabIndex: s ? void 0 : 0,
+        style: U(g, a),
+        onPointerDown(d) {
+          if (!m || !L(d)) return;
+          const P = d.currentTarget.getBoundingClientRect(), x = {
+            x: P.left + P.width / 2,
+            y: P.top + P.height / 2
+          }, R = {
+            x: d.clientX - x.x,
+            y: d.clientY - x.y
+          };
+          n({ type: "THUMB_POINTER_DOWN", index: a, offset: R }), d.stopPropagation();
+        },
+        onBlur() {
+          m && n({ type: "BLUR" });
+        },
+        onFocus() {
+          m && n({ type: "FOCUS", index: a });
+        },
+        onKeyDown(d) {
+          if (d.defaultPrevented || !m) return;
+          const y = K(d) * e("step"), P = {
+            ArrowUp() {
+              V || n({ type: "ARROW_INC", step: y, src: "ArrowUp" });
+            },
+            ArrowDown() {
+              V || n({ type: "ARROW_DEC", step: y, src: "ArrowDown" });
+            },
+            ArrowLeft() {
+              w || n({ type: "ARROW_DEC", step: y, src: "ArrowLeft" });
+            },
+            ArrowRight() {
+              w || n({ type: "ARROW_INC", step: y, src: "ArrowRight" });
+            },
+            PageUp() {
+              n({ type: "ARROW_INC", step: y, src: "PageUp" });
+            },
+            PageDown() {
+              n({ type: "ARROW_DEC", step: y, src: "PageDown" });
+            },
+            Home() {
+              n({ type: "HOME" });
+            },
+            End() {
+              n({ type: "END" });
+            }
+          }, x = X(d, {
+            dir: e("dir"),
+            orientation: e("orientation")
+          }), R = P[x];
+          R && (R(d), d.preventDefault(), d.stopPropagation());
+        }
+      });
+    },
+    getHiddenInputProps(t) {
+      const { index: a = 0, name: i } = t;
+      return l.input({
+        name: i ?? (e("name") ? e("name") + (c.length > 1 ? "[]" : "") : void 0),
+        form: e("form"),
+        type: "text",
+        hidden: !0,
+        defaultValue: c[a],
+        id: M(o, a)
+      });
+    },
+    getRangeProps() {
+      return l.element({
+        id: J(o),
+        ...u.range.attrs,
+        dir: e("dir"),
+        "data-dragging": r(f),
+        "data-focus": r(p),
+        "data-invalid": r(b),
+        "data-disabled": r(s),
+        "data-orientation": e("orientation"),
+        style: nt(g)
+      });
+    },
+    getControlProps() {
+      return l.element({
+        ...u.control.attrs,
+        dir: e("dir"),
+        id: q(o),
+        "data-dragging": r(f),
+        "data-disabled": r(s),
+        "data-orientation": e("orientation"),
+        "data-invalid": r(b),
+        "data-focus": r(p),
+        style: rt(),
+        onPointerDown(t) {
+          if (!m || !L(t) || H(t)) return;
+          const a = G(t);
+          n({ type: "POINTER_DOWN", point: a }), t.preventDefault(), t.stopPropagation();
+        }
+      });
+    },
+    getMarkerGroupProps() {
+      return l.element({
+        ...u.markerGroup.attrs,
+        role: "presentation",
+        dir: e("dir"),
+        "aria-hidden": !0,
+        "data-orientation": e("orientation"),
+        style: at()
+      });
+    },
+    getMarkerProps(t) {
+      const a = et(g, t.value);
+      let i;
+      return t.value < ot(c) ? i = "under-value" : t.value > dt(c) ? i = "over-value" : i = "at-value", l.element({
+        ...u.marker.attrs,
+        id: j(o, t.value),
+        role: "presentation",
+        dir: e("dir"),
+        "data-orientation": e("orientation"),
+        "data-value": t.value,
+        "data-disabled": r(s),
+        "data-state": i,
+        style: a
+      });
+    },
+    getDraggingIndicatorProps(t) {
+      const { index: a = 0 } = t, i = a === A && f;
+      return l.element({
+        ...u.draggingIndicator.attrs,
+        role: "presentation",
+        dir: e("dir"),
+        hidden: !i,
+        "data-orientation": e("orientation"),
+        "data-state": i ? "open" : "closed",
+        style: U(g, a)
+      });
+    }
+  };
+}
+export {
+  Pt as connect
+};

package/dist/node_modules/@zag-js/slider/dist/slider.dom.js

@@ -0,0 +1,88 @@
+import { getPercentValue as P, clampPercent as u } from "../../utils/dist/number.js";
+import { dispatchInputValueEvent as T } from "../../dom-query/dist/form.js";
+import { queryAll as V } from "../../dom-query/dist/query.js";
+var b = (t) => {
+  var e;
+  return ((e = t.ids) == null ? void 0 : e.root) ?? `slider:${t.id}`;
+}, k = (t, e) => {
+  var r, n;
+  return ((n = (r = t.ids) == null ? void 0 : r.thumb) == null ? void 0 : n.call(r, e)) ?? `slider:${t.id}:thumb:${e}`;
+}, C = (t, e) => {
+  var r, n;
+  return ((n = (r = t.ids) == null ? void 0 : r.hiddenInput) == null ? void 0 : n.call(r, e)) ?? `slider:${t.id}:input:${e}`;
+}, R = (t) => {
+  var e;
+  return ((e = t.ids) == null ? void 0 : e.control) ?? `slider:${t.id}:control`;
+}, O = (t) => {
+  var e;
+  return ((e = t.ids) == null ? void 0 : e.track) ?? `slider:${t.id}:track`;
+}, q = (t) => {
+  var e;
+  return ((e = t.ids) == null ? void 0 : e.range) ?? `slider:${t.id}:range`;
+}, x = (t) => {
+  var e;
+  return ((e = t.ids) == null ? void 0 : e.label) ?? `slider:${t.id}:label`;
+}, D = (t) => {
+  var e;
+  return ((e = t.ids) == null ? void 0 : e.valueText) ?? `slider:${t.id}:value-text`;
+}, F = (t, e) => {
+  var r, n;
+  return ((n = (r = t.ids) == null ? void 0 : r.marker) == null ? void 0 : n.call(r, e)) ?? `slider:${t.id}:marker:${e}`;
+}, M = (t) => t.getById(b(t)), X = (t, e) => t.getById(k(t, e)), B = (t) => V(h(t), "[role=slider]"), Y = (t) => B(t)[0], H = (t, e) => t.getById(C(t, e)), h = (t) => t.getById(R(t)), j = (t, e, r) => e === "contain" ? (r === "vertical" ? (t == null ? void 0 : t.height) ?? 0 : (t == null ? void 0 : t.width) ?? 0) / 2 : 0, G = (t, e) => {
+  const { context: r, prop: n, scope: o, refs: l } = t, g = h(o);
+  if (!g) return;
+  const i = l.get("thumbDragOffset"), c = {
+    x: e.x - ((i == null ? void 0 : i.x) ?? 0),
+    y: e.y - ((i == null ? void 0 : i.y) ?? 0)
+  }, v = j(r.get("thumbSize"), n("thumbAlignment"), n("orientation")), d = w(c, g, v).getPercentValue({
+    orientation: n("orientation"),
+    dir: n("dir"),
+    inverted: { y: !0 }
+  });
+  return P(d, n("min"), n("max"), n("step"));
+};
+function w(t, e, r) {
+  const { left: n, top: o, width: l, height: g } = e.getBoundingClientRect(), i = l - r * 2, c = g - r * 2, v = n + r, f = o + r, d = {
+    x: t.x - v,
+    y: t.y - f
+  }, s = {
+    x: i > 0 ? u(d.x / i) : 0,
+    y: c > 0 ? u(d.y / c) : 0
+  };
+  function p(I = {}) {
+    const { dir: y = "ltr", orientation: m = "horizontal", inverted: a } = I, $ = typeof a == "object" ? a.x : a, E = typeof a == "object" ? a.y : a;
+    return m === "horizontal" ? y === "rtl" || $ ? 1 - s.x : s.x : E ? 1 - s.y : s.y;
+  }
+  return { offset: d, percent: s, getPercentValue: p };
+}
+var J = (t, e) => {
+  e.forEach((r, n) => {
+    const o = H(t, n);
+    o && T(o, { value: r });
+  });
+}, K = (t) => ({
+  left: (t == null ? void 0 : t.offsetLeft) ?? 0,
+  top: (t == null ? void 0 : t.offsetTop) ?? 0,
+  width: (t == null ? void 0 : t.offsetWidth) ?? 0,
+  height: (t == null ? void 0 : t.offsetHeight) ?? 0
+});
+export {
+  J as dispatchChangeEvent,
+  h as getControlEl,
+  R as getControlId,
+  Y as getFirstThumbEl,
+  H as getHiddenInputEl,
+  C as getHiddenInputId,
+  x as getLabelId,
+  F as getMarkerId,
+  K as getOffsetRect,
+  G as getPointValue,
+  q as getRangeId,
+  M as getRootEl,
+  b as getRootId,
+  X as getThumbEl,
+  B as getThumbEls,
+  k as getThumbId,
+  O as getTrackId,
+  D as getValueTextId
+};

package/dist/node_modules/@zag-js/slider/dist/slider.machine.js

@@ -0,0 +1,309 @@
+import { getThumbEl as h, getPointValue as c, getHiddenInputEl as g, dispatchChangeEvent as f, getThumbEls as v, getRootEl as T, getOffsetRect as x } from "./slider.dom.js";
+import { normalizeValues as b, constrainValue as I, getRangeAtIndex as d, increment as E, decrement as V, resolveThumbCollision as O, selectMovableThumb as C, getClosestIndex as D } from "./slider.utils.js";
+import { createMachine as S } from "../../core/dist/create-machine.js";
+import { setValueAtIndex as r, getValuePercent as A, getValueRanges as P, snapValueToStep as R, clampValue as N, isValueWithinRange as k } from "../../utils/dist/number.js";
+import { raf as M } from "../../dom-query/dist/raf.js";
+import { setElementValue as z, trackFormControl as p } from "../../dom-query/dist/form.js";
+import { resizeObserverBorderBox as F } from "../../dom-query/dist/resize-observer.js";
+import { callAll as _ } from "../../utils/dist/functions.js";
+import { trackPointerMove as w } from "../../dom-query/dist/pointer-move.js";
+import { memo as B } from "../../core/dist/memo.js";
+import { isEqual as y } from "../../utils/dist/equal.js";
+import { pick as U } from "../../utils/dist/object.js";
+var W = (e, t) => (e == null ? void 0 : e.width) === (t == null ? void 0 : t.width) && (e == null ? void 0 : e.height) === (t == null ? void 0 : t.height), m = (e, t, n, a, s) => P(e, t, n, s * a).map((o) => {
+  const l = R(o.value, o.min, o.max, a), i = N(l, o.min, o.max);
+  if (!k(i, t, n))
+    throw new Error(
+      "[zag-js/slider] The configured `min`, `max`, `step` or `minStepsBetweenThumbs` values are invalid"
+    );
+  return i;
+}), ee = S({
+  props({ props: e }) {
+    const t = e.min ?? 0, n = e.max ?? 100, a = e.step ?? 1, s = e.defaultValue ?? [t], u = e.minStepsBetweenThumbs ?? 0;
+    return {
+      dir: "ltr",
+      thumbAlignment: "contain",
+      origin: "start",
+      orientation: "horizontal",
+      thumbCollisionBehavior: "none",
+      minStepsBetweenThumbs: u,
+      ...e,
+      defaultValue: m(s, t, n, a, u),
+      value: e.value ? m(e.value, t, n, a, u) : void 0,
+      max: n,
+      step: a,
+      min: t
+    };
+  },
+  initialState() {
+    return "idle";
+  },
+  context({ prop: e, bindable: t, getContext: n }) {
+    return {
+      thumbSize: t(() => ({
+        defaultValue: e("thumbSize") || null
+      })),
+      value: t(() => ({
+        defaultValue: e("defaultValue"),
+        value: e("value"),
+        isEqual: y,
+        hash(a) {
+          return a.join(",");
+        },
+        onChange(a) {
+          var s;
+          (s = e("onValueChange")) == null || s({ value: a });
+        }
+      })),
+      focusedIndex: t(() => ({
+        defaultValue: -1,
+        onChange(a) {
+          var u;
+          const s = n();
+          (u = e("onFocusChange")) == null || u({ focusedIndex: a, value: s.get("value") });
+        }
+      })),
+      fieldsetDisabled: t(() => ({
+        defaultValue: !1
+      }))
+    };
+  },
+  refs() {
+    return {
+      thumbDragOffset: null,
+      thumbDragStartValue: null
+    };
+  },
+  computed: {
+    isHorizontal: ({ prop: e }) => e("orientation") === "horizontal",
+    isVertical: ({ prop: e }) => e("orientation") === "vertical",
+    isRtl: ({ prop: e }) => e("orientation") === "horizontal" && e("dir") === "rtl",
+    isDisabled: ({ context: e, prop: t }) => !!t("disabled") || e.get("fieldsetDisabled"),
+    isInteractive: ({ prop: e, computed: t }) => !(e("readOnly") || t("isDisabled")),
+    hasMeasuredThumbSize: ({ context: e }) => e.get("thumbSize") != null,
+    valuePercent: B(
+      ({ context: e, prop: t }) => [e.get("value"), t("min"), t("max")],
+      ([e, t, n]) => e.map((a) => 100 * A(a, t, n))
+    )
+  },
+  watch({ track: e, action: t, context: n, computed: a, send: s }) {
+    e([() => n.hash("value")], () => {
+      t(["syncInputElements", "dispatchChangeEvent"]);
+    }), e([() => a("isDisabled")], () => {
+      a("isDisabled") && s({ type: "POINTER_CANCEL" });
+    });
+  },
+  effects: ["trackFormControlState", "trackThumbSize"],
+  on: {
+    SET_VALUE: [
+      {
+        guard: "hasIndex",
+        actions: ["setValueAtIndex", "invokeOnChangeEnd"]
+      },
+      {
+        actions: ["setValue", "invokeOnChangeEnd"]
+      }
+    ],
+    INCREMENT: {
+      actions: ["incrementThumbAtIndex", "invokeOnChangeEnd"]
+    },
+    DECREMENT: {
+      actions: ["decrementThumbAtIndex", "invokeOnChangeEnd"]
+    }
+  },
+  states: {
+    idle: {
+      on: {
+        POINTER_DOWN: {
+          target: "dragging",
+          actions: ["setClosestThumbIndex", "setThumbDragStartValue", "setPointerValue", "focusActiveThumb"]
+        },
+        FOCUS: {
+          target: "focus",
+          actions: ["setFocusedIndex"]
+        },
+        THUMB_POINTER_DOWN: {
+          target: "dragging",
+          actions: ["setFocusedIndex", "setThumbDragOffset", "setThumbDragStartValue", "focusActiveThumb"]
+        }
+      }
+    },
+    focus: {
+      entry: ["focusActiveThumb"],
+      on: {
+        POINTER_DOWN: {
+          target: "dragging",
+          actions: ["setClosestThumbIndex", "setThumbDragStartValue", "setPointerValue", "focusActiveThumb"]
+        },
+        THUMB_POINTER_DOWN: {
+          target: "dragging",
+          actions: ["setFocusedIndex", "setThumbDragOffset", "setThumbDragStartValue", "focusActiveThumb"]
+        },
+        ARROW_DEC: {
+          actions: ["decrementThumbAtIndex", "invokeOnChangeEnd"]
+        },
+        ARROW_INC: {
+          actions: ["incrementThumbAtIndex", "invokeOnChangeEnd"]
+        },
+        HOME: {
+          actions: ["setFocusedThumbToMin", "invokeOnChangeEnd"]
+        },
+        END: {
+          actions: ["setFocusedThumbToMax", "invokeOnChangeEnd"]
+        },
+        BLUR: {
+          target: "idle",
+          actions: ["clearFocusedIndex"]
+        }
+      }
+    },
+    dragging: {
+      entry: ["focusActiveThumb"],
+      effects: ["trackPointerMove"],
+      on: {
+        POINTER_UP: {
+          target: "focus",
+          actions: ["invokeOnChangeEnd", "clearThumbDragOffset", "clearThumbDragStartValue"]
+        },
+        POINTER_MOVE: {
+          actions: ["setPointerValue"]
+        },
+        POINTER_CANCEL: {
+          target: "idle",
+          actions: ["clearFocusedIndex", "clearThumbDragOffset", "clearThumbDragStartValue"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      hasIndex: ({ event: e }) => e.index != null
+    },
+    effects: {
+      trackFormControlState({ context: e, scope: t }) {
+        return p(T(t), {
+          onFieldsetDisabledChange(n) {
+            e.set("fieldsetDisabled", n);
+          },
+          onFormReset() {
+            e.set("value", e.initial("value"));
+          }
+        });
+      },
+      trackPointerMove({ scope: e, send: t }) {
+        return w(e.getDoc(), {
+          onPointerMove(n) {
+            t({ type: "POINTER_MOVE", point: n.point });
+          },
+          onPointerUp() {
+            t({ type: "POINTER_UP" });
+          }
+        });
+      },
+      trackThumbSize({ context: e, scope: t, prop: n }) {
+        if (n("thumbAlignment") !== "contain" || n("thumbSize")) return;
+        const a = (o) => {
+          const l = x(o), i = U(l, ["width", "height"]);
+          W(e.get("thumbSize"), i) || e.set("thumbSize", i);
+        }, s = v(t);
+        s.forEach(a);
+        const u = s.map((o) => F.observe(o, () => a(o)));
+        return _(...u);
+      }
+    },
+    actions: {
+      dispatchChangeEvent({ context: e, scope: t }) {
+        f(t, e.get("value"));
+      },
+      syncInputElements({ context: e, scope: t }) {
+        e.get("value").forEach((n, a) => {
+          const s = g(t, a);
+          z(s, n.toString());
+        });
+      },
+      invokeOnChangeEnd({ prop: e, context: t }) {
+        queueMicrotask(() => {
+          var n;
+          (n = e("onValueChangeEnd")) == null || n({ value: t.get("value") });
+        });
+      },
+      setClosestThumbIndex(e) {
+        const { context: t, event: n } = e, a = c(e, n.point);
+        if (a == null) return;
+        const s = D(e, a);
+        t.set("focusedIndex", s);
+      },
+      setFocusedIndex(e) {
+        const { context: t, event: n } = e, a = C(e, n.index);
+        t.set("focusedIndex", a);
+      },
+      clearFocusedIndex({ context: e }) {
+        e.set("focusedIndex", -1);
+      },
+      setThumbDragOffset(e) {
+        const { refs: t, event: n } = e;
+        t.set("thumbDragOffset", n.offset ?? null);
+      },
+      clearThumbDragOffset({ refs: e }) {
+        e.set("thumbDragOffset", null);
+      },
+      setThumbDragStartValue({ refs: e, context: t }) {
+        e.set("thumbDragStartValue", t.get("value").slice());
+      },
+      clearThumbDragStartValue({ refs: e }) {
+        e.set("thumbDragStartValue", null);
+      },
+      setPointerValue(e) {
+        queueMicrotask(() => {
+          const { context: t, event: n, prop: a, refs: s } = e, u = c(e, n.point);
+          if (u == null) return;
+          const o = t.get("focusedIndex"), l = s.get("thumbDragStartValue"), i = O(
+            a("thumbCollisionBehavior"),
+            o,
+            u,
+            t.get("value"),
+            a("min"),
+            a("max"),
+            a("step"),
+            a("minStepsBetweenThumbs"),
+            l == null ? void 0 : l[o]
+          );
+          i.swapped && t.set("focusedIndex", i.index), t.set("value", i.values);
+        });
+      },
+      focusActiveThumb({ scope: e, context: t }) {
+        M(() => {
+          const n = h(e, t.get("focusedIndex"));
+          n == null || n.focus({ preventScroll: !0 });
+        });
+      },
+      decrementThumbAtIndex(e) {
+        const { context: t, event: n } = e, a = V(e, n.index, n.step);
+        t.set("value", a);
+      },
+      incrementThumbAtIndex(e) {
+        const { context: t, event: n } = e, a = E(e, n.index, n.step);
+        t.set("value", a);
+      },
+      setFocusedThumbToMin(e) {
+        const { context: t } = e, n = t.get("focusedIndex"), { min: a } = d(e, n);
+        t.set("value", (s) => r(s, n, a));
+      },
+      setFocusedThumbToMax(e) {
+        const { context: t } = e, n = t.get("focusedIndex"), { max: a } = d(e, n);
+        t.set("value", (s) => r(s, n, a));
+      },
+      setValueAtIndex(e) {
+        const { context: t, event: n } = e, a = I(e, n.value, n.index);
+        t.set("value", (s) => r(s, n.index, a));
+      },
+      setValue(e) {
+        const { context: t, event: n } = e, a = b(e, n.value);
+        t.set("value", a);
+      }
+    }
+  }
+});
+export {
+  ee as machine
+};