@serendie/ui 3.2.1 → 3.2.2-dev.202604270058

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
+};

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

@@ -0,0 +1,119 @@
+import { toPx as a, getValuePercent as p, getValueTransformer as u } from "../../utils/dist/number.js";
+function b(t) {
+  const e = t[0], o = t[t.length - 1];
+  return [e, o];
+}
+function x(t) {
+  const { prop: e, computed: o } = t, n = o("valuePercent"), [r, i] = b(n);
+  if (n.length === 1) {
+    if (e("origin") === "center") {
+      const s = n[0] < 50, l = s ? `${n[0]}%` : "50%", c = s ? "50%" : `${100 - n[0]}%`;
+      return { start: l, end: c };
+    }
+    return e("origin") === "end" ? { start: `${i}%`, end: "0%" } : { start: "0%", end: `${100 - i}%` };
+  }
+  return { start: `${r}%`, end: `${100 - i}%` };
+}
+function R(t) {
+  const { computed: e } = t, o = e("isVertical"), n = e("isRtl");
+  return o ? {
+    position: "absolute",
+    bottom: "var(--slider-range-start)",
+    top: "var(--slider-range-end)"
+  } : {
+    position: "absolute",
+    [n ? "right" : "left"]: "var(--slider-range-start)",
+    [n ? "left" : "right"]: "var(--slider-range-end)"
+  };
+}
+function v(t, e) {
+  const { context: o, prop: n } = t, { height: r = 0 } = o.get("thumbSize") ?? {}, i = u([n("min"), n("max")], [-r / 2, r / 2]);
+  return parseFloat(i(e).toFixed(2));
+}
+function S(t, e) {
+  const { computed: o, context: n, prop: r } = t, { width: i = 0 } = n.get("thumbSize") ?? {};
+  if (o("isRtl")) {
+    const c = u([r("max"), r("min")], [-i / 2, i / 2]);
+    return -1 * parseFloat(c(e).toFixed(2));
+  }
+  const l = u([r("min"), r("max")], [-i / 2, i / 2]);
+  return parseFloat(l(e).toFixed(2));
+}
+function y(t, e, o) {
+  const { computed: n, prop: r } = t;
+  if (r("thumbAlignment") === "center") return `${e}%`;
+  const i = n("isVertical") ? v(t, o) : S(t, o);
+  return `calc(${e}% - ${i}px)`;
+}
+function f(t, e) {
+  const { prop: o } = t, n = p(e, o("min"), o("max")) * 100;
+  return y(t, n, e);
+}
+function d(t) {
+  const { computed: e, prop: o } = t;
+  let n = "visible";
+  return o("thumbAlignment") === "contain" && !e("hasMeasuredThumbSize") && (n = "hidden"), n;
+}
+function $(t, e) {
+  const { computed: o, context: n } = t, r = o("isVertical") ? "bottom" : "insetInlineStart", i = n.get("focusedIndex");
+  return {
+    visibility: d(t),
+    position: "absolute",
+    transform: "var(--slider-thumb-transform)",
+    [r]: `var(--slider-thumb-offset-${e})`,
+    zIndex: i === e ? 1 : void 0
+  };
+}
+function P() {
+  return {
+    touchAction: "none",
+    userSelect: "none",
+    WebkitUserSelect: "none",
+    position: "relative"
+  };
+}
+function T(t) {
+  const { context: e, computed: o } = t, n = o("isVertical"), r = o("isRtl"), i = x(t), s = e.get("thumbSize");
+  return {
+    ...e.get("value").reduce((c, g, m) => {
+      const h = f(t, g);
+      return { ...c, [`--slider-thumb-offset-${m}`]: h };
+    }, {}),
+    "--slider-thumb-width": a(s == null ? void 0 : s.width),
+    "--slider-thumb-height": a(s == null ? void 0 : s.height),
+    "--slider-thumb-transform": n ? "translateY(50%)" : r ? "translateX(50%)" : "translateX(-50%)",
+    "--slider-range-start": i.start,
+    "--slider-range-end": i.end
+  };
+}
+function F(t, e) {
+  const { computed: o } = t, n = o("isHorizontal"), r = o("isRtl");
+  return {
+    visibility: d(t),
+    position: "absolute",
+    pointerEvents: "none",
+    [n ? "insetInlineStart" : "bottom"]: f(t, e),
+    translate: "var(--translate-x) var(--translate-y)",
+    "--translate-x": n ? r ? "50%" : "-50%" : "0%",
+    "--translate-y": n ? "0%" : "50%"
+  };
+}
+function z() {
+  return {
+    userSelect: "none",
+    WebkitUserSelect: "none",
+    pointerEvents: "none",
+    position: "relative"
+  };
+}
+export {
+  P as getControlStyle,
+  z as getMarkerGroupStyle,
+  F as getMarkerStyle,
+  x as getRangeOffsets,
+  R as getRangeStyle,
+  T as getRootStyle,
+  f as getThumbOffset,
+  $ as getThumbStyle,
+  d as getVisibility
+};

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

@@ -0,0 +1,105 @@
+import { snapValueToStep as b, clampValue as x, getValueRanges as w, getNextStepValue as V, getPreviousStepValue as T } from "../../utils/dist/number.js";
+function g(t) {
+  const { index: n, values: s, min: e, max: c, gap: o } = t, a = s[n - 1], u = s[n + 1];
+  return {
+    min: a != null ? a + o : e,
+    max: u != null ? u - o : c
+  };
+}
+function i(t) {
+  return Math.round(t * 1e10) / 1e10;
+}
+function h(t) {
+  const { index: n, value: s, values: e } = t, c = g(t), o = e.slice();
+  return o[n] = i(x(s, c.min, c.max)), { values: o, index: n, swapped: !1 };
+}
+function I(t) {
+  const { index: n, value: s, values: e, min: c, max: o, gap: a } = t, u = e.slice(), p = c + n * a, m = o - (e.length - 1 - n) * a;
+  u[n] = i(x(s, p, m));
+  for (let l = n + 1; l < e.length; l++) {
+    const r = u[l - 1] + a;
+    u[l] < r && (u[l] = i(r));
+  }
+  for (let l = n - 1; l >= 0; l--) {
+    const r = u[l + 1] - a;
+    u[l] > r && (u[l] = i(r));
+  }
+  return { values: u, index: n, swapped: !1 };
+}
+function M(t, n) {
+  const { index: s, value: e, values: c, gap: o } = t, a = c[s - 1], u = c[s + 1], p = u != null && e >= u && e > n, m = a != null && e <= a && e < n;
+  if (!p && !m)
+    return h(t);
+  const l = p ? s + 1 : s - 1, r = c.slice(), v = { ...t, index: l }, f = g(v);
+  return r[l] = i(x(e, f.min, f.max)), r[s] = c[l], p && r[s] > r[l] - o ? r[s] = i(r[l] - o) : m && r[s] < r[l] + o && (r[s] = i(r[l] + o)), { values: r, index: l, swapped: !0 };
+}
+function N(t, n, s, e, c, o, a, u, p) {
+  if (e.length === 1)
+    return { values: [i(x(s, c, o))], index: 0, swapped: !1 };
+  const m = a * u, l = { behavior: t, index: n, value: s, values: e, min: c, max: o, gap: m };
+  switch (t) {
+    case "push":
+      return I(l);
+    case "swap":
+      return M(l, p ?? e[n]);
+    case "none":
+    default:
+      return h(l);
+  }
+}
+function P(t, n) {
+  return n.map((s, e) => S(t, s, e));
+}
+function d(t, n) {
+  const { context: s, prop: e } = t, c = e("step") * e("minStepsBetweenThumbs");
+  return w(s.get("value"), e("min"), e("max"), c)[n];
+}
+function S(t, n, s) {
+  const { prop: e } = t, c = d(t, s), o = b(n, e("min"), e("max"), e("step"));
+  return x(o, c.min, c.max);
+}
+function B(t, n, s) {
+  const { context: e, prop: c } = t, o = n ?? e.get("focusedIndex"), a = d(t, o), u = T(o, {
+    ...a,
+    step: s ?? c("step"),
+    values: e.get("value")
+  });
+  return u[o] = x(u[o], a.min, a.max), u;
+}
+function R(t, n, s) {
+  const { context: e, prop: c } = t, o = n ?? e.get("focusedIndex"), a = d(t, o), u = V(o, {
+    ...a,
+    step: s ?? c("step"),
+    values: e.get("value")
+  });
+  return u[o] = x(u[o], a.min, a.max), u;
+}
+function z(t, n) {
+  const { context: s } = t, e = s.get("value");
+  let c = 0, o = Math.abs(e[0] - n);
+  for (let a = 1; a < e.length; a++) {
+    const u = Math.abs(e[a] - n);
+    u <= o && (c = a, o = u);
+  }
+  return A(t, c);
+}
+function A(t, n) {
+  const { context: s, prop: e } = t, c = s.get("value"), o = e("max");
+  if (c[n] === o) {
+    let u = n;
+    for (; u > 0 && c[u - 1] === o; )
+      u -= 1;
+    return u;
+  }
+  return n;
+}
+export {
+  S as constrainValue,
+  B as decrement,
+  z as getClosestIndex,
+  d as getRangeAtIndex,
+  R as increment,
+  P as normalizeValues,
+  N as resolveThumbCollision,
+  A as selectMovableThumb
+};

package/dist/node_modules/@zag-js/utils/dist/number.js

@@ -1,11 +1,66 @@
-var { min: c, max: i } = Math, o = (a) => Number.isNaN(a), t = (a) => o(a) ? 0 : a, s = (a, n, e) => {
-  const r = t(a), l = n == null || r >= n, u = e == null || r <= e;
-  return l && u;
-}, m = (a, n, e) => c(i(t(a), n), e), N = (a) => typeof a == "number" ? `${a}px` : a;
+var { floor: N, abs: p, round: f, min: h, max: I, pow: S, sign: b } = Math, V = (e) => Number.isNaN(e), s = (e) => V(e) ? 0 : e, x = (e, t, a) => e === 0 ? a : t[e - 1], A = (e, t, a) => e === t.length - 1 ? a : t[e + 1], R = (e, t, a) => {
+  const r = s(e), n = t == null || r >= t, l = a == null || r <= a;
+  return n && l;
+}, P = (e, t, a) => f((s(e) - t) / a) * a + t, m = (e, t, a) => h(I(s(e), t), a), T = (e) => m(e, 0, 1), k = (e, t, a) => (s(e) - t) / (a - t), w = (e, t, a, r) => m(P(e * (a - t) + t, t, r), t, a), i = (e, t) => {
+  let a = e, r = t.toString(), n = r.indexOf("."), l = n >= 0 ? r.length - n : 0;
+  if (l > 0) {
+    let u = S(10, l);
+    a = f(a * u) / u;
+  }
+  return a;
+}, v = (e, t, a, r) => {
+  const n = t != null ? Number(t) : 0, l = Number(a), u = (e - n) % r;
+  let o = p(u) * 2 >= r ? e + b(u) * (r - p(u)) : e - u;
+  if (o = i(o, r), !V(n) && o < n)
+    o = n;
+  else if (!V(l) && o > l) {
+    const c = N((l - n) / r), g = n + c * r;
+    o = c <= 0 || g < n ? l : g;
+  }
+  return i(o, r);
+}, M = (e, t, a) => e[t] === a ? e : [...e.slice(0, t), a, ...e.slice(t + 1)];
+function d(e, t) {
+  const a = x(e, t.values, t.min), r = A(e, t.values, t.max);
+  let n = t.values.slice();
+  return function(u) {
+    let o = v(u, a, r, t.step);
+    return n = M(n, e, u), n[e] = o, n;
+  };
+}
+function C(e, t) {
+  const a = t.values[e] + t.step;
+  return d(e, t)(a);
+}
+function y(e, t) {
+  const a = t.values[e] - t.step;
+  return d(e, t)(a);
+}
+var O = (e, t, a, r) => e.map((n, l) => ({
+  min: l === 0 ? t : e[l - 1] + r,
+  max: l === e.length - 1 ? a : e[l + 1] - r,
+  value: n
+})), W = (e, t) => {
+  const [a, r] = e, [n, l] = t;
+  return (u) => a === r || n === l ? n : n + (l - n) / (r - a) * (u - a);
+}, $ = (e) => typeof e == "number" ? `${e}px` : e;
 export {
+  T as clampPercent,
   m as clampValue,
-  o as isNaN,
-  s as isValueWithinRange,
-  t as nan,
-  N as toPx
+  A as getMaxValueAtIndex,
+  x as getMinValueAtIndex,
+  C as getNextStepValue,
+  w as getPercentValue,
+  y as getPreviousStepValue,
+  k as getValuePercent,
+  O as getValueRanges,
+  d as getValueSetterAtIndex,
+  W as getValueTransformer,
+  V as isNaN,
+  R as isValueWithinRange,
+  s as nan,
+  i as roundToStepPrecision,
+  P as roundValue,
+  M as setValueAtIndex,
+  v as snapValueToStep,
+  $ as toPx
 };

package/dist/node_modules/@zag-js/utils/dist/object.js

@@ -1,13 +1,22 @@
-import { isPlainObject as r } from "./guard.js";
-function f(t) {
-  if (!r(t) || t === void 0) return t;
-  const o = Reflect.ownKeys(t).filter((e) => typeof e == "string"), i = {};
-  for (const e of o) {
+import { isPlainObject as f } from "./guard.js";
+function r(t) {
+  if (!f(t) || t === void 0) return t;
+  const i = Reflect.ownKeys(t).filter((e) => typeof e == "string"), o = {};
+  for (const e of i) {
     const n = t[e];
-    n !== void 0 && (i[e] = f(n));
+    n !== void 0 && (o[e] = r(n));
   }
-  return i;
+  return o;
+}
+function s(t, i) {
+  const o = {};
+  for (const e of i) {
+    const n = t[e];
+    n !== void 0 && (o[e] = n);
+  }
+  return o;
 }
 export {
-  f as compact
+  r as compact,
+  s as pick
 };