@prokodo/ui 0.0.26 → 0.0.28

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/useSlider/useSlider.js

@@ -1,423 +1,620 @@
-import * as g from "react";
-import Ae from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useControlled/useControlled.js";
-import R from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/clamp/clamp.js";
-import De from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
-import Ce from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js";
-import J from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js";
-import U from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/ownerDocument/ownerDocument.js";
-import Q from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
-import Me from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/visuallyHidden/visuallyHidden.js";
-import { areArraysEqual as Ne } from "../utils/areArraysEqual.js";
-import ae from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/isFocusVisible/isFocusVisible.js";
-const Re = 2;
-function pe(n, u) {
-  return n - u;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+import useControlled from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useControlled/useControlled.js";
+import clamp from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/clamp/clamp.js";
+import useForkRef from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
+import useEnhancedEffect from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js";
+import useEventCallback from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js";
+import ownerDocument from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/ownerDocument/ownerDocument.js";
+import extractEventHandlers from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
+import visuallyHidden from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/visuallyHidden/visuallyHidden.js";
+import { areArraysEqual } from "../utils/areArraysEqual.js";
+import isFocusVisible from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/isFocusVisible/isFocusVisible.js";
+const INTENTIONAL_DRAG_COUNT_THRESHOLD = 2;
+function asc(a, b) {
+  return a - b;
 }
-function fe(n, u) {
+__name(asc, "asc");
+function findClosest(values, currentValue) {
   const {
-    index: s
-  } = n.reduce((r, m, T) => {
-    const b = Math.abs(u - m);
-    return r === null || b < r.distance || b === r.distance ? {
-      distance: b,
-      index: T
-    } : r;
+    index: closestIndex
+  } = values.reduce((acc, value, index) => {
+    const distance = Math.abs(currentValue - value);
+    if (acc === null || distance < acc.distance || distance === acc.distance) {
+      return {
+        distance,
+        index
+      };
+    }
+    return acc;
   }, null) ?? {};
-  return s;
+  return closestIndex;
 }
-function B(n, u) {
-  if (u.current !== void 0 && n.changedTouches) {
-    const s = n;
-    for (let r = 0; r < s.changedTouches.length; r += 1) {
-      const m = s.changedTouches[r];
-      if (m.identifier === u.current)
+__name(findClosest, "findClosest");
+function trackFinger(event, touchId) {
+  if (touchId.current !== void 0 && event.changedTouches) {
+    const touchEvent = event;
+    for (let i = 0; i < touchEvent.changedTouches.length; i += 1) {
+      const touch = touchEvent.changedTouches[i];
+      if (touch.identifier === touchId.current) {
         return {
-          x: m.clientX,
-          y: m.clientY
+          x: touch.clientX,
+          y: touch.clientY
         };
+      }
     }
-    return !1;
+    return false;
   }
   return {
-    x: n.clientX,
-    y: n.clientY
+    x: event.clientX,
+    y: event.clientY
   };
 }
-function le(n, u, s) {
-  return (n - u) * 100 / (s - u);
+__name(trackFinger, "trackFinger");
+function valueToPercent(value, min, max) {
+  return (value - min) * 100 / (max - min);
 }
-function Ve(n, u, s) {
-  return (s - u) * n + u;
+__name(valueToPercent, "valueToPercent");
+function percentToValue(percent, min, max) {
+  return (max - min) * percent + min;
 }
-function Oe(n) {
-  if (Math.abs(n) < 1) {
-    const s = n.toExponential().split("e-"), r = s[0].split(".")[1];
-    return (r ? r.length : 0) + parseInt(s[1], 10);
+__name(percentToValue, "percentToValue");
+function getDecimalPrecision(num) {
+  if (Math.abs(num) < 1) {
+    const parts = num.toExponential().split("e-");
+    const matissaDecimalPart = parts[0].split(".")[1];
+    return (matissaDecimalPart ? matissaDecimalPart.length : 0) + parseInt(parts[1], 10);
   }
-  const u = n.toString().split(".")[1];
-  return u ? u.length : 0;
+  const decimalPart = num.toString().split(".")[1];
+  return decimalPart ? decimalPart.length : 0;
 }
-function Pe(n, u, s) {
-  const r = Math.round((n - s) / u) * u + s;
-  return Number(r.toFixed(Oe(u)));
+__name(getDecimalPrecision, "getDecimalPrecision");
+function roundValueToStep(value, step, min) {
+  const nearest = Math.round((value - min) / step) * step + min;
+  return Number(nearest.toFixed(getDecimalPrecision(step)));
 }
-function de({
-  values: n,
-  newValue: u,
-  index: s
+__name(roundValueToStep, "roundValueToStep");
+function setValueIndex({
+  values,
+  newValue,
+  index
 }) {
-  const r = n.slice();
-  return r[s] = u, r.sort(pe);
+  const output = values.slice();
+  output[index] = newValue;
+  return output.sort(asc);
 }
-function _({
-  sliderRef: n,
-  activeIndex: u,
-  setActive: s
+__name(setValueIndex, "setValueIndex");
+function focusThumb({
+  sliderRef,
+  activeIndex,
+  setActive
 }) {
-  var m, T, b;
-  const r = U(n.current);
-  (!((m = n.current) != null && m.contains(r.activeElement)) || Number((T = r == null ? void 0 : r.activeElement) == null ? void 0 : T.getAttribute("data-index")) !== u) && ((b = n.current) == null || b.querySelector(`[type="range"][data-index="${u}"]`).focus()), s && s(u);
+  var _a, _b, _c;
+  const doc = ownerDocument(sliderRef.current);
+  if (!((_a = sliderRef.current) == null ? void 0 : _a.contains(doc.activeElement)) || Number((_b = doc == null ? void 0 : doc.activeElement) == null ? void 0 : _b.getAttribute("data-index")) !== activeIndex) {
+    (_c = sliderRef.current) == null ? void 0 : _c.querySelector(`[type="range"][data-index="${activeIndex}"]`).focus();
+  }
+  if (setActive) {
+    setActive(activeIndex);
+  }
 }
-function j(n, u) {
-  return typeof n == "number" && typeof u == "number" ? n === u : typeof n == "object" && typeof u == "object" ? Ne(n, u) : !1;
+__name(focusThumb, "focusThumb");
+function areValuesEqual(newValue, oldValue) {
+  if (typeof newValue === "number" && typeof oldValue === "number") {
+    return newValue === oldValue;
+  }
+  if (typeof newValue === "object" && typeof oldValue === "object") {
+    return areArraysEqual(newValue, oldValue);
+  }
+  return false;
 }
-const Fe = {
+__name(areValuesEqual, "areValuesEqual");
+const axisProps = {
   horizontal: {
-    offset: (n) => ({
-      left: `${n}%`
-    }),
-    leap: (n) => ({
-      width: `${n}%`
-    })
+    offset: /* @__PURE__ */ __name((percent) => ({
+      left: `${percent}%`
+    }), "offset"),
+    leap: /* @__PURE__ */ __name((percent) => ({
+      width: `${percent}%`
+    }), "leap")
   },
   "horizontal-reverse": {
-    offset: (n) => ({
-      right: `${n}%`
-    }),
-    leap: (n) => ({
-      width: `${n}%`
-    })
+    offset: /* @__PURE__ */ __name((percent) => ({
+      right: `${percent}%`
+    }), "offset"),
+    leap: /* @__PURE__ */ __name((percent) => ({
+      width: `${percent}%`
+    }), "leap")
   },
   vertical: {
-    offset: (n) => ({
-      bottom: `${n}%`
-    }),
-    leap: (n) => ({
-      height: `${n}%`
-    })
+    offset: /* @__PURE__ */ __name((percent) => ({
+      bottom: `${percent}%`
+    }), "offset"),
+    leap: /* @__PURE__ */ __name((percent) => ({
+      height: `${percent}%`
+    }), "leap")
   }
-}, $e = (n) => n;
-let q;
-function me() {
-  return q === void 0 && (typeof CSS < "u" && typeof CSS.supports == "function" ? q = CSS.supports("touch-action", "none") : q = !0), q;
+};
+const Identity = /* @__PURE__ */ __name((x) => x, "Identity");
+let cachedSupportsTouchActionNone;
+function doesSupportTouchActionNone() {
+  if (cachedSupportsTouchActionNone === void 0) {
+    if (typeof CSS !== "undefined" && typeof CSS.supports === "function") {
+      cachedSupportsTouchActionNone = CSS.supports("touch-action", "none");
+    } else {
+      cachedSupportsTouchActionNone = true;
+    }
+  }
+  return cachedSupportsTouchActionNone;
 }
-function Ze(n) {
+__name(doesSupportTouchActionNone, "doesSupportTouchActionNone");
+function useSlider(parameters) {
   const {
-    "aria-labelledby": u,
-    defaultValue: s,
-    disabled: r = !1,
-    disableSwap: m = !1,
-    isRtl: T = !1,
-    marks: b = !1,
-    max: y = 100,
-    min: d = 0,
-    name: Z,
-    onChange: H,
-    onChangeCommitted: V,
-    orientation: X = "horizontal",
-    rootRef: ge,
-    scale: ee = $e,
-    step: I = 1,
-    shiftStep: te = 10,
-    tabIndex: be,
-    value: ye
-  } = n, k = g.useRef(void 0), [O, A] = g.useState(-1), [xe, D] = g.useState(-1), [ne, oe] = g.useState(!1), P = g.useRef(0), [S, F] = Ae({
-    controlled: ye,
-    default: s ?? d,
+    "aria-labelledby": ariaLabelledby,
+    defaultValue,
+    disabled = false,
+    disableSwap = false,
+    isRtl = false,
+    marks: marksProp = false,
+    max = 100,
+    min = 0,
+    name,
+    onChange,
+    onChangeCommitted,
+    orientation = "horizontal",
+    rootRef: ref,
+    scale = Identity,
+    step = 1,
+    shiftStep = 10,
+    tabIndex,
+    value: valueProp
+  } = parameters;
+  const touchId = React.useRef(void 0);
+  const [active, setActive] = React.useState(-1);
+  const [open, setOpen] = React.useState(-1);
+  const [dragging, setDragging] = React.useState(false);
+  const moveCount = React.useRef(0);
+  const [valueDerived, setValueState] = useControlled({
+    controlled: valueProp,
+    default: defaultValue ?? min,
     name: "Slider"
-  }), v = H && ((e, t, o) => {
-    const c = e.nativeEvent || e, a = new c.constructor(c.type, c);
-    Object.defineProperty(a, "target", {
-      writable: !0,
+  });
+  const handleChange = onChange && ((event, value, thumbIndex) => {
+    const nativeEvent = event.nativeEvent || event;
+    const clonedEvent = new nativeEvent.constructor(nativeEvent.type, nativeEvent);
+    Object.defineProperty(clonedEvent, "target", {
+      writable: true,
       value: {
-        value: t,
-        name: Z
+        value,
+        name
+      }
+    });
+    onChange(clonedEvent, value, thumbIndex);
+  });
+  const range = Array.isArray(valueDerived);
+  let values = range ? valueDerived.slice().sort(asc) : [valueDerived];
+  values = values.map((value) => value == null ? min : clamp(value, min, max));
+  const marks = marksProp === true && step !== null ? [...Array(Math.floor((max - min) / step) + 1)].map((_, index) => ({
+    value: min + step * index
+  })) : marksProp || [];
+  const marksValues = marks.map((mark) => mark.value);
+  const [focusedThumbIndex, setFocusedThumbIndex] = React.useState(-1);
+  const sliderRef = React.useRef(null);
+  const handleRef = useForkRef(ref, sliderRef);
+  const createHandleHiddenInputFocus = /* @__PURE__ */ __name((otherHandlers) => (event) => {
+    var _a;
+    const index = Number(event.currentTarget.getAttribute("data-index"));
+    if (isFocusVisible(event.target)) {
+      setFocusedThumbIndex(index);
+    }
+    setOpen(index);
+    (_a = otherHandlers == null ? void 0 : otherHandlers.onFocus) == null ? void 0 : _a.call(otherHandlers, event);
+  }, "createHandleHiddenInputFocus");
+  const createHandleHiddenInputBlur = /* @__PURE__ */ __name((otherHandlers) => (event) => {
+    var _a;
+    if (!isFocusVisible(event.target)) {
+      setFocusedThumbIndex(-1);
+    }
+    setOpen(-1);
+    (_a = otherHandlers == null ? void 0 : otherHandlers.onBlur) == null ? void 0 : _a.call(otherHandlers, event);
+  }, "createHandleHiddenInputBlur");
+  const changeValue = /* @__PURE__ */ __name((event, valueInput) => {
+    const index = Number(event.currentTarget.getAttribute("data-index"));
+    const value = values[index];
+    const marksIndex = marksValues.indexOf(value);
+    let newValue = valueInput;
+    if (marks && step == null) {
+      const maxMarksValue = marksValues[marksValues.length - 1];
+      if (newValue > maxMarksValue) {
+        newValue = maxMarksValue;
+      } else if (newValue < marksValues[0]) {
+        newValue = marksValues[0];
+      } else {
+        newValue = newValue < value ? marksValues[marksIndex - 1] : marksValues[marksIndex + 1];
       }
-    }), H(a, t, o);
-  }), C = Array.isArray(S);
-  let f = C ? S.slice().sort(pe) : [S];
-  f = f.map((e) => e == null ? d : R(e, d, y));
-  const Y = b === !0 && I !== null ? [...Array(Math.floor((y - d) / I) + 1)].map((e, t) => ({
-    value: d + I * t
-  })) : b || [], x = Y.map((e) => e.value), [ue, $] = g.useState(-1), p = g.useRef(null), ie = De(ge, p), he = (e) => (t) => {
-    var c;
-    const o = Number(t.currentTarget.getAttribute("data-index"));
-    ae(t.target) && $(o), D(o), (c = e == null ? void 0 : e.onFocus) == null || c.call(e, t);
-  }, ve = (e) => (t) => {
-    var o;
-    ae(t.target) || $(-1), D(-1), (o = e == null ? void 0 : e.onBlur) == null || o.call(e, t);
-  }, re = (e, t) => {
-    const o = Number(e.currentTarget.getAttribute("data-index")), c = f[o], a = x.indexOf(c);
-    let i = t;
-    if (Y && I == null) {
-      const h = x[x.length - 1];
-      i > h ? i = h : i < x[0] ? i = x[0] : i = i < c ? x[a - 1] : x[a + 1];
     }
-    if (i = R(i, d, y), C) {
-      m && (i = R(i, f[o - 1] || -1 / 0, f[o + 1] || 1 / 0));
-      const h = i;
-      i = de({
-        values: f,
-        newValue: i,
-        index: o
+    newValue = clamp(newValue, min, max);
+    if (range) {
+      if (disableSwap) {
+        newValue = clamp(newValue, values[index - 1] || -Infinity, values[index + 1] || Infinity);
+      }
+      const previousValue = newValue;
+      newValue = setValueIndex({
+        values,
+        newValue,
+        index
       });
-      let w = o;
-      m || (w = i.indexOf(h)), _({
-        sliderRef: p,
-        activeIndex: w
+      let activeIndex = index;
+      if (!disableSwap) {
+        activeIndex = newValue.indexOf(previousValue);
+      }
+      focusThumb({
+        sliderRef,
+        activeIndex
       });
     }
-    F(i), $(o), v && !j(i, S) && v(e, i, o), V && V(e, i);
-  }, we = (e) => (t) => {
-    var o;
-    if (I !== null) {
-      const c = Number(t.currentTarget.getAttribute("data-index")), a = f[c];
-      let i = null;
-      (t.key === "ArrowLeft" || t.key === "ArrowDown") && t.shiftKey || t.key === "PageDown" ? i = Math.max(a - te, d) : ((t.key === "ArrowRight" || t.key === "ArrowUp") && t.shiftKey || t.key === "PageUp") && (i = Math.min(a + te, y)), i !== null && (re(t, i), t.preventDefault());
+    setValueState(newValue);
+    setFocusedThumbIndex(index);
+    if (handleChange && !areValuesEqual(newValue, valueDerived)) {
+      handleChange(event, newValue, index);
     }
-    (o = e == null ? void 0 : e.onKeyDown) == null || o.call(e, t);
-  };
-  Ce(() => {
-    var e;
-    r && p.current.contains(document.activeElement) && ((e = document.activeElement) == null || e.blur());
-  }, [r]), r && O !== -1 && A(-1), r && ue !== -1 && $(-1);
-  const Ee = (e) => (t) => {
-    var o;
-    (o = e.onChange) == null || o.call(e, t), re(t, t.target.valueAsNumber);
-  }, ce = g.useRef(void 0);
-  let K = X;
-  T && X === "horizontal" && (K += "-reverse");
-  const z = ({
-    finger: e,
-    move: t = !1
+    if (onChangeCommitted) {
+      onChangeCommitted(event, newValue);
+    }
+  }, "changeValue");
+  const createHandleHiddenInputKeyDown = /* @__PURE__ */ __name((otherHandlers) => (event) => {
+    var _a;
+    if (step !== null) {
+      const index = Number(event.currentTarget.getAttribute("data-index"));
+      const value = values[index];
+      let newValue = null;
+      if ((event.key === "ArrowLeft" || event.key === "ArrowDown") && event.shiftKey || event.key === "PageDown") {
+        newValue = Math.max(value - shiftStep, min);
+      } else if ((event.key === "ArrowRight" || event.key === "ArrowUp") && event.shiftKey || event.key === "PageUp") {
+        newValue = Math.min(value + shiftStep, max);
+      }
+      if (newValue !== null) {
+        changeValue(event, newValue);
+        event.preventDefault();
+      }
+    }
+    (_a = otherHandlers == null ? void 0 : otherHandlers.onKeyDown) == null ? void 0 : _a.call(otherHandlers, event);
+  }, "createHandleHiddenInputKeyDown");
+  useEnhancedEffect(() => {
+    var _a;
+    if (disabled && sliderRef.current.contains(document.activeElement)) {
+      (_a = document.activeElement) == null ? void 0 : _a.blur();
+    }
+  }, [disabled]);
+  if (disabled && active !== -1) {
+    setActive(-1);
+  }
+  if (disabled && focusedThumbIndex !== -1) {
+    setFocusedThumbIndex(-1);
+  }
+  const createHandleHiddenInputChange = /* @__PURE__ */ __name((otherHandlers) => (event) => {
+    var _a;
+    (_a = otherHandlers.onChange) == null ? void 0 : _a.call(otherHandlers, event);
+    changeValue(event, event.target.valueAsNumber);
+  }, "createHandleHiddenInputChange");
+  const previousIndex = React.useRef(void 0);
+  let axis = orientation;
+  if (isRtl && orientation === "horizontal") {
+    axis += "-reverse";
+  }
+  const getFingerNewValue = /* @__PURE__ */ __name(({
+    finger,
+    move = false
   }) => {
     const {
-      current: o
-    } = p, {
-      width: c,
-      height: a,
-      bottom: i,
-      left: h
-    } = o.getBoundingClientRect();
-    let w;
-    K.startsWith("vertical") ? w = (i - e.y) / a : w = (e.x - h) / c, K.indexOf("-reverse") !== -1 && (w = 1 - w);
-    let l;
-    if (l = Ve(w, d, y), I)
-      l = Pe(l, I, d);
-    else {
-      const W = fe(x, l);
-      l = x[W];
+      current: slider
+    } = sliderRef;
+    const {
+      width,
+      height,
+      bottom,
+      left
+    } = slider.getBoundingClientRect();
+    let percent;
+    if (axis.startsWith("vertical")) {
+      percent = (bottom - finger.y) / height;
+    } else {
+      percent = (finger.x - left) / width;
     }
-    l = R(l, d, y);
-    let E = 0;
-    if (C) {
-      t ? E = ce.current : E = fe(f, l), m && (l = R(l, f[E - 1] || -1 / 0, f[E + 1] || 1 / 0));
-      const W = l;
-      l = de({
-        values: f,
-        newValue: l,
-        index: E
-      }), m && t || (E = l.indexOf(W), ce.current = E);
+    if (axis.indexOf("-reverse") !== -1) {
+      percent = 1 - percent;
+    }
+    let newValue;
+    newValue = percentToValue(percent, min, max);
+    if (step) {
+      newValue = roundValueToStep(newValue, step, min);
+    } else {
+      const closestIndex = findClosest(marksValues, newValue);
+      newValue = marksValues[closestIndex];
+    }
+    newValue = clamp(newValue, min, max);
+    let activeIndex = 0;
+    if (range) {
+      if (!move) {
+        activeIndex = findClosest(values, newValue);
+      } else {
+        activeIndex = previousIndex.current;
+      }
+      if (disableSwap) {
+        newValue = clamp(newValue, values[activeIndex - 1] || -Infinity, values[activeIndex + 1] || Infinity);
+      }
+      const previousValue = newValue;
+      newValue = setValueIndex({
+        values,
+        newValue,
+        index: activeIndex
+      });
+      if (!(disableSwap && move)) {
+        activeIndex = newValue.indexOf(previousValue);
+        previousIndex.current = activeIndex;
+      }
     }
     return {
-      newValue: l,
-      activeIndex: E
+      newValue,
+      activeIndex
     };
-  }, M = J((e) => {
-    const t = B(e, k);
-    if (!t)
+  }, "getFingerNewValue");
+  const handleTouchMove = useEventCallback((nativeEvent) => {
+    const finger = trackFinger(nativeEvent, touchId);
+    if (!finger) {
       return;
-    if (P.current += 1, e.type === "mousemove" && e.buttons === 0) {
-      L(e);
+    }
+    moveCount.current += 1;
+    if (nativeEvent.type === "mousemove" && nativeEvent.buttons === 0) {
+      handleTouchEnd(nativeEvent);
       return;
     }
     const {
-      newValue: o,
-      activeIndex: c
-    } = z({
-      finger: t,
-      move: !0
+      newValue,
+      activeIndex
+    } = getFingerNewValue({
+      finger,
+      move: true
     });
-    _({
-      sliderRef: p,
-      activeIndex: c,
-      setActive: A
-    }), F(o), !ne && P.current > Re && oe(!0), v && !j(o, S) && v(e, o, c);
-  }), L = J((e) => {
-    const t = B(e, k);
-    if (oe(!1), !t)
+    focusThumb({
+      sliderRef,
+      activeIndex,
+      setActive
+    });
+    setValueState(newValue);
+    if (!dragging && moveCount.current > INTENTIONAL_DRAG_COUNT_THRESHOLD) {
+      setDragging(true);
+    }
+    if (handleChange && !areValuesEqual(newValue, valueDerived)) {
+      handleChange(nativeEvent, newValue, activeIndex);
+    }
+  });
+  const handleTouchEnd = useEventCallback((nativeEvent) => {
+    const finger = trackFinger(nativeEvent, touchId);
+    setDragging(false);
+    if (!finger) {
       return;
+    }
     const {
-      newValue: o
-    } = z({
-      finger: t,
-      move: !0
+      newValue
+    } = getFingerNewValue({
+      finger,
+      move: true
     });
-    A(-1), e.type === "touchend" && D(-1), V && V(e, o), k.current = void 0, N();
-  }), G = J((e) => {
-    if (r)
+    setActive(-1);
+    if (nativeEvent.type === "touchend") {
+      setOpen(-1);
+    }
+    if (onChangeCommitted) {
+      onChangeCommitted(nativeEvent, newValue);
+    }
+    touchId.current = void 0;
+    stopListening();
+  });
+  const handleTouchStart = useEventCallback((nativeEvent) => {
+    if (disabled) {
       return;
-    me() || e.preventDefault();
-    const t = e.changedTouches[0];
-    t != null && (k.current = t.identifier);
-    const o = B(e, k);
-    if (o !== !1) {
+    }
+    if (!doesSupportTouchActionNone()) {
+      nativeEvent.preventDefault();
+    }
+    const touch = nativeEvent.changedTouches[0];
+    if (touch != null) {
+      touchId.current = touch.identifier;
+    }
+    const finger = trackFinger(nativeEvent, touchId);
+    if (finger !== false) {
       const {
-        newValue: a,
-        activeIndex: i
-      } = z({
-        finger: o
+        newValue,
+        activeIndex
+      } = getFingerNewValue({
+        finger
       });
-      _({
-        sliderRef: p,
-        activeIndex: i,
-        setActive: A
-      }), F(a), v && !j(a, S) && v(e, a, i);
+      focusThumb({
+        sliderRef,
+        activeIndex,
+        setActive
+      });
+      setValueState(newValue);
+      if (handleChange && !areValuesEqual(newValue, valueDerived)) {
+        handleChange(nativeEvent, newValue, activeIndex);
+      }
     }
-    P.current = 0;
-    const c = U(p.current);
-    c.addEventListener("touchmove", M, {
-      passive: !0
-    }), c.addEventListener("touchend", L, {
-      passive: !0
+    moveCount.current = 0;
+    const doc = ownerDocument(sliderRef.current);
+    doc.addEventListener("touchmove", handleTouchMove, {
+      passive: true
+    });
+    doc.addEventListener("touchend", handleTouchEnd, {
+      passive: true
     });
-  }), N = g.useCallback(() => {
-    const e = U(p.current);
-    e.removeEventListener("mousemove", M), e.removeEventListener("mouseup", L), e.removeEventListener("touchmove", M), e.removeEventListener("touchend", L);
-  }, [L, M]);
-  g.useEffect(() => {
+  });
+  const stopListening = React.useCallback(() => {
+    const doc = ownerDocument(sliderRef.current);
+    doc.removeEventListener("mousemove", handleTouchMove);
+    doc.removeEventListener("mouseup", handleTouchEnd);
+    doc.removeEventListener("touchmove", handleTouchMove);
+    doc.removeEventListener("touchend", handleTouchEnd);
+  }, [handleTouchEnd, handleTouchMove]);
+  React.useEffect(() => {
     const {
-      current: e
-    } = p;
-    return e.addEventListener("touchstart", G, {
-      passive: me()
-    }), () => {
-      e.removeEventListener("touchstart", G), N();
+      current: slider
+    } = sliderRef;
+    slider.addEventListener("touchstart", handleTouchStart, {
+      passive: doesSupportTouchActionNone()
+    });
+    return () => {
+      slider.removeEventListener("touchstart", handleTouchStart);
+      stopListening();
     };
-  }, [N, G]), g.useEffect(() => {
-    r && N();
-  }, [r, N]);
-  const Te = (e) => (t) => {
-    var a;
-    if ((a = e.onMouseDown) == null || a.call(e, t), r || t.defaultPrevented || t.button !== 0)
+  }, [stopListening, handleTouchStart]);
+  React.useEffect(() => {
+    if (disabled) {
+      stopListening();
+    }
+  }, [disabled, stopListening]);
+  const createHandleMouseDown = /* @__PURE__ */ __name((otherHandlers) => (event) => {
+    var _a;
+    (_a = otherHandlers.onMouseDown) == null ? void 0 : _a.call(otherHandlers, event);
+    if (disabled) {
       return;
-    t.preventDefault();
-    const o = B(t, k);
-    if (o !== !1) {
+    }
+    if (event.defaultPrevented) {
+      return;
+    }
+    if (event.button !== 0) {
+      return;
+    }
+    event.preventDefault();
+    const finger = trackFinger(event, touchId);
+    if (finger !== false) {
       const {
-        newValue: i,
-        activeIndex: h
-      } = z({
-        finger: o
+        newValue,
+        activeIndex
+      } = getFingerNewValue({
+        finger
       });
-      _({
-        sliderRef: p,
-        activeIndex: h,
-        setActive: A
-      }), F(i), v && !j(i, S) && v(t, i, h);
+      focusThumb({
+        sliderRef,
+        activeIndex,
+        setActive
+      });
+      setValueState(newValue);
+      if (handleChange && !areValuesEqual(newValue, valueDerived)) {
+        handleChange(event, newValue, activeIndex);
+      }
     }
-    P.current = 0;
-    const c = U(p.current);
-    c.addEventListener("mousemove", M, {
-      passive: !0
-    }), c.addEventListener("mouseup", L);
-  }, se = le(C ? f[0] : d, d, y), Ie = le(f[f.length - 1], d, y) - se, Se = (e = {}) => {
-    const t = Q(e), o = {
-      onMouseDown: Te(t || {})
-    }, c = {
-      ...t,
-      ...o
+    moveCount.current = 0;
+    const doc = ownerDocument(sliderRef.current);
+    doc.addEventListener("mousemove", handleTouchMove, {
+      passive: true
+    });
+    doc.addEventListener("mouseup", handleTouchEnd);
+  }, "createHandleMouseDown");
+  const trackOffset = valueToPercent(range ? values[0] : min, min, max);
+  const trackLeap = valueToPercent(values[values.length - 1], min, max) - trackOffset;
+  const getRootProps = /* @__PURE__ */ __name((externalProps = {}) => {
+    const externalHandlers = extractEventHandlers(externalProps);
+    const ownEventHandlers = {
+      onMouseDown: createHandleMouseDown(externalHandlers || {})
+    };
+    const mergedEventHandlers = {
+      ...externalHandlers,
+      ...ownEventHandlers
     };
     return {
-      ...e,
-      ref: ie,
-      ...c
+      ...externalProps,
+      ref: handleRef,
+      ...mergedEventHandlers
     };
-  }, ke = (e) => (t) => {
-    var c;
-    (c = e.onMouseOver) == null || c.call(e, t);
-    const o = Number(t.currentTarget.getAttribute("data-index"));
-    D(o);
-  }, Le = (e) => (t) => {
-    var o;
-    (o = e.onMouseLeave) == null || o.call(e, t), D(-1);
-  };
-  return {
-    active: O,
-    axis: K,
-    axisProps: Fe,
-    dragging: ne,
-    focusedThumbIndex: ue,
-    getHiddenInputProps: (e = {}) => {
-      const t = Q(e), o = {
-        onChange: Ee(t || {}),
-        onFocus: he(t || {}),
-        onBlur: ve(t || {}),
-        onKeyDown: we(t || {})
-      }, c = {
-        ...t,
-        ...o
-      };
-      return {
-        tabIndex: be,
-        "aria-labelledby": u,
-        "aria-orientation": X,
-        "aria-valuemax": ee(y),
-        "aria-valuemin": ee(d),
-        name: Z,
-        type: "range",
-        min: n.min,
-        max: n.max,
-        step: n.step === null && n.marks ? "any" : n.step ?? void 0,
-        disabled: r,
-        ...e,
-        ...c,
-        style: {
-          ...Me,
-          direction: T ? "rtl" : "ltr",
-          // So that VoiceOver's focus indicator matches the thumb's dimensions
-          width: "100%",
-          height: "100%"
-        }
-      };
-    },
-    getRootProps: Se,
-    getThumbProps: (e = {}) => {
-      const t = Q(e), o = {
-        onMouseOver: ke(t || {}),
-        onMouseLeave: Le(t || {})
-      };
-      return {
-        ...e,
-        ...t,
-        ...o
-      };
-    },
-    marks: Y,
-    open: xe,
-    range: C,
-    rootRef: ie,
-    trackLeap: Ie,
-    trackOffset: se,
-    values: f,
-    getThumbStyle: (e) => ({
+  }, "getRootProps");
+  const createHandleMouseOver = /* @__PURE__ */ __name((otherHandlers) => (event) => {
+    var _a;
+    (_a = otherHandlers.onMouseOver) == null ? void 0 : _a.call(otherHandlers, event);
+    const index = Number(event.currentTarget.getAttribute("data-index"));
+    setOpen(index);
+  }, "createHandleMouseOver");
+  const createHandleMouseLeave = /* @__PURE__ */ __name((otherHandlers) => (event) => {
+    var _a;
+    (_a = otherHandlers.onMouseLeave) == null ? void 0 : _a.call(otherHandlers, event);
+    setOpen(-1);
+  }, "createHandleMouseLeave");
+  const getThumbProps = /* @__PURE__ */ __name((externalProps = {}) => {
+    const externalHandlers = extractEventHandlers(externalProps);
+    const ownEventHandlers = {
+      onMouseOver: createHandleMouseOver(externalHandlers || {}),
+      onMouseLeave: createHandleMouseLeave(externalHandlers || {})
+    };
+    return {
+      ...externalProps,
+      ...externalHandlers,
+      ...ownEventHandlers
+    };
+  }, "getThumbProps");
+  const getThumbStyle = /* @__PURE__ */ __name((index) => {
+    return {
       // So the non active thumb doesn't show its label on hover.
-      pointerEvents: O !== -1 && O !== e ? "none" : void 0
-    })
+      pointerEvents: active !== -1 && active !== index ? "none" : void 0
+    };
+  }, "getThumbStyle");
+  const getHiddenInputProps = /* @__PURE__ */ __name((externalProps = {}) => {
+    const externalHandlers = extractEventHandlers(externalProps);
+    const ownEventHandlers = {
+      onChange: createHandleHiddenInputChange(externalHandlers || {}),
+      onFocus: createHandleHiddenInputFocus(externalHandlers || {}),
+      onBlur: createHandleHiddenInputBlur(externalHandlers || {}),
+      onKeyDown: createHandleHiddenInputKeyDown(externalHandlers || {})
+    };
+    const mergedEventHandlers = {
+      ...externalHandlers,
+      ...ownEventHandlers
+    };
+    return {
+      tabIndex,
+      "aria-labelledby": ariaLabelledby,
+      "aria-orientation": orientation,
+      "aria-valuemax": scale(max),
+      "aria-valuemin": scale(min),
+      name,
+      type: "range",
+      min: parameters.min,
+      max: parameters.max,
+      step: parameters.step === null && parameters.marks ? "any" : parameters.step ?? void 0,
+      disabled,
+      ...externalProps,
+      ...mergedEventHandlers,
+      style: {
+        ...visuallyHidden,
+        direction: isRtl ? "rtl" : "ltr",
+        // So that VoiceOver's focus indicator matches the thumb's dimensions
+        width: "100%",
+        height: "100%"
+      }
+    };
+  }, "getHiddenInputProps");
+  return {
+    active,
+    axis,
+    axisProps,
+    dragging,
+    focusedThumbIndex,
+    getHiddenInputProps,
+    getRootProps,
+    getThumbProps,
+    marks,
+    open,
+    range,
+    rootRef: handleRef,
+    trackLeap,
+    trackOffset,
+    values,
+    getThumbStyle
   };
 }
+__name(useSlider, "useSlider");
 export {
-  $e as Identity,
-  Ze as useSlider,
-  le as valueToPercent
+  Identity,
+  useSlider,
+  valueToPercent
 };