@unicom-cloud/ui 0.8.46 → 0.8.48

package/Slider.js

@@ -1,193 +1,658 @@
-import { jsx as d, jsxs as oe } from "react/jsx-runtime";
-/* empty css                              */
-/* empty css                 */
-/* empty css                        */
-/* empty css                       */
-/* empty css                         */
-/* empty css                         */
-/* empty css                        */
-import { divide as Fe, plus as Je, times as qe } from "@unicom-cloud/utils/math";
-import ne from "lodash/isArray";
-import re from "lodash/isFunction";
-import ie from "lodash/isPlainObject";
-import ze, { forwardRef as Ge, useContext as He, useRef as V, useMemo as Ke } from "react";
-import "./config-provider/ConfigProvider.js";
-import Qe from "./hooks/useMergeProps.js";
-import We from "./hooks/useMergeValue.js";
-import Ze from "./hooks/useUpdateEffect.js";
-import ae from "@unicom-cloud/utils/class-name";
-import { on as se, off as le } from "./utils/dom.js";
-import _e from "./utils/omit.js";
-import et from "./slider/Button.js";
-import tt from "./slider/Dot.js";
-import ot from "./slider/Input.js";
-import nt from "./slider/Mark.js";
-import rt from "./slider/Tick.js";
-import it from "./slider/hook/useInterval.js";
-import at from "./slider/hook/useLegalValue.js";
-import { needSort as st, sortNumberArray as ue, getIntervalOffset as j, formatPercent as y, findNearestIndex as lt } from "./slider/util.js";
-import { ConfigContext as ut } from "./config-provider/context.js";
-const ct = {
+import { jsx as I, jsxs as ge } from "react/jsx-runtime";
+import { minus as pe, times as we, plus as oe, divide as Re } from "@unicom-cloud/utils/math";
+import he from "lodash/isArray";
+import L from "lodash/isFunction";
+import re from "lodash/isPlainObject";
+import _, { useState as Se, useContext as Ee, useMemo as Z, useRef as S, useEffect as Le, createElement as De, useCallback as H, forwardRef as st } from "react";
+import { a as Be } from "./chunk/z7sBNzI4.js";
+import at from "./hooks/useMergeProps.js";
+import Fe from "./hooks/useMergeValue.js";
+import ut from "./hooks/useUpdateEffect.js";
+import Y from "@unicom-cloud/utils/class-name";
+import { on as U, off as W } from "./utils/dom.js";
+import lt from "./utils/omit.js";
+import ne from "lodash/isNumber";
+import ct from "lodash/isString";
+import ft from "./hooks/useKeyboardEvent.js";
+import mt from "./Trigger.js";
+import { a as Te } from "./chunk/I0bfWb5y.js";
+import { isEmptyObject as dt } from "@unicom-cloud/utils/is";
+import gt from "lodash/isUndefined";
+const pt = { maxWidth: 350 }, ht = {
+  enter: 300,
+  exit: 100
+}, vt = {
+  left: 12,
+  right: 12,
+  top: 12,
+  bottom: 12
+}, wt = function(e) {
+  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
+  } = e, t = ft(), [g, w] = Se(!1), [v, i] = Fe(!1, {
+    value: k
+  }), { getPrefixCls: u } = Ee(Be), M = Z(
+    () => m || (d ? "right" : "top"),
+    [m, d]
+  ), T = S(null), K = S(!1), z = S(!1), P = S(null);
+  function ae(C) {
+    C.stopPropagation(), !n && (ie(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 ie(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), ue(), j(K.current), L(h) && h();
+  }
+  function ue() {
+    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 e ? k : C;
+    i(N);
+  }
+  function le() {
+    K.current = !0, J();
+  }
+  const x = Z(() => L(b) ? b(s) : s, [b, s]);
+  function ee(C) {
+    const N = u("tooltip");
+    return /* @__PURE__ */ I(
+      "div",
+      {
+        className: Y(
+          `${N}-content`,
+          `${N}-content-${C}`
+        ),
+        onMouseLeave: D,
+        onMouseEnter: le,
+        onClick: (B) => {
+          B.stopPropagation();
+        },
+        children: /* @__PURE__ */ I("div", { className: `${N}-content-inner`, children: x })
+      }
+    );
+  }
+  return Le(() => {
+    P && P.current && P.current.updatePopupPosition();
+  }, [s]), /* @__PURE__ */ I(
+    mt,
+    {
+      style: pt,
+      classNames: "zoomInFadeOut",
+      duration: ht,
+      showArrow: !0,
+      popupAlign: vt,
+      ref: P,
+      popup: () => ee(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: ae,
+          onMouseEnter: O,
+          onMouseLeave: D,
+          style: o,
+          role: "slider",
+          "aria-valuemax": e.maxValue,
+          "aria-valuemin": e.minValue,
+          "aria-valuenow": s,
+          "aria-disabled": !!n,
+          tabIndex: n ? -1 : 0,
+          "aria-valuetext": ct(x) || ne(x) ? String(x) : void 0,
+          ...t({
+            onArrowRight: (C) => {
+              var N;
+              C.preventDefault(), (N = e.onArrowEvent) == null || N.call(e, "addition");
+            },
+            onArrowUp: (C) => {
+              var N;
+              C.preventDefault(), (N = e.onArrowEvent) == null || N.call(e, "addition");
+            },
+            onArrowLeft: (C) => {
+              var N;
+              C.preventDefault(), (N = e.onArrowEvent) == null || N.call(e, "subtraction");
+            },
+            onArrowDown: (C) => {
+              var N;
+              C.preventDefault(), (N = e.onArrowEvent) == null || N.call(e, "subtraction");
+            }
+          })
+        }
+      )
+    }
+  );
+}, bt = _.memo(wt);
+function Vt(e) {
+  const o = `${e}`.split(".")[1];
+  return o && o.length || 0;
+}
+function X(e) {
+  return `${e * 100}%`;
+}
+function Mt(e, o) {
+  const n = Number(e);
+  if (o && !isNaN(n)) {
+    const [r, s] = o;
+    return Re(pe(n, r), pe(s, r));
+  }
+  return 0;
+}
+function je(e, o) {
+  const n = Number(e);
+  return o.sort((r, s) => r - s), n >= o[0] && n <= o[1];
+}
+function de(e) {
+  return e || e === 0;
+}
+function Ct(e) {
+  const o = parseFloat(e), n = o > 1 ? (o / 100).toFixed(2) : o, r = parseFloat(n);
+  if (!isNaN(r) && r >= 0 && r <= 1)
+    return r;
+}
+function Q(e, o) {
+  const n = o.find(
+    (r) => e >= r.begin && e <= r.end
+  );
+  if (n) {
+    const { beginOffset: r, begin: s, end: d, endOffset: k } = n, m = Mt(e, [s, d]), b = pe(k, r), c = we(m, b);
+    return oe(r, c);
+  }
+}
+function ve(e) {
+  const o = e.slice(0);
+  return o.sort((n, r) => n - r), o;
+}
+function xt(e) {
+  return e.some((o, n) => o > e[n + 1]);
+}
+function Nt(e, o) {
+  let n = o.indexOf(e);
+  return n === -1 ? (n = ve(o.concat(e)).indexOf(e), [
+    Math.max(n - 1, 0),
+    Math.min(n, o.length - 1)
+  ]) : [n, n + 1];
+}
+const kt = function(e) {
+  const {
+    data: o = [],
+    valueRange: n = [],
+    vertical: r,
+    prefixCls: s,
+    reverse: d,
+    intervalConfigs: k
+  } = e;
+  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(e.onMouseDown) && e.onMouseDown(parseFloat(m));
+        },
+        children: re(b) && b.dot ? b.dot : /* @__PURE__ */ I(
+          "div",
+          {
+            className: Y(`${s}-dot`, {
+              [`${s}-dot-active`]: je(m, n)
+            })
+          }
+        )
+      },
+      m
+    );
+  }) }) : null;
+}, It = _.memo(kt), yt = function(e) {
+  const {
+    value: o,
+    range: n,
+    min: r,
+    max: s,
+    step: d,
+    disabled: k,
+    prefixCls: m,
+    onChange: b,
+    extra: c = []
+  } = e, V = {
+    min: r,
+    max: s,
+    step: d,
+    disabled: k
+  }, [h, f] = Se(o), t = c[0], g = n ? c[1] : c[0];
+  Le(() => {
+    f(o);
+  }, [o]);
+  const w = (i) => {
+    b == null || b(i);
+  }, v = () => {
+    f([...o].sort((i, u) => i - u));
+  };
+  return /* @__PURE__ */ ge(
+    "div",
+    {
+      className: Y(`${m}-input`, {
+        [`${m}-input-group`]: n
+      }),
+      onBlur: v,
+      children: [
+        n && [
+          /* @__PURE__ */ De(
+            Te,
+            {
+              hideControl: !0,
+              ...t,
+              ...V,
+              value: h[0],
+              key: 0,
+              onChange: (i, u) => {
+                var M;
+                isNaN(i) && i !== i || (w([i, h[1]]), (M = t == null ? void 0 : t.onChange) == null || M.call(t, i, u));
+              }
+            }
+          ),
+          /* @__PURE__ */ I("div", { className: `${m}-input-range`, children: /* @__PURE__ */ I("span", { className: `${m}-input-range-content` }) }, 1)
+        ],
+        /* @__PURE__ */ De(
+          Te,
+          {
+            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));
+            }
+          }
+        )
+      ]
+    }
+  );
+}, $t = _.memo(yt), Ot = function(e) {
+  const { data: o = [], vertical: n, prefixCls: r, reverse: s, intervalConfigs: d } = e;
+  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 re(m) && de(m.text) ? c = m.text : de(m) && (c = m), de(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(e.onMouseDown) && e.onMouseDown(parseFloat(k));
+        },
+        children: c
+      },
+      k
+    );
+  }) }) : null;
+}, Pt = _.memo(Ot);
+function At(e) {
+  const {
+    min: o,
+    max: n,
+    valueRange: r,
+    prefixCls: s,
+    vertical: d,
+    reverse: k,
+    intervalConfigs: m
+  } = e, b = /* @__PURE__ */ new Map(), c = (h) => {
+    const { step: f, begin: t, end: g } = h, w = Math.floor((g - t) / f);
+    for (let v = 0; v <= w; v++) {
+      const i = oe(v * f, t);
+      if (i <= o || i >= n) continue;
+      const u = X(Q(i, m));
+      b.set(u, {
+        offset: u,
+        isActive: je(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 Dt = _.memo(At);
+function Tt(e) {
+  if (e.length < 2)
+    return [];
+  const o = [];
+  for (let n = 1; n < e.length; n++) {
+    const r = e[n - 1], s = e[n];
+    o.push([r, s]);
+  }
+  return o;
+}
+function Rt(e) {
+  const { marks: o = {}, getIntervalConfig: n, max: r, min: s } = e, { markIntervals: d, markList: k } = Z(() => {
+    const b = Object.keys(o).filter((f) => ne(+f) && +f >= s && +f <= r).sort((f, t) => +f > +t ? 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: Tt(V), markList: c };
+  }, [o, s, r]);
+  return {
+    intervalConfigs: Z(() => {
+      if (!L(n))
+        return [
+          {
+            begin: s,
+            end: r,
+            step: e.step,
+            beginOffset: 0,
+            endOffset: 1,
+            width: 1
+          }
+        ];
+      const b = ([t, g], w) => {
+        const v = { step: e.step, width: 0 }, i = n([t, g], w) || {}, u = i.step, M = Ct(i.width);
+        return ne(u) && u && (v.step = u), ne(M) && M && (v.width = M), v;
+      };
+      let c = 1, V = r - s;
+      const h = d.map(([t, g], w) => {
+        const v = b([t, g], w);
+        let i = v.width;
+        if (i) {
+          i = Math.min(c, i);
+          const u = g - t;
+          V -= u, c -= i;
+        }
+        return { width: i, step: v.step };
+      });
+      if (h.every(({ width: t }) => t) && c) {
+        const t = h[d.length - 1];
+        t.width += c;
+      }
+      const f = [];
+      return d.forEach(([t, g], w) => {
+        const { step: v, width: i } = h[w], u = {
+          begin: t,
+          end: g,
+          step: v,
+          beginOffset: 0,
+          endOffset: 0,
+          width: i
+        };
+        u.width || (u.width = c * ((g - t) / 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, e.step]),
+    markList: k
+  };
+}
+function St(e) {
+  const { isRange: o, min: n, max: r, onlyMarkValue: s, intervalConfigs: d, marks: k } = e, m = H(
+    (t) => {
+      const g = d.find((w) => t >= w.begin && t <= w.end);
+      if (g) {
+        const { begin: w, step: v } = g, i = t - w, u = Math.round(i / v), M = Vt(v), T = parseFloat(
+          we(v, u).toFixed(M)
+        );
+        return oe(w, T);
+      }
+      return t;
+    },
+    [d]
+  ), b = H(
+    (t) => {
+      if (!re(k) || dt(k))
+        return console.warn("marks must be an object when onlyMarkValue is true"), n;
+      if (k[t])
+        return t;
+      const g = Object.keys(k), w = g.map((i) => Math.abs(t - parseFloat(i))), v = w.indexOf(Math.min.apply(null, w));
+      return parseFloat(g[v]);
+    },
+    [k, n]
+  ), c = H(
+    (t) => gt(t) || t <= n ? n : t >= r ? r : s ? b(t) : m(t),
+    [b, m, r, n, s]
+  ), V = H(
+    (t) => c(t) === t,
+    [c]
+  ), h = H(
+    (t) => {
+      let [g, w] = [n, n];
+      if (o) {
+        if (he(t))
+          return g = c(t[0]), t.map((v) => c(v));
+        console.error("value must be an array when range is true");
+      } else ne(t) ? w = c(t) : console.error("value must be a number when range is false");
+      return [g, w];
+    },
+    [c, o, n]
+  ), f = H(
+    (t, g) => {
+      const w = g === "subtraction" ? -1 : 1;
+      let v = oe(t, w * e.step);
+      if (e.onlyMarkValue) {
+        const i = Object.keys(e.marks), u = i.findIndex((M) => Number(M) === t);
+        v = i[u + w] !== void 0 ? Number(i[u + w]) : t;
+      }
+      return v;
+    },
+    [e.marks, e.onlyMarkValue, e.step]
+  );
+  return {
+    getLegalRangeValue: h,
+    getLegalValue: c,
+    isLegalValue: V,
+    getNextMarkValue: f
+  };
+}
+const Et = {
   max: 100,
   min: 0,
   step: 1
 };
-function ft(fe, me) {
-  const { getPrefixCls: pe, componentConfig: I, rtl: U } = He(ut), l = Qe(
-    fe,
-    ct,
-    I == null ? void 0 : I.Slider
+function Lt(e, o) {
+  const { getPrefixCls: n, componentConfig: r, rtl: s } = Ee(Be), d = at(
+    e,
+    Et,
+    r == null ? void 0 : r.Slider
   ), {
-    className: ge,
-    style: de,
-    tooltipVisible: ve,
-    tooltipPosition: he,
-    disabled: C,
-    min: c,
-    max: w,
-    range: P,
-    step: R,
-    showTicks: Ve,
-    marks: N,
-    onlyMarkValue: k,
+    className: k,
+    style: m,
+    tooltipVisible: b,
+    tooltipPosition: c,
+    disabled: V,
+    min: h,
+    max: f,
+    range: t,
+    step: g,
+    showTicks: w,
+    marks: v,
+    onlyMarkValue: i,
     vertical: u,
-    showInput: f,
-    reverse: X,
-    getIntervalConfig: Ce,
-    ...we
-  } = l, m = !!P, Me = ie(P) ? { ...P } : { draggableBar: !1 }, s = U ? !X : X, { intervalConfigs: p, markList: Y } = it({
-    min: c,
-    max: w,
-    onlyMarkValue: k,
-    step: R,
-    marks: N,
-    getIntervalConfig: Ce
-  }), { getLegalValue: b, getLegalRangeValue: B, isLegalValue: be, getNextMarkValue: xe } = at({
-    isRange: m,
-    min: c,
-    max: w,
-    onlyMarkValue: k,
-    step: R,
-    intervalConfigs: p,
-    marks: N
-  }), [O, ye] = We(
-    m ? [c, c] : c,
+    showInput: M,
+    reverse: T,
+    getIntervalConfig: K,
+    ...z
+  } = d, P = !!t, ae = re(t) ? { ...t } : { draggableBar: !1 }, O = s ? !T : T, { intervalConfigs: D, markList: ie } = Rt({
+    min: h,
+    max: f,
+    onlyMarkValue: i,
+    step: g,
+    marks: v,
+    getIntervalConfig: K
+  }), { getLegalValue: E, getLegalRangeValue: R, isLegalValue: ue, getNextMarkValue: J } = St({
+    isRange: P,
+    min: h,
+    max: f,
+    onlyMarkValue: i,
+    step: g,
+    intervalConfigs: D,
+    marks: v
+  }), [j, le] = Fe(
+    P ? [h, h] : h,
     {
-      defaultValue: l.defaultValue,
-      value: l.value
+      defaultValue: d.defaultValue,
+      value: d.value
     }
   );
-  let n = B(O);
-  const S = V(n), T = V(st(n));
-  Ze(() => {
-    S.current = B(O);
-  }, [O, B]), T.current && (n = ue(n));
-  const $ = n[n.length - 1], A = n[0], D = f && !k && (!m || n.length < 3), Ie = Ke(() => D && (ne(f) || ie(f)) ? ne(f) ? [...f] : [{ ...f }, { ...f }] : [], [D, f]), i = pe("slider"), F = V(null), J = V({
+  let x = R(j);
+  const ee = S(x), C = S(xt(x));
+  ut(() => {
+    ee.current = R(j);
+  }, [j, R]), C.current && (x = ve(x));
+  const N = x[x.length - 1], B = x[0], ce = M && !i && (!P || x.length < 3), We = Z(() => ce && (he(M) || re(M)) ? he(M) ? [...M] : [{ ...M }, { ...M }] : [], [ce, M]), $ = n("slider"), be = S(null), Ve = S({
     left: 0,
     height: 0,
     top: 0,
     width: 0
-  }), q = V(!1), z = V(0);
-  function G(t) {
-    const e = ue(t);
-    return m ? e : e[e.length - 1];
-  }
-  function Pe(t) {
-    const e = t.map((o) => b(o));
-    return S.current = e, e;
-  }
-  function v(t, e) {
-    const o = Pe(t), r = G(o);
-    ye(r), e === "inputValueChange" ? T.current = o.some((a, h) => a > o[h]) : T.current = !1, re(l.onChange) && l.onChange(r);
-  }
-  function x() {
-    if (re(l.onAfterChange)) {
-      const t = G(S.current);
-      l.onAfterChange(t);
+  }), Me = S(!1), Ce = S(0);
+  function xe(l) {
+    const a = ve(l);
+    return P ? a : a[a.length - 1];
+  }
+  function Xe(l) {
+    const a = l.map((p) => E(p));
+    return ee.current = a, a;
+  }
+  function q(l, a) {
+    const p = Xe(l), y = xe(p);
+    le(y), a === "inputValueChange" ? C.current = p.some((A, G) => A > p[G]) : C.current = !1, L(d.onChange) && d.onChange(y);
+  }
+  function se() {
+    if (L(d.onAfterChange)) {
+      const l = xe(ee.current);
+      d.onAfterChange(l);
     }
   }
-  function Re(t) {
-    let [e, o] = [n[0], n[n.length - 1]];
-    return e > o && ([e, o] = [o, e]), m ? t >= e && t <= o : t <= o;
+  function Ye(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 E(t, e) {
-    const { left: o, top: r, width: a, height: h } = J.current;
-    let g = a, W = s ? o + a - t : t - o;
-    if (u && (g = h, W = s ? e - r : r + h - e), g <= 0)
+  function fe(l, a) {
+    const { left: p, top: y, width: A, height: G } = Ve.current;
+    let F = A, ye = O ? p + A - l : l - p;
+    if (u && (F = G, ye = O ? a - y : y + G - a), F <= 0)
       return 0;
-    let M = Math.max(Fe(W, g), 0);
-    M = Math.min(1, M);
-    const De = p.find((te) => M >= te.beginOffset && M <= te.endOffset), {
-      begin: Z,
-      beginOffset: _,
-      step: ee,
-      endOffset: Ee,
-      end: Le
-    } = De, je = M - _, Ue = Ee - _, Xe = je / Ue * (Le - Z), Ye = Math.round(Xe / ee);
-    return Je(Z, qe(Ye, ee));
-  }
-  function Ne(t) {
-    let [e, o] = t;
-    e > o && ([e, o] = [o, e]);
-    const r = y(e), a = y(1 - o);
+    let te = Math.max(Re(ye, F), 0);
+    te = Math.min(1, te);
+    const _e = D.find((Ae) => te >= Ae.beginOffset && te <= Ae.endOffset), {
+      begin: $e,
+      beginOffset: Oe,
+      step: Pe,
+      endOffset: et,
+      end: tt
+    } = _e, nt = te - Oe, ot = et - Oe, rt = nt / ot * (tt - $e), it = Math.round(rt / Pe);
+    return oe($e, we(it, Pe));
+  }
+  function Ke(l) {
+    let [a, p] = l;
+    a > p && ([a, p] = [p, a]);
+    const y = X(a), A = X(1 - p);
     return u ? {
-      [s ? "top" : "bottom"]: r,
-      [s ? "bottom" : "top"]: a
+      [O ? "top" : "bottom"]: y,
+      [O ? "bottom" : "top"]: A
     } : {
-      [s ? "right" : "left"]: r,
-      [s ? "left" : "right"]: a
+      [O ? "right" : "left"]: y,
+      [O ? "left" : "right"]: A
     };
   }
-  function ke(t) {
-    return u ? { [s ? "top" : "bottom"]: y(t) } : { [s ? "right" : "left"]: y(t) };
+  function ze(l) {
+    return u ? { [O ? "top" : "bottom"]: X(l) } : { [O ? "right" : "left"]: X(l) };
   }
-  function Be() {
-    const t = {
-      getTooltipContainer: l.getTooltipContainer,
-      formatTooltip: l.formatTooltip
+  function Je() {
+    const l = {
+      getTooltipContainer: d.getTooltipContainer,
+      formatTooltip: d.formatTooltip
     };
-    return "tooltipPosition" in l && (t.tooltipPosition = he), "tooltipVisible" in l && (t.tooltipVisible = ve), t;
+    return "tooltipPosition" in d && (l.tooltipPosition = c), "tooltipVisible" in d && (l.tooltipVisible = b), l;
   }
-  function H() {
-    J.current = F.current.getBoundingClientRect();
+  function Ne() {
+    Ve.current = be.current.getBoundingClientRect();
   }
-  function Oe(t) {
-    H();
-    const e = E(t.clientX, t.clientY);
-    Me.draggableBar && Re(e) ? (z.current = b(e), se(window, "mousemove", K), se(window, "mouseup", Q)) : L(e);
+  function qe(l) {
+    Ne();
+    const a = fe(l.clientX, l.clientY);
+    ae.draggableBar && Ye(a) ? (Ce.current = E(a), U(window, "mousemove", ke), U(window, "mouseup", Ie)) : me(a);
   }
-  function L(t) {
-    if (C) return;
-    const e = b(t), [o, r] = lt(e, n), a = n[o], h = n[r], g = n.slice(0);
-    m && h - e > e - a ? (g[o] = e, v(g, "jumpToClick")) : (g[r] = e, v(g, "jumpToClick")), x();
+  function me(l) {
+    if (V) return;
+    const a = E(l), [p, y] = Nt(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")), se();
   }
-  function Se(t) {
-    v(t, "inputValueChange"), x();
+  function Ge(l) {
+    q(l, "inputValueChange"), se();
   }
-  function Te(t, e, o) {
-    q.current = !0;
-    const r = n.slice(0);
-    r[o] = E(t, e), v(r, "mousemove");
+  function He(l, a, p) {
+    Me.current = !0;
+    const y = x.slice(0);
+    y[p] = fe(l, a), q(y, "mousemove");
   }
-  function $e() {
-    q.current = !1, x();
+  function Qe() {
+    Me.current = !1, se();
   }
-  function Ae(t, e) {
-    if (C) return;
-    const o = n.slice(0);
-    o[e] = xe(n[e], t), v(o);
+  function Ze(l, a) {
+    if (V) return;
+    const p = x.slice(0);
+    p[a] = J(x[a], l), q(p);
   }
-  function K(t) {
-    const o = b(E(t.clientX, t.clientY)) - z.current, r = n.map((a) => a + o);
-    r.every((a) => be(a)) && v(r, "mousemove");
+  function ke(l) {
+    const p = E(fe(l.clientX, l.clientY)) - Ce.current, y = x.map((A) => A + p);
+    y.every((A) => ue(A)) && q(y, "mousemove");
   }
-  function Q() {
-    le(window, "mousemove", K), le(window, "mouseup", Q), x();
+  function Ie() {
+    W(window, "mousemove", ke), W(window, "mouseup", Ie), se();
   }
-  return /* @__PURE__ */ d(
+  return /* @__PURE__ */ I(
     "div",
     {
-      ..._e(we, [
+      ...lt(z, [
         "defaultValue",
         "value",
         "onChange",
@@ -195,116 +660,116 @@ function ft(fe, me) {
         "formatTooltip",
         "onAfterChange"
       ]),
-      className: ae(
-        i,
+      className: Y(
+        $,
         {
-          [`${i}-vertical`]: u,
-          [`${i}-with-marks`]: N,
-          [`${i}-reverse`]: s,
-          [`${i}-rtl`]: U
+          [`${$}-vertical`]: u,
+          [`${$}-with-marks`]: v,
+          [`${$}-reverse`]: O,
+          [`${$}-rtl`]: s
         },
-        ge
+        k
       ),
-      style: de,
-      ref: me,
-      children: /* @__PURE__ */ oe("div", { className: `${i}-wrapper`, children: [
-        /* @__PURE__ */ oe(
+      style: m,
+      ref: o,
+      children: /* @__PURE__ */ ge("div", { className: `${$}-wrapper`, children: [
+        /* @__PURE__ */ ge(
           "div",
           {
-            ref: F,
-            className: ae(`${i}-road`, {
-              [`${i}-road-disabled`]: C,
-              [`${i}-road-vertical`]: u
+            ref: be,
+            className: Y(`${$}-road`, {
+              [`${$}-road-disabled`]: V,
+              [`${$}-road-vertical`]: u
             }),
-            onMouseDown: Oe,
+            onMouseDown: qe,
             children: [
-              /* @__PURE__ */ d(
+              /* @__PURE__ */ I(
                 "div",
                 {
-                  className: `${i}-bar`,
-                  style: Ne([
-                    j(A, p),
-                    j($, p)
+                  className: `${$}-bar`,
+                  style: Ke([
+                    Q(B, D),
+                    Q(N, D)
                   ])
                 }
               ),
-              Ve && /* @__PURE__ */ d(
-                rt,
+              w && /* @__PURE__ */ I(
+                Dt,
                 {
-                  intervalConfigs: p,
-                  min: c,
-                  max: w,
-                  valueRange: [A, $],
-                  prefixCls: i,
+                  intervalConfigs: D,
+                  min: h,
+                  max: f,
+                  valueRange: [B, N],
+                  prefixCls: $,
                   vertical: u,
-                  reverse: s
+                  reverse: O
                 }
               ),
-              /* @__PURE__ */ d(
-                tt,
+              /* @__PURE__ */ I(
+                It,
                 {
-                  data: Y,
-                  intervalConfigs: p,
-                  valueRange: [A, $],
+                  data: ie,
+                  intervalConfigs: D,
+                  valueRange: [B, N],
                   vertical: u,
-                  prefixCls: i,
-                  reverse: s,
-                  onMouseDown: L
+                  prefixCls: $,
+                  reverse: O,
+                  onMouseDown: me
                 }
               ),
-              /* @__PURE__ */ d(
-                nt,
+              /* @__PURE__ */ I(
+                Pt,
                 {
-                  data: Y,
-                  intervalConfigs: p,
+                  data: ie,
+                  intervalConfigs: D,
                   vertical: u,
-                  prefixCls: i,
-                  reverse: s,
-                  onMouseDown: L
+                  prefixCls: $,
+                  reverse: O,
+                  onMouseDown: me
                 }
               ),
-              n.map((t, e) => !m && e !== n.length - 1 ? null : /* @__PURE__ */ d(
-                et,
+              x.map((l, a) => !P && a !== x.length - 1 ? null : /* @__PURE__ */ I(
+                bt,
                 {
-                  style: ke(j(t, p)),
-                  disabled: C,
-                  prefixCls: i,
-                  value: t,
-                  maxValue: w,
-                  minValue: c,
+                  style: ze(Q(l, D)),
+                  disabled: V,
+                  prefixCls: $,
+                  value: l,
+                  maxValue: f,
+                  minValue: h,
                   vertical: u,
-                  ...Be(),
-                  onMoveBegin: H,
-                  onMoving: (o, r) => Te(o, r, e),
-                  onMoveEnd: $e,
-                  onArrowEvent: (o) => Ae(o, e)
+                  ...Je(),
+                  onMoveBegin: Ne,
+                  onMoving: (p, y) => He(p, y, a),
+                  onMoveEnd: Qe,
+                  onArrowEvent: (p) => Ze(p, a)
                 },
-                e
+                a
               ))
             ]
           }
         ),
-        D && /* @__PURE__ */ d(
-          ot,
+        ce && /* @__PURE__ */ I(
+          $t,
           {
-            min: c,
-            max: w,
-            step: R,
-            value: n,
-            range: m,
-            disabled: C,
-            prefixCls: i,
-            onChange: Se,
-            extra: Ie
+            min: h,
+            max: f,
+            step: g,
+            value: x,
+            range: P,
+            disabled: V,
+            prefixCls: $,
+            onChange: Ge,
+            extra: We
           }
         )
       ] })
     }
   );
 }
-const ce = Ge(ft);
-ce.displayName = "Slider";
-const Xt = ze.memo(ce);
+const Ue = st(Lt);
+Ue.displayName = "Slider";
+const rn = _.memo(Ue);
 export {
-  Xt as default
+  rn as default
 };