@unicom-cloud/ui 0.8.41

package/Slider.js

@@ -0,0 +1,784 @@
+import { jsx as I, jsxs as gt } from "react/jsx-runtime";
+import { a as Dt } from "./chunk/Bl5t8Z6F.js";
+import "./chunk/DP2rzg_V.js";
+import "./chunk/C6Kfwj0f.js";
+import "./chunk/RnTpOC5-.js";
+import se from "./Trigger.js";
+import "./Tooltip.js";
+import { minus as pt, times as wt, plus as ot, divide as Rt } from "@unicom-cloud/utils/math";
+import ht from "lodash/isArray";
+import L from "lodash/isFunction";
+import rt from "lodash/isPlainObject";
+import _, { useState as St, useContext as Et, useMemo as Z, useRef as S, useEffect as Lt, createElement as Tt, useCallback as H, forwardRef as ae } from "react";
+import { a as Bt } from "./chunk/Dc_89PVN.js";
+import ue from "./hooks/useMergeProps.js";
+import Ft from "./hooks/useMergeValue.js";
+import le from "./hooks/useUpdateEffect.js";
+import Y from "@unicom-cloud/utils/class-name";
+import { on as U, off as W } from "./utils/dom.js";
+import ce from "./utils/omit.js";
+import nt from "lodash/isNumber";
+import fe from "lodash/isString";
+import me from "./hooks/useKeyboardEvent.js";
+import { isEmptyObject as de } from "@unicom-cloud/utils/is";
+import ge from "lodash/isUndefined";
+const pe = { maxWidth: 350 }, he = {
+  enter: 300,
+  exit: 100
+}, ve = {
+  left: 12,
+  right: 12,
+  top: 12,
+  bottom: 12
+}, we = function(t) {
+  const {
+    style: o,
+    disabled: n,
+    prefixCls: r,
+    value: s,
+    vertical: d,
+    tooltipVisible: k,
+    tooltipPosition: m,
+    formatTooltip: b,
+    getTooltipContainer: c,
+    onMoving: V,
+    onMoveEnd: h,
+    onMoveBegin: f
+  } = t, e = me(), [g, w] = St(!1), [v, i] = Ft(!1, {
+    value: k
+  }), { getPrefixCls: u } = Et(Bt), M = Z(
+    () => m || (d ? "right" : "top"),
+    [m, d]
+  ), T = S(null), K = S(!1), z = S(!1), P = S(null);
+  function at(C) {
+    C.stopPropagation(), !n && (it(C), w(!0), U(window, "mousemove", E), U(window, "touchmove", E), U(window, "mouseup", R), U(window, "touchend", R), U(window, "contextmenu", R));
+  }
+  function O() {
+    K.current = !0, J(), v || (T.current = setTimeout(() => {
+      j(!0);
+    }, 50));
+  }
+  function D() {
+    K.current = !1, z.current || (J(), T.current = setTimeout(() => {
+      j(!1);
+    }, 200));
+  }
+  function it(C) {
+    var B;
+    C.preventDefault();
+    const N = document.activeElement;
+    (B = N == null ? void 0 : N.blur) == null || B.call(N), L(f) && f();
+  }
+  function E(C) {
+    z.current = !0, C.type === "touchstart" && (C.clientY = C.touches[0].clientY, C.clientX = C.touches[0].clientX), L(V) && V(C.clientX, C.clientY);
+  }
+  function R() {
+    z.current = !1, w(!1), ut(), j(K.current), L(h) && h();
+  }
+  function ut() {
+    J(), W(window, "mousemove", E), W(window, "touchmove", E), W(window, "mouseup", R), W(window, "touchend", R), W(window, "contextmenu", R);
+  }
+  function J() {
+    T.current && (clearTimeout(T.current), T.current = null);
+  }
+  function j(C) {
+    if (z.current)
+      return;
+    const N = "tooltipVisible" in t ? k : C;
+    i(N);
+  }
+  function lt() {
+    K.current = !0, J();
+  }
+  const x = Z(() => L(b) ? b(s) : s, [b, s]);
+  function tt(C) {
+    const N = u("tooltip");
+    return /* @__PURE__ */ I(
+      "div",
+      {
+        className: Y(
+          `${N}-content`,
+          `${N}-content-${C}`
+        ),
+        onMouseLeave: D,
+        onMouseEnter: lt,
+        onClick: (B) => {
+          B.stopPropagation();
+        },
+        children: /* @__PURE__ */ I("div", { className: `${N}-content-inner`, children: x })
+      }
+    );
+  }
+  return Lt(() => {
+    P && P.current && P.current.updatePopupPosition();
+  }, [s]), /* @__PURE__ */ I(
+    se,
+    {
+      style: pe,
+      classNames: "zoomInFadeOut",
+      duration: he,
+      showArrow: !0,
+      popupAlign: ve,
+      ref: P,
+      popup: () => tt(M),
+      popupVisible: v,
+      disabled: k === !1,
+      getPopupContainer: c,
+      position: M,
+      childrenPrefix: u("tooltip"),
+      children: /* @__PURE__ */ I(
+        "div",
+        {
+          className: Y(`${r}-button`, {
+            [`${r}-button-active`]: g
+          }),
+          onMouseDown: at,
+          onMouseEnter: O,
+          onMouseLeave: D,
+          style: o,
+          role: "slider",
+          "aria-valuemax": t.maxValue,
+          "aria-valuemin": t.minValue,
+          "aria-valuenow": s,
+          "aria-disabled": !!n,
+          tabIndex: n ? -1 : 0,
+          "aria-valuetext": fe(x) || nt(x) ? String(x) : void 0,
+          ...e({
+            onArrowRight: (C) => {
+              var N;
+              C.preventDefault(), (N = t.onArrowEvent) == null || N.call(t, "addition");
+            },
+            onArrowUp: (C) => {
+              var N;
+              C.preventDefault(), (N = t.onArrowEvent) == null || N.call(t, "addition");
+            },
+            onArrowLeft: (C) => {
+              var N;
+              C.preventDefault(), (N = t.onArrowEvent) == null || N.call(t, "subtraction");
+            },
+            onArrowDown: (C) => {
+              var N;
+              C.preventDefault(), (N = t.onArrowEvent) == null || N.call(t, "subtraction");
+            }
+          })
+        }
+      )
+    }
+  );
+}, be = _.memo(we);
+function Ve(t) {
+  const o = `${t}`.split(".")[1];
+  return o && o.length || 0;
+}
+function X(t) {
+  return `${t * 100}%`;
+}
+function Me(t, o) {
+  const n = Number(t);
+  if (o && !isNaN(n)) {
+    const [r, s] = o;
+    return Rt(pt(n, r), pt(s, r));
+  }
+  return 0;
+}
+function jt(t, o) {
+  const n = Number(t);
+  return o.sort((r, s) => r - s), n >= o[0] && n <= o[1];
+}
+function dt(t) {
+  return t || t === 0;
+}
+function Ce(t) {
+  const o = parseFloat(t), n = o > 1 ? (o / 100).toFixed(2) : o, r = parseFloat(n);
+  if (!isNaN(r) && r >= 0 && r <= 1)
+    return r;
+}
+function Q(t, o) {
+  const n = o.find(
+    (r) => t >= r.begin && t <= r.end
+  );
+  if (n) {
+    const { beginOffset: r, begin: s, end: d, endOffset: k } = n, m = Me(t, [s, d]), b = pt(k, r), c = wt(m, b);
+    return ot(r, c);
+  }
+}
+function vt(t) {
+  const o = t.slice(0);
+  return o.sort((n, r) => n - r), o;
+}
+function xe(t) {
+  return t.some((o, n) => o > t[n + 1]);
+}
+function Ne(t, o) {
+  let n = o.indexOf(t);
+  return n === -1 ? (n = vt(o.concat(t)).indexOf(t), [
+    Math.max(n - 1, 0),
+    Math.min(n, o.length - 1)
+  ]) : [n, n + 1];
+}
+const ke = function(t) {
+  const {
+    data: o = [],
+    valueRange: n = [],
+    vertical: r,
+    prefixCls: s,
+    reverse: d,
+    intervalConfigs: k
+  } = t;
+  return o.length ? /* @__PURE__ */ I("div", { className: `${s}-dots`, children: o.map(({ key: m, content: b }) => {
+    const c = X(Q(+m, k));
+    return /* @__PURE__ */ I(
+      "div",
+      {
+        className: `${s}-dot-wrapper`,
+        style: {
+          ...r ? { [d ? "top" : "bottom"]: c } : { [d ? "right" : "left"]: c }
+        },
+        onMouseDown: (V) => {
+          V.stopPropagation(), L(t.onMouseDown) && t.onMouseDown(parseFloat(m));
+        },
+        children: rt(b) && b.dot ? b.dot : /* @__PURE__ */ I(
+          "div",
+          {
+            className: Y(`${s}-dot`, {
+              [`${s}-dot-active`]: jt(m, n)
+            })
+          }
+        )
+      },
+      m
+    );
+  }) }) : null;
+}, Ie = _.memo(ke), ye = function(t) {
+  const {
+    value: o,
+    range: n,
+    min: r,
+    max: s,
+    step: d,
+    disabled: k,
+    prefixCls: m,
+    onChange: b,
+    extra: c = []
+  } = t, V = {
+    min: r,
+    max: s,
+    step: d,
+    disabled: k
+  }, [h, f] = St(o), e = c[0], g = n ? c[1] : c[0];
+  Lt(() => {
+    f(o);
+  }, [o]);
+  const w = (i) => {
+    b == null || b(i);
+  }, v = () => {
+    f([...o].sort((i, u) => i - u));
+  };
+  return /* @__PURE__ */ gt(
+    "div",
+    {
+      className: Y(`${m}-input`, {
+        [`${m}-input-group`]: n
+      }),
+      onBlur: v,
+      children: [
+        n && [
+          /* @__PURE__ */ Tt(
+            Dt,
+            {
+              hideControl: !0,
+              ...e,
+              ...V,
+              value: h[0],
+              key: 0,
+              onChange: (i, u) => {
+                var M;
+                isNaN(i) && i !== i || (w([i, h[1]]), (M = e == null ? void 0 : e.onChange) == null || M.call(e, i, u));
+              }
+            }
+          ),
+          /* @__PURE__ */ I("div", { className: `${m}-input-range`, children: /* @__PURE__ */ I("span", { className: `${m}-input-range-content` }) }, 1)
+        ],
+        /* @__PURE__ */ Tt(
+          Dt,
+          {
+            hideControl: !0,
+            ...g,
+            ...V,
+            key: 2,
+            value: h[1],
+            onChange: (i, u) => {
+              var M;
+              isNaN(i) && i !== i || (w([h[0], i]), (M = g == null ? void 0 : g.onChange) == null || M.call(g, i, u));
+            }
+          }
+        )
+      ]
+    }
+  );
+}, $e = _.memo(ye), Oe = function(t) {
+  const { data: o = [], vertical: n, prefixCls: r, reverse: s, intervalConfigs: d } = t;
+  return o.length ? /* @__PURE__ */ I("div", { className: `${r}-marks`, children: o.map(({ key: k, content: m }) => {
+    const b = X(Q(+k, d));
+    let c = null;
+    return rt(m) && dt(m.text) ? c = m.text : dt(m) && (c = m), dt(c) && /* @__PURE__ */ I(
+      "div",
+      {
+        className: `${r}-marks-text`,
+        "aria-hidden": !0,
+        style: n ? { [s ? "top" : "bottom"]: b } : { [s ? "right" : "left"]: b },
+        onMouseDown: (V) => {
+          V.stopPropagation(), L(t.onMouseDown) && t.onMouseDown(parseFloat(k));
+        },
+        children: c
+      },
+      k
+    );
+  }) }) : null;
+}, Pe = _.memo(Oe);
+function Ae(t) {
+  const {
+    min: o,
+    max: n,
+    valueRange: r,
+    prefixCls: s,
+    vertical: d,
+    reverse: k,
+    intervalConfigs: m
+  } = t, b = /* @__PURE__ */ new Map(), c = (h) => {
+    const { step: f, begin: e, end: g } = h, w = Math.floor((g - e) / f);
+    for (let v = 0; v <= w; v++) {
+      const i = ot(v * f, e);
+      if (i <= o || i >= n)
+        continue;
+      const u = X(Q(i, m));
+      b.set(u, {
+        offset: u,
+        isActive: jt(i, r)
+      });
+    }
+  }, V = Z(() => {
+    var h;
+    return b.clear(), (h = m == null ? void 0 : m.forEach) == null || h.call(m, (f) => c(f)), Array.from(b.values());
+  }, [m]);
+  return /* @__PURE__ */ I("div", { className: `${s}-ticks`, children: V.map((h, f) => /* @__PURE__ */ I(
+    "div",
+    {
+      className: Y(`${s}-tick`, {
+        [`${s}-tick-active`]: h.isActive
+      }),
+      style: d ? { [k ? "top" : "bottom"]: h.offset } : { [k ? "right" : "left"]: h.offset }
+    },
+    f
+  )) });
+}
+const De = _.memo(Ae);
+function Te(t) {
+  if (t.length < 2)
+    return [];
+  const o = [];
+  for (let n = 1; n < t.length; n++) {
+    const r = t[n - 1], s = t[n];
+    o.push([r, s]);
+  }
+  return o;
+}
+function Re(t) {
+  const { marks: o = {}, getIntervalConfig: n, max: r, min: s } = t, { markIntervals: d, markList: k } = Z(() => {
+    const b = Object.keys(o).filter((f) => nt(+f) && +f >= s && +f <= r).sort((f, e) => +f > +e ? 1 : -1), c = b.map((f) => ({ key: f, content: o[f] }));
+    let V = b.map((f) => +f);
+    return V.length === 0 ? V = [s, r] : (V[0] > s && (V.unshift(s), c.unshift({ key: `${s}`, content: "" })), V.slice(-1)[0] < r && (V.push(r), c.push({ key: `${r}`, content: "" }))), { markIntervals: Te(V), markList: c };
+  }, [o, s, r]);
+  return {
+    intervalConfigs: Z(() => {
+      if (!L(n))
+        return [
+          {
+            begin: s,
+            end: r,
+            step: t.step,
+            beginOffset: 0,
+            endOffset: 1,
+            width: 1
+          }
+        ];
+      const b = ([e, g], w) => {
+        const v = { step: t.step, width: 0 }, i = n([e, g], w) || {}, u = i.step, M = Ce(i.width);
+        return nt(u) && u && (v.step = u), nt(M) && M && (v.width = M), v;
+      };
+      let c = 1, V = r - s;
+      const h = d.map(([e, g], w) => {
+        const v = b([e, g], w);
+        let i = v.width;
+        if (i) {
+          i = Math.min(c, i);
+          const u = g - e;
+          V -= u, c -= i;
+        }
+        return { width: i, step: v.step };
+      });
+      if (h.every(({ width: e }) => e) && c) {
+        const e = h[d.length - 1];
+        e.width += c;
+      }
+      const f = [];
+      return d.forEach(([e, g], w) => {
+        const { step: v, width: i } = h[w], u = {
+          begin: e,
+          end: g,
+          step: v,
+          beginOffset: 0,
+          endOffset: 0,
+          width: i
+        };
+        u.width || (u.width = c * ((g - e) / V));
+        const M = f.length - 1;
+        f[M] && (u.beginOffset = f[M].endOffset), u.endOffset = Math.min(1, u.beginOffset + u.width), f.push(u);
+      }), f;
+    }, [n, d, r, s, t.step]),
+    markList: k
+  };
+}
+function Se(t) {
+  const { isRange: o, min: n, max: r, onlyMarkValue: s, intervalConfigs: d, marks: k } = t, m = H(
+    (e) => {
+      const g = d.find((w) => e >= w.begin && e <= w.end);
+      if (g) {
+        const { begin: w, step: v } = g, i = e - w, u = Math.round(i / v), M = Ve(v), T = parseFloat(
+          wt(v, u).toFixed(M)
+        );
+        return ot(w, T);
+      }
+      return e;
+    },
+    [d]
+  ), b = H(
+    (e) => {
+      if (!rt(k) || de(k))
+        return console.warn("marks must be an object when onlyMarkValue is true"), n;
+      if (k[e])
+        return e;
+      const g = Object.keys(k), w = g.map((i) => Math.abs(e - parseFloat(i))), v = w.indexOf(Math.min.apply(null, w));
+      return parseFloat(g[v]);
+    },
+    [k, n]
+  ), c = H(
+    (e) => ge(e) || e <= n ? n : e >= r ? r : s ? b(e) : m(e),
+    [b, m, r, n, s]
+  ), V = H(
+    (e) => c(e) === e,
+    [c]
+  ), h = H(
+    (e) => {
+      let [g, w] = [n, n];
+      if (o) {
+        if (ht(e))
+          return g = c(e[0]), e.map((v) => c(v));
+        console.error("value must be an array when range is true");
+      } else
+        nt(e) ? w = c(e) : console.error("value must be a number when range is false");
+      return [g, w];
+    },
+    [c, o, n]
+  ), f = H(
+    (e, g) => {
+      const w = g === "subtraction" ? -1 : 1;
+      let v = ot(e, w * t.step);
+      if (t.onlyMarkValue) {
+        const i = Object.keys(t.marks), u = i.findIndex((M) => Number(M) === e);
+        v = i[u + w] !== void 0 ? Number(i[u + w]) : e;
+      }
+      return v;
+    },
+    [t.marks, t.onlyMarkValue, t.step]
+  );
+  return {
+    getLegalRangeValue: h,
+    getLegalValue: c,
+    isLegalValue: V,
+    getNextMarkValue: f
+  };
+}
+const Ee = {
+  max: 100,
+  min: 0,
+  step: 1
+};
+function Le(t, o) {
+  const { getPrefixCls: n, componentConfig: r, rtl: s } = Et(Bt), d = ue(
+    t,
+    Ee,
+    r == null ? void 0 : r.Slider
+  ), {
+    className: k,
+    style: m,
+    tooltipVisible: b,
+    tooltipPosition: c,
+    disabled: V,
+    min: h,
+    max: f,
+    range: e,
+    step: g,
+    showTicks: w,
+    marks: v,
+    onlyMarkValue: i,
+    vertical: u,
+    showInput: M,
+    reverse: T,
+    getIntervalConfig: K,
+    ...z
+  } = d, P = !!e, at = rt(e) ? { ...e } : { draggableBar: !1 }, O = s ? !T : T, { intervalConfigs: D, markList: it } = Re({
+    min: h,
+    max: f,
+    onlyMarkValue: i,
+    step: g,
+    marks: v,
+    getIntervalConfig: K
+  }), { getLegalValue: E, getLegalRangeValue: R, isLegalValue: ut, getNextMarkValue: J } = Se({
+    isRange: P,
+    min: h,
+    max: f,
+    onlyMarkValue: i,
+    step: g,
+    intervalConfigs: D,
+    marks: v
+  }), [j, lt] = Ft(
+    P ? [h, h] : h,
+    {
+      defaultValue: d.defaultValue,
+      value: d.value
+    }
+  );
+  let x = R(j);
+  const tt = S(x), C = S(xe(x));
+  le(() => {
+    tt.current = R(j);
+  }, [j, R]), C.current && (x = vt(x));
+  const N = x[x.length - 1], B = x[0], ct = M && !i && (!P || x.length < 3), Wt = Z(() => ct && (ht(M) || rt(M)) ? ht(M) ? [...M] : [{ ...M }, { ...M }] : [], [ct, M]), $ = n("slider"), bt = S(null), Vt = S({
+    left: 0,
+    height: 0,
+    top: 0,
+    width: 0
+  }), Mt = S(!1), Ct = S(0);
+  function xt(l) {
+    const a = vt(l);
+    return P ? a : a[a.length - 1];
+  }
+  function Xt(l) {
+    const a = l.map((p) => E(p));
+    return tt.current = a, a;
+  }
+  function q(l, a) {
+    const p = Xt(l), y = xt(p);
+    lt(y), a === "inputValueChange" ? C.current = p.some((A, G) => A > p[G]) : C.current = !1, L(d.onChange) && d.onChange(y);
+  }
+  function st() {
+    if (L(d.onAfterChange)) {
+      const l = xt(tt.current);
+      d.onAfterChange(l);
+    }
+  }
+  function Yt(l) {
+    let [a, p] = [x[0], x[x.length - 1]];
+    return a > p && ([a, p] = [p, a]), P ? l >= a && l <= p : l <= p;
+  }
+  function ft(l, a) {
+    const { left: p, top: y, width: A, height: G } = Vt.current;
+    let F = A, yt = O ? p + A - l : l - p;
+    if (u && (F = G, yt = O ? a - y : y + G - a), F <= 0)
+      return 0;
+    let et = Math.max(Rt(yt, F), 0);
+    et = Math.min(1, et);
+    const _t = D.find((At) => et >= At.beginOffset && et <= At.endOffset), {
+      begin: $t,
+      beginOffset: Ot,
+      step: Pt,
+      endOffset: te,
+      end: ee
+    } = _t, ne = et - Ot, oe = te - Ot, re = ne / oe * (ee - $t), ie = Math.round(re / Pt);
+    return ot($t, wt(ie, Pt));
+  }
+  function Kt(l) {
+    let [a, p] = l;
+    a > p && ([a, p] = [p, a]);
+    const y = X(a), A = X(1 - p);
+    return u ? {
+      [O ? "top" : "bottom"]: y,
+      [O ? "bottom" : "top"]: A
+    } : {
+      [O ? "right" : "left"]: y,
+      [O ? "left" : "right"]: A
+    };
+  }
+  function zt(l) {
+    return u ? { [O ? "top" : "bottom"]: X(l) } : { [O ? "right" : "left"]: X(l) };
+  }
+  function Jt() {
+    const l = {
+      getTooltipContainer: d.getTooltipContainer,
+      formatTooltip: d.formatTooltip
+    };
+    return "tooltipPosition" in d && (l.tooltipPosition = c), "tooltipVisible" in d && (l.tooltipVisible = b), l;
+  }
+  function Nt() {
+    Vt.current = bt.current.getBoundingClientRect();
+  }
+  function qt(l) {
+    Nt();
+    const a = ft(l.clientX, l.clientY);
+    at.draggableBar && Yt(a) ? (Ct.current = E(a), U(window, "mousemove", kt), U(window, "mouseup", It)) : mt(a);
+  }
+  function mt(l) {
+    if (V)
+      return;
+    const a = E(l), [p, y] = Ne(a, x), A = x[p], G = x[y], F = x.slice(0);
+    P && G - a > a - A ? (F[p] = a, q(F, "jumpToClick")) : (F[y] = a, q(F, "jumpToClick")), st();
+  }
+  function Gt(l) {
+    q(l, "inputValueChange"), st();
+  }
+  function Ht(l, a, p) {
+    Mt.current = !0;
+    const y = x.slice(0);
+    y[p] = ft(l, a), q(y, "mousemove");
+  }
+  function Qt() {
+    Mt.current = !1, st();
+  }
+  function Zt(l, a) {
+    if (V)
+      return;
+    const p = x.slice(0);
+    p[a] = J(x[a], l), q(p);
+  }
+  function kt(l) {
+    const p = E(ft(l.clientX, l.clientY)) - Ct.current, y = x.map((A) => A + p);
+    y.every((A) => ut(A)) && q(y, "mousemove");
+  }
+  function It() {
+    W(window, "mousemove", kt), W(window, "mouseup", It), st();
+  }
+  return /* @__PURE__ */ I(
+    "div",
+    {
+      ...ce(z, [
+        "defaultValue",
+        "value",
+        "onChange",
+        "getTooltipContainer",
+        "formatTooltip",
+        "onAfterChange"
+      ]),
+      className: Y(
+        $,
+        {
+          [`${$}-vertical`]: u,
+          [`${$}-with-marks`]: v,
+          [`${$}-reverse`]: O,
+          [`${$}-rtl`]: s
+        },
+        k
+      ),
+      style: m,
+      ref: o,
+      children: /* @__PURE__ */ gt("div", { className: `${$}-wrapper`, children: [
+        /* @__PURE__ */ gt(
+          "div",
+          {
+            ref: bt,
+            className: Y(`${$}-road`, {
+              [`${$}-road-disabled`]: V,
+              [`${$}-road-vertical`]: u
+            }),
+            onMouseDown: qt,
+            children: [
+              /* @__PURE__ */ I(
+                "div",
+                {
+                  className: `${$}-bar`,
+                  style: Kt([
+                    Q(B, D),
+                    Q(N, D)
+                  ])
+                }
+              ),
+              w && /* @__PURE__ */ I(
+                De,
+                {
+                  intervalConfigs: D,
+                  min: h,
+                  max: f,
+                  valueRange: [B, N],
+                  prefixCls: $,
+                  vertical: u,
+                  reverse: O
+                }
+              ),
+              /* @__PURE__ */ I(
+                Ie,
+                {
+                  data: it,
+                  intervalConfigs: D,
+                  valueRange: [B, N],
+                  vertical: u,
+                  prefixCls: $,
+                  reverse: O,
+                  onMouseDown: mt
+                }
+              ),
+              /* @__PURE__ */ I(
+                Pe,
+                {
+                  data: it,
+                  intervalConfigs: D,
+                  vertical: u,
+                  prefixCls: $,
+                  reverse: O,
+                  onMouseDown: mt
+                }
+              ),
+              x.map((l, a) => !P && a !== x.length - 1 ? null : /* @__PURE__ */ I(
+                be,
+                {
+                  style: zt(Q(l, D)),
+                  disabled: V,
+                  prefixCls: $,
+                  value: l,
+                  maxValue: f,
+                  minValue: h,
+                  vertical: u,
+                  ...Jt(),
+                  onMoveBegin: Nt,
+                  onMoving: (p, y) => Ht(p, y, a),
+                  onMoveEnd: Qt,
+                  onArrowEvent: (p) => Zt(p, a)
+                },
+                a
+              ))
+            ]
+          }
+        ),
+        ct && /* @__PURE__ */ I(
+          $e,
+          {
+            min: h,
+            max: f,
+            step: g,
+            value: x,
+            range: P,
+            disabled: V,
+            prefixCls: $,
+            onChange: Gt,
+            extra: Wt
+          }
+        )
+      ] })
+    }
+  );
+}
+const Ut = ae(Le);
+Ut.displayName = "Slider";
+const ln = _.memo(Ut);
+export {
+  ln as default
+};