@prokodo/ui 0.0.4 → 0.0.6

package/dist/components/Slider-C-lecSwc.js

@@ -0,0 +1,957 @@
+import { j as A } from "./jsx-runtime-C5mzlN2N.js";
+import * as h from "react";
+import { memo as qe, useState as Oe, useCallback as Ce, useEffect as Ye } from "react";
+import { c as Ge } from "./bem-CYKrPjje.js";
+import { L as Xe } from "./Label-DRUCdGoX.js";
+import { g as Be, a as We, u as Je, e as Ee, i as Me, b as X, f as Ae, c as Qe, d as Ze, P as n } from "./ClassNameConfigurator-Ce5BUPXc.js";
+import { u as He } from "./useControlled-BYdyS7Pn.js";
+import { u as Ue, v as et, a as tt } from "./areArraysEqual-CJkStQkx.js";
+function Ve(t, r) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...l) {
+    return t(...l) || r(...l);
+  };
+}
+function he(t) {
+  return t && t.ownerDocument || document;
+}
+function Ie(t) {
+  const r = h.useRef(t);
+  return Ue(() => {
+    r.current = t;
+  }), h.useRef((...u) => (
+    // @ts-expect-error hide `this`
+    (0, r.current)(...u)
+  )).current;
+}
+function ue(t, r = Number.MIN_SAFE_INTEGER, u = Number.MAX_SAFE_INTEGER) {
+  return Math.max(r, Math.min(t, u));
+}
+function Pe(t) {
+  return typeof t == "string";
+}
+function at(t, r, u) {
+  return typeof t == "function" ? t(r, u) : t;
+}
+const $e = "Slider";
+function nt(t) {
+  return We($e, t);
+}
+Be($e, ["root", "active", "focusVisible", "disabled", "dragging", "marked", "vertical", "trackInverted", "trackFalse", "rail", "track", "mark", "markActive", "markLabel", "markLabelActive", "thumb"]);
+const rt = 2;
+function Ke(t, r) {
+  return t - r;
+}
+function Re(t, r) {
+  const {
+    index: u
+  } = t.reduce((l, m, b) => {
+    const x = Math.abs(r - m);
+    return l === null || x < l.distance || x === l.distance ? {
+      distance: x,
+      index: b
+    } : l;
+  }, null) ?? {};
+  return u;
+}
+function ge(t, r) {
+  if (r.current !== void 0 && t.changedTouches) {
+    const u = t;
+    for (let l = 0; l < u.changedTouches.length; l += 1) {
+      const m = u.changedTouches[l];
+      if (m.identifier === r.current)
+        return {
+          x: m.clientX,
+          y: m.clientY
+        };
+    }
+    return !1;
+  }
+  return {
+    x: t.clientX,
+    y: t.clientY
+  };
+}
+function xe(t, r, u) {
+  return (t - r) * 100 / (u - r);
+}
+function ot(t, r, u) {
+  return (u - r) * t + r;
+}
+function st(t) {
+  if (Math.abs(t) < 1) {
+    const u = t.toExponential().split("e-"), l = u[0].split(".")[1];
+    return (l ? l.length : 0) + parseInt(u[1], 10);
+  }
+  const r = t.toString().split(".")[1];
+  return r ? r.length : 0;
+}
+function lt(t, r, u) {
+  const l = Math.round((t - u) / r) * r + u;
+  return Number(l.toFixed(st(r)));
+}
+function je({
+  values: t,
+  newValue: r,
+  index: u
+}) {
+  const l = t.slice();
+  return l[u] = r, l.sort(Ke);
+}
+function ye({
+  sliderRef: t,
+  activeIndex: r,
+  setActive: u
+}) {
+  var m, b, x;
+  const l = he(t.current);
+  (!((m = t.current) != null && m.contains(l.activeElement)) || Number((b = l == null ? void 0 : l.activeElement) == null ? void 0 : b.getAttribute("data-index")) !== r) && ((x = t.current) == null || x.querySelector(`[type="range"][data-index="${r}"]`).focus()), u && u(r);
+}
+function ke(t, r) {
+  return typeof t == "number" && typeof r == "number" ? t === r : typeof t == "object" && typeof r == "object" ? tt(t, r) : !1;
+}
+const it = {
+  horizontal: {
+    offset: (t) => ({
+      left: `${t}%`
+    }),
+    leap: (t) => ({
+      width: `${t}%`
+    })
+  },
+  "horizontal-reverse": {
+    offset: (t) => ({
+      right: `${t}%`
+    }),
+    leap: (t) => ({
+      width: `${t}%`
+    })
+  },
+  vertical: {
+    offset: (t) => ({
+      bottom: `${t}%`
+    }),
+    leap: (t) => ({
+      height: `${t}%`
+    })
+  }
+}, ut = (t) => t;
+let ve;
+function De() {
+  return ve === void 0 && (typeof CSS < "u" && typeof CSS.supports == "function" ? ve = CSS.supports("touch-action", "none") : ve = !0), ve;
+}
+function ct(t) {
+  const {
+    "aria-labelledby": r,
+    defaultValue: u,
+    disabled: l = !1,
+    disableSwap: m = !1,
+    isRtl: b = !1,
+    marks: x = !1,
+    max: S = 100,
+    min: d = 0,
+    name: P,
+    onChange: w,
+    onChangeCommitted: F,
+    orientation: O = "horizontal",
+    rootRef: R,
+    scale: U = ut,
+    step: C = 1,
+    shiftStep: B = 10,
+    tabIndex: ae,
+    value: M
+  } = t, T = h.useRef(void 0), [$, W] = h.useState(-1), [J, Q] = h.useState(-1), [K, ce] = h.useState(!1), Z = h.useRef(0), [g, _] = He({
+    controlled: M,
+    default: u ?? d,
+    name: "Slider"
+  }), V = w && ((e, a, s) => {
+    const c = e.nativeEvent || e, i = new c.constructor(c.type, c);
+    Object.defineProperty(i, "target", {
+      writable: !0,
+      value: {
+        value: a,
+        name: P
+      }
+    }), w(i, a, s);
+  }), z = Array.isArray(g);
+  let p = z ? g.slice().sort(Ke) : [g];
+  p = p.map((e) => e == null ? d : ue(e, d, S));
+  const ne = x === !0 && C !== null ? [...Array(Math.floor((S - d) / C) + 1)].map((e, a) => ({
+    value: d + C * a
+  })) : x || [], I = ne.map((e) => e.value), [fe, q] = h.useState(-1), y = h.useRef(null), re = Je(R, y), oe = (e) => (a) => {
+    var c;
+    const s = Number(a.currentTarget.getAttribute("data-index"));
+    Me(a.target) && q(s), Q(s), (c = e == null ? void 0 : e.onFocus) == null || c.call(e, a);
+  }, Se = (e) => (a) => {
+    var s;
+    Me(a.target) || q(-1), Q(-1), (s = e == null ? void 0 : e.onBlur) == null || s.call(e, a);
+  }, H = (e, a) => {
+    const s = Number(e.currentTarget.getAttribute("data-index")), c = p[s], i = I.indexOf(c);
+    let o = a;
+    if (ne && C == null) {
+      const N = I[I.length - 1];
+      o > N ? o = N : o < I[0] ? o = I[0] : o = o < c ? I[i - 1] : I[i + 1];
+    }
+    if (o = ue(o, d, S), z) {
+      m && (o = ue(o, p[s - 1] || -1 / 0, p[s + 1] || 1 / 0));
+      const N = o;
+      o = je({
+        values: p,
+        newValue: o,
+        index: s
+      });
+      let E = s;
+      m || (E = o.indexOf(N)), ye({
+        sliderRef: y,
+        activeIndex: E
+      });
+    }
+    _(o), q(s), V && !ke(o, g) && V(e, o, s), F && F(e, o);
+  }, L = (e) => (a) => {
+    var s;
+    if (C !== null) {
+      const c = Number(a.currentTarget.getAttribute("data-index")), i = p[c];
+      let o = null;
+      (a.key === "ArrowLeft" || a.key === "ArrowDown") && a.shiftKey || a.key === "PageDown" ? o = Math.max(i - B, d) : ((a.key === "ArrowRight" || a.key === "ArrowUp") && a.shiftKey || a.key === "PageUp") && (o = Math.min(i + B, S)), o !== null && (H(a, o), a.preventDefault());
+    }
+    (s = e == null ? void 0 : e.onKeyDown) == null || s.call(e, a);
+  };
+  Ue(() => {
+    var e;
+    l && y.current.contains(document.activeElement) && ((e = document.activeElement) == null || e.blur());
+  }, [l]), l && $ !== -1 && W(-1), l && fe !== -1 && q(-1);
+  const Te = (e) => (a) => {
+    var s;
+    (s = e.onChange) == null || s.call(e, a), H(a, a.target.valueAsNumber);
+  }, de = h.useRef(void 0);
+  let ee = O;
+  b && O === "horizontal" && (ee += "-reverse");
+  const v = ({
+    finger: e,
+    move: a = !1
+  }) => {
+    const {
+      current: s
+    } = y, {
+      width: c,
+      height: i,
+      bottom: o,
+      left: N
+    } = s.getBoundingClientRect();
+    let E;
+    ee.startsWith("vertical") ? E = (o - e.y) / i : E = (e.x - N) / c, ee.indexOf("-reverse") !== -1 && (E = 1 - E);
+    let f;
+    if (f = ot(E, d, S), C)
+      f = lt(f, C, d);
+    else {
+      const Ne = Re(I, f);
+      f = I[Ne];
+    }
+    f = ue(f, d, S);
+    let G = 0;
+    if (z) {
+      a ? G = de.current : G = Re(p, f), m && (f = ue(f, p[G - 1] || -1 / 0, p[G + 1] || 1 / 0));
+      const Ne = f;
+      f = je({
+        values: p,
+        newValue: f,
+        index: G
+      }), m && a || (G = f.indexOf(Ne), de.current = G);
+    }
+    return {
+      newValue: f,
+      activeIndex: G
+    };
+  }, k = Ie((e) => {
+    const a = ge(e, T);
+    if (!a)
+      return;
+    if (Z.current += 1, e.type === "mousemove" && e.buttons === 0) {
+      j(e);
+      return;
+    }
+    const {
+      newValue: s,
+      activeIndex: c
+    } = v({
+      finger: a,
+      move: !0
+    });
+    ye({
+      sliderRef: y,
+      activeIndex: c,
+      setActive: W
+    }), _(s), !K && Z.current > rt && ce(!0), V && !ke(s, g) && V(e, s, c);
+  }), j = Ie((e) => {
+    const a = ge(e, T);
+    if (ce(!1), !a)
+      return;
+    const {
+      newValue: s
+    } = v({
+      finger: a,
+      move: !0
+    });
+    W(-1), e.type === "touchend" && Q(-1), F && F(e, s), T.current = void 0, Y();
+  }), se = Ie((e) => {
+    if (l)
+      return;
+    De() || e.preventDefault();
+    const a = e.changedTouches[0];
+    a != null && (T.current = a.identifier);
+    const s = ge(e, T);
+    if (s !== !1) {
+      const {
+        newValue: i,
+        activeIndex: o
+      } = v({
+        finger: s
+      });
+      ye({
+        sliderRef: y,
+        activeIndex: o,
+        setActive: W
+      }), _(i), V && !ke(i, g) && V(e, i, o);
+    }
+    Z.current = 0;
+    const c = he(y.current);
+    c.addEventListener("touchmove", k, {
+      passive: !0
+    }), c.addEventListener("touchend", j, {
+      passive: !0
+    });
+  }), Y = h.useCallback(() => {
+    const e = he(y.current);
+    e.removeEventListener("mousemove", k), e.removeEventListener("mouseup", j), e.removeEventListener("touchmove", k), e.removeEventListener("touchend", j);
+  }, [j, k]);
+  h.useEffect(() => {
+    const {
+      current: e
+    } = y;
+    return e.addEventListener("touchstart", se, {
+      passive: De()
+    }), () => {
+      e.removeEventListener("touchstart", se), Y();
+    };
+  }, [Y, se]), h.useEffect(() => {
+    l && Y();
+  }, [l, Y]);
+  const _e = (e) => (a) => {
+    var i;
+    if ((i = e.onMouseDown) == null || i.call(e, a), l || a.defaultPrevented || a.button !== 0)
+      return;
+    a.preventDefault();
+    const s = ge(a, T);
+    if (s !== !1) {
+      const {
+        newValue: o,
+        activeIndex: N
+      } = v({
+        finger: s
+      });
+      ye({
+        sliderRef: y,
+        activeIndex: N,
+        setActive: W
+      }), _(o), V && !ke(o, g) && V(a, o, N);
+    }
+    Z.current = 0;
+    const c = he(y.current);
+    c.addEventListener("mousemove", k, {
+      passive: !0
+    }), c.addEventListener("mouseup", j);
+  }, le = xe(z ? p[0] : d, d, S), Le = xe(p[p.length - 1], d, S) - le, me = (e = {}) => {
+    const a = Ee(e), s = {
+      onMouseDown: _e(a || {})
+    }, c = {
+      ...a,
+      ...s
+    };
+    return {
+      ...e,
+      ref: re,
+      ...c
+    };
+  }, ie = (e) => (a) => {
+    var c;
+    (c = e.onMouseOver) == null || c.call(e, a);
+    const s = Number(a.currentTarget.getAttribute("data-index"));
+    Q(s);
+  }, te = (e) => (a) => {
+    var s;
+    (s = e.onMouseLeave) == null || s.call(e, a), Q(-1);
+  };
+  return {
+    active: $,
+    axis: ee,
+    axisProps: it,
+    dragging: K,
+    focusedThumbIndex: fe,
+    getHiddenInputProps: (e = {}) => {
+      const a = Ee(e), s = {
+        onChange: Te(a || {}),
+        onFocus: oe(a || {}),
+        onBlur: Se(a || {}),
+        onKeyDown: L(a || {})
+      }, c = {
+        ...a,
+        ...s
+      };
+      return {
+        tabIndex: ae,
+        "aria-labelledby": r,
+        "aria-orientation": O,
+        "aria-valuemax": U(S),
+        "aria-valuemin": U(d),
+        name: P,
+        type: "range",
+        min: t.min,
+        max: t.max,
+        step: t.step === null && t.marks ? "any" : t.step ?? void 0,
+        disabled: l,
+        ...e,
+        ...c,
+        style: {
+          ...et,
+          direction: b ? "rtl" : "ltr",
+          // So that VoiceOver's focus indicator matches the thumb's dimensions
+          width: "100%",
+          height: "100%"
+        }
+      };
+    },
+    getRootProps: me,
+    getThumbProps: (e = {}) => {
+      const a = Ee(e), s = {
+        onMouseOver: ie(a || {}),
+        onMouseLeave: te(a || {})
+      };
+      return {
+        ...e,
+        ...a,
+        ...s
+      };
+    },
+    marks: ne,
+    open: J,
+    range: z,
+    rootRef: re,
+    trackLeap: Le,
+    trackOffset: le,
+    values: p,
+    getThumbStyle: (e) => ({
+      // So the non active thumb doesn't show its label on hover.
+      pointerEvents: $ !== -1 && $ !== e ? "none" : void 0
+    })
+  };
+}
+function Fe(t) {
+  return t;
+}
+const ft = (t) => {
+  const {
+    disabled: r,
+    dragging: u,
+    marked: l,
+    orientation: m,
+    track: b
+  } = t;
+  return Qe({
+    root: ["root", r && "disabled", u && "dragging", l && "marked", m === "vertical" && "vertical", b === "inverted" && "trackInverted", b === !1 && "trackFalse"],
+    rail: ["rail"],
+    track: ["track"],
+    mark: ["mark"],
+    markActive: ["markActive"],
+    markLabel: ["markLabel"],
+    markLabelActive: ["markLabelActive"],
+    valueLabel: ["valueLabel"],
+    thumb: ["thumb", r && "disabled"],
+    active: ["active"],
+    disabled: ["disabled"],
+    focusVisible: ["focusVisible"]
+  }, Ze(nt));
+}, ze = /* @__PURE__ */ h.forwardRef(function(r, u) {
+  const {
+    "aria-label": l,
+    "aria-valuetext": m,
+    "aria-labelledby": b,
+    className: x,
+    disableSwap: S = !1,
+    disabled: d = !1,
+    getAriaLabel: P,
+    getAriaValueText: w,
+    marks: F = !1,
+    max: O = 100,
+    min: R = 0,
+    name: U,
+    onChange: C,
+    onChangeCommitted: B,
+    orientation: ae = "horizontal",
+    shiftStep: M = 10,
+    scale: T = Fe,
+    step: $ = 1,
+    tabIndex: W,
+    track: J = "normal",
+    value: Q,
+    valueLabelFormat: K = Fe,
+    isRtl: ce = !1,
+    defaultValue: Z,
+    slotProps: g = {},
+    slots: _ = {},
+    ...V
+  } = r, z = {
+    ...r,
+    marks: F,
+    disabled: d,
+    disableSwap: S,
+    isRtl: ce,
+    defaultValue: Z,
+    max: O,
+    min: R,
+    orientation: ae,
+    scale: T,
+    step: $,
+    shiftStep: M,
+    track: J,
+    valueLabelFormat: K
+  }, {
+    axisProps: p,
+    getRootProps: ne,
+    getHiddenInputProps: I,
+    getThumbProps: fe,
+    active: q,
+    axis: y,
+    range: re,
+    focusedThumbIndex: oe,
+    dragging: Se,
+    marks: H,
+    values: L,
+    trackOffset: Te,
+    trackLeap: de,
+    getThumbStyle: ee
+  } = ct({
+    ...z,
+    rootRef: u
+  }), v = {
+    ...z,
+    marked: H.length > 0 && H.some((i) => i.label),
+    dragging: Se,
+    focusedThumbIndex: oe,
+    activeThumbIndex: q
+  }, k = ft(v), j = _.root ?? "span", se = X({
+    elementType: j,
+    getSlotProps: ne,
+    externalSlotProps: g.root,
+    externalForwardedProps: V,
+    ownerState: v,
+    className: [k.root, x]
+  }), Y = _.rail ?? "span", _e = X({
+    elementType: Y,
+    externalSlotProps: g.rail,
+    ownerState: v,
+    className: k.rail
+  }), le = _.track ?? "span", Le = X({
+    elementType: le,
+    externalSlotProps: g.track,
+    additionalProps: {
+      style: {
+        ...p[y].offset(Te),
+        ...p[y].leap(de)
+      }
+    },
+    ownerState: v,
+    className: k.track
+  }), me = _.thumb ?? "span", ie = X({
+    elementType: me,
+    getSlotProps: fe,
+    externalSlotProps: g.thumb,
+    ownerState: v,
+    skipResolvingSlotProps: !0
+  }), te = _.valueLabel, we = X({
+    elementType: te,
+    externalSlotProps: g.valueLabel,
+    ownerState: v
+  }), pe = _.mark ?? "span", be = X({
+    elementType: pe,
+    externalSlotProps: g.mark,
+    ownerState: v,
+    className: k.mark
+  }), e = _.markLabel ?? "span", a = X({
+    elementType: e,
+    externalSlotProps: g.markLabel,
+    ownerState: v
+  }), s = _.input || "input", c = X({
+    elementType: s,
+    getSlotProps: I,
+    externalSlotProps: g.input,
+    ownerState: v
+  });
+  return /* @__PURE__ */ A.jsxs(j, {
+    ...se,
+    children: [/* @__PURE__ */ A.jsx(Y, {
+      ..._e
+    }), /* @__PURE__ */ A.jsx(le, {
+      ...Le
+    }), H.filter((i) => i.value >= R && i.value <= O).map((i, o) => {
+      const N = xe(i.value, R, O), E = p[y].offset(N);
+      let f;
+      return J === !1 ? f = L.indexOf(i.value) !== -1 : f = J === "normal" && (re ? i.value >= L[0] && i.value <= L[L.length - 1] : i.value <= L[0]) || J === "inverted" && (re ? i.value <= L[0] || i.value >= L[L.length - 1] : i.value >= L[0]), /* @__PURE__ */ A.jsxs(h.Fragment, {
+        children: [/* @__PURE__ */ A.jsx(pe, {
+          "data-index": o,
+          ...be,
+          ...!Pe(pe) && {
+            markActive: f
+          },
+          style: {
+            ...E,
+            ...be.style
+          },
+          className: Ae(be.className, f && k.markActive)
+        }), i.label != null ? /* @__PURE__ */ A.jsx(e, {
+          "aria-hidden": !0,
+          "data-index": o,
+          ...a,
+          ...!Pe(e) && {
+            markLabelActive: f
+          },
+          style: {
+            ...E,
+            ...a.style
+          },
+          className: Ae(k.markLabel, a.className, f && k.markLabelActive),
+          children: i.label
+        }) : null]
+      }, o);
+    }), L.map((i, o) => {
+      const N = xe(i, R, O), E = p[y].offset(N), f = at(g.thumb, v, {
+        index: o,
+        focused: oe === o,
+        active: q === o
+      });
+      return /* @__PURE__ */ A.jsxs(me, {
+        "data-index": o,
+        ...ie,
+        ...f,
+        className: Ae(k.thumb, ie.className, f == null ? void 0 : f.className, q === o && k.active, oe === o && k.focusVisible),
+        style: {
+          ...E,
+          ...ee(o),
+          ...ie.style,
+          ...f == null ? void 0 : f.style
+        },
+        children: [/* @__PURE__ */ A.jsx(s, {
+          "data-index": o,
+          "aria-label": P ? P(o) : l,
+          "aria-valuenow": T(i),
+          "aria-labelledby": b,
+          "aria-valuetext": w ? w(T(i), o) : m,
+          value: L[o],
+          ...c
+        }), te ? /* @__PURE__ */ A.jsx(te, {
+          ...!Pe(te) && {
+            valueLabelFormat: K,
+            index: o,
+            disabled: d
+          },
+          ...we,
+          children: typeof K == "function" ? K(T(i), o) : K
+        }) : null]
+      }, o);
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (ze.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The label of the slider.
+   */
+  "aria-label": Ve(n.string, (t) => Array.isArray(t.value || t.defaultValue) && t["aria-label"] != null ? new Error("MUI: You need to use the `getAriaLabel` prop instead of `aria-label` when using a range slider.") : null),
+  /**
+   * The id of the element containing a label for the slider.
+   */
+  "aria-labelledby": n.string,
+  /**
+   * A string value that provides a user-friendly name for the current value of the slider.
+   */
+  "aria-valuetext": Ve(n.string, (t) => Array.isArray(t.value || t.defaultValue) && t["aria-valuetext"] != null ? new Error("MUI: You need to use the `getAriaValueText` prop instead of `aria-valuetext` when using a range slider.") : null),
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: n.oneOfType([n.arrayOf(n.number), n.number]),
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: n.bool,
+  /**
+   * If `true`, the active thumb doesn't swap when moving pointer over a thumb while dragging another thumb.
+   * @default false
+   */
+  disableSwap: n.bool,
+  /**
+   * Accepts a function which returns a string value that provides a user-friendly name for the thumb labels of the slider.
+   * This is important for screen reader users.
+   * @param {number} index The thumb label's index to format.
+   * @returns {string}
+   */
+  getAriaLabel: n.func,
+  /**
+   * Accepts a function which returns a string value that provides a user-friendly name for the current value of the slider.
+   * This is important for screen reader users.
+   * @param {number} value The thumb label's value to format.
+   * @param {number} index The thumb label's index to format.
+   * @returns {string}
+   */
+  getAriaValueText: n.func,
+  /**
+   * If `true` the Slider will be rendered right-to-left (with the lowest value on the right-hand side).
+   * @default false
+   */
+  isRtl: n.bool,
+  /**
+   * Marks indicate predetermined values to which the user can move the slider.
+   * If `true` the marks are spaced according the value of the `step` prop.
+   * If an array, it should contain objects with `value` and an optional `label` keys.
+   * @default false
+   */
+  marks: n.oneOfType([n.arrayOf(n.shape({
+    label: n.node,
+    value: n.number.isRequired
+  })), n.bool]),
+  /**
+   * The maximum allowed value of the slider.
+   * Should not be equal to min.
+   * @default 100
+   */
+  max: n.number,
+  /**
+   * The minimum allowed value of the slider.
+   * Should not be equal to max.
+   * @default 0
+   */
+  min: n.number,
+  /**
+   * Name attribute of the hidden `input` element.
+   */
+  name: n.string,
+  /**
+   * Callback function that is fired when the slider's value changed.
+   *
+   * @param {Event} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (any).
+   * **Warning**: This is a generic event not a change event.
+   * @param {number | number[]} value The new value.
+   * @param {number} activeThumb Index of the currently moved thumb.
+   */
+  onChange: n.func,
+  /**
+   * Callback function that is fired when the `mouseup` is triggered.
+   *
+   * @param {React.SyntheticEvent | Event} event The event source of the callback. **Warning**: This is a generic event not a change event.
+   * @param {number | number[]} value The new value.
+   */
+  onChangeCommitted: n.func,
+  /**
+   * The component orientation.
+   * @default 'horizontal'
+   */
+  orientation: n.oneOf(["horizontal", "vertical"]),
+  /**
+   * A transformation function, to change the scale of the slider.
+   * @param {any} x
+   * @returns {any}
+   * @default function Identity(x) {
+   *   return x;
+   * }
+   */
+  scale: n.func,
+  /**
+   * The granularity with which the slider can step through values when using Page Up/Page Down or Shift + Arrow Up/Arrow Down.
+   * @default 10
+   */
+  shiftStep: n.number,
+  /**
+   * The props used for each slot inside the Slider.
+   * @default {}
+   */
+  slotProps: n.shape({
+    input: n.oneOfType([n.func, n.object]),
+    mark: n.oneOfType([n.func, n.object]),
+    markLabel: n.oneOfType([n.func, n.object]),
+    rail: n.oneOfType([n.func, n.object]),
+    root: n.oneOfType([n.func, n.object]),
+    thumb: n.oneOfType([n.func, n.object]),
+    track: n.oneOfType([n.func, n.object]),
+    valueLabel: n.oneOfType([n.any, n.func])
+  }),
+  /**
+   * The components used for each slot inside the Slider.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: n.shape({
+    input: n.elementType,
+    mark: n.elementType,
+    markLabel: n.elementType,
+    rail: n.elementType,
+    root: n.elementType,
+    thumb: n.elementType,
+    track: n.elementType,
+    valueLabel: n.elementType
+  }),
+  /**
+   * The granularity with which the slider can step through values. (A "discrete" slider.)
+   * The `min` prop serves as the origin for the valid values.
+   * We recommend (max - min) to be evenly divisible by the step.
+   *
+   * When step is `null`, the thumb can only be slid onto marks provided with the `marks` prop.
+   * @default 1
+   */
+  step: n.number,
+  /**
+   * Tab index attribute of the hidden `input` element.
+   */
+  tabIndex: n.number,
+  /**
+   * The track presentation:
+   *
+   * - `normal` the track will render a bar representing the slider value.
+   * - `inverted` the track will render a bar representing the remaining slider value.
+   * - `false` the track will render without a bar.
+   * @default 'normal'
+   */
+  track: n.oneOf(["inverted", "normal", !1]),
+  /**
+   * The value of the slider.
+   * For ranged sliders, provide an array with two values.
+   */
+  value: n.oneOfType([n.arrayOf(n.number), n.number]),
+  /**
+   * The format function the value label's value.
+   *
+   * When a function is provided, it should have the following signature:
+   *
+   * - {number} value The value label's value to format
+   * - {number} index The value label's index to format
+   * @param {any} x
+   * @returns {any}
+   * @default function Identity(x) {
+   *   return x;
+   * }
+   */
+  valueLabelFormat: n.oneOfType([n.func, n.string])
+});
+const dt = "gradientMove", mt = "fadeInKeyframe", pt = {
+  "prokodo-Slider": "prokodo-Slider",
+  "prokodo-Slider__label": "prokodo-Slider__label",
+  "prokodo-Slider__root": "prokodo-Slider__root",
+  "prokodo-Slider__root--disabled": "prokodo-Slider__root--disabled",
+  "prokodo-Slider__rail": "prokodo-Slider__rail",
+  "prokodo-Slider__track": "prokodo-Slider__track",
+  "prokodo-Slider__thumb": "prokodo-Slider__thumb",
+  "prokodo-Slider__thumb--focused": "prokodo-Slider__thumb--focused",
+  "prokodo-Slider__mark": "prokodo-Slider__mark",
+  "prokodo-Slider__mark__label": "prokodo-Slider__mark__label",
+  "prokodo-Slider__valueText": "prokodo-Slider__valueText",
+  gradientMove: dt,
+  fadeInKeyframe: mt
+}, D = Ge(pt, "Slider"), bt = qe(
+  ({
+    id: t,
+    className: r,
+    required: u,
+    value: l,
+    label: m,
+    labelProps: b,
+    valueLabelProps: x,
+    disabled: S,
+    onFocus: d,
+    onBlur: P,
+    onChange: w,
+    ...F
+  }) => {
+    const [O, R] = Oe(
+      Number(l) ?? 0
+    ), [U, C] = Oe(!1), B = Ce(
+      (M) => {
+        C(!U), U ? P == null || P(M) : d == null || d(M);
+      },
+      [U, d, P]
+    );
+    Ye(() => {
+      l !== void 0 && R(Number(l));
+    }, [l]);
+    const ae = Ce(
+      (M, T, $) => {
+        R(T), w == null || w(M, T, $);
+      },
+      [w]
+    );
+    return /* @__PURE__ */ A.jsxs("div", { className: D(void 0, void 0, r), children: [
+      /* @__PURE__ */ A.jsx(
+        Xe,
+        {
+          ...b,
+          className: D("label"),
+          htmlFor: t,
+          label: m,
+          required: u
+        }
+      ),
+      /* @__PURE__ */ A.jsx(
+        ze,
+        {
+          marks: !0,
+          "aria-label": m,
+          id: t,
+          ...F,
+          disabled: S,
+          value: O,
+          slotProps: {
+            root: {
+              className: D("root", {
+                disabled: !!S
+              })
+            },
+            rail: {
+              className: D("rail")
+            },
+            track: {
+              className: D("track")
+            },
+            thumb: {
+              className: D("thumb", {
+                focused: U
+              })
+            },
+            mark: {
+              className: D("mark")
+            },
+            markLabel: {
+              className: D("mark__label")
+            }
+          },
+          slots: {
+            valueLabel: ({ children: M }) => /* @__PURE__ */ A.jsx(
+              "span",
+              {
+                ...x,
+                className: D("valueText", void 0, b == null ? void 0 : b.className),
+                children: M
+              }
+            )
+          },
+          onBlur: B,
+          onChange: ae,
+          onFocus: B
+        }
+      )
+    ] });
+  }
+);
+bt.displayName = "Slider";
+export {
+  bt as S
+};