impact-ui 4.0.16 → 4.0.17-alpha.2

package/dist/node_modules/@mui/material/node_modules/@mui/base/TextareaAutosize/TextareaAutosize.js

@@ -0,0 +1,226 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import * as React from "react";
+import PropTypes from "../../../../../../prop-types/index.js";
+import * as ReactDOM from "react-dom";
+import { jsxs, jsx } from "react/jsx-runtime";
+import useForkRef from "../../../../../utils/useForkRef/useForkRef.js";
+import ownerWindow from "../../../../../utils/ownerWindow/ownerWindow.js";
+import debounce from "../../../../../utils/debounce/debounce.js";
+import useEnhancedEffect from "../../../../../utils/useEnhancedEffect/useEnhancedEffect.js";
+const _excluded = ["onChange", "maxRows", "minRows", "style", "value"];
+function getStyleValue(value) {
+  return parseInt(value, 10) || 0;
+}
+const styles = {
+  shadow: {
+    // Visibility needed to hide the extra text area on iPads
+    visibility: "hidden",
+    // Remove from the content flow
+    position: "absolute",
+    // Ignore the scrollbar width
+    overflow: "hidden",
+    height: 0,
+    top: 0,
+    left: 0,
+    // Create a new layer, increase the isolation of the computed values
+    transform: "translateZ(0)"
+  }
+};
+function isEmpty(obj) {
+  return obj === void 0 || obj === null || Object.keys(obj).length === 0 || obj.outerHeightStyle === 0 && !obj.overflow;
+}
+const TextareaAutosize = /* @__PURE__ */ React.forwardRef(function TextareaAutosize2(props, forwardedRef) {
+  const {
+    onChange,
+    maxRows,
+    minRows = 1,
+    style,
+    value
+  } = props, other = _objectWithoutPropertiesLoose(props, _excluded);
+  const {
+    current: isControlled
+  } = React.useRef(value != null);
+  const inputRef = React.useRef(null);
+  const handleRef = useForkRef(forwardedRef, inputRef);
+  const shadowRef = React.useRef(null);
+  const renders = React.useRef(0);
+  const [state, setState] = React.useState({
+    outerHeightStyle: 0
+  });
+  const getUpdatedState = React.useCallback(() => {
+    const input = inputRef.current;
+    const containerWindow = ownerWindow(input);
+    const computedStyle = containerWindow.getComputedStyle(input);
+    if (computedStyle.width === "0px") {
+      return {
+        outerHeightStyle: 0
+      };
+    }
+    const inputShallow = shadowRef.current;
+    inputShallow.style.width = computedStyle.width;
+    inputShallow.value = input.value || props.placeholder || "x";
+    if (inputShallow.value.slice(-1) === "\n") {
+      inputShallow.value += " ";
+    }
+    const boxSizing = computedStyle.boxSizing;
+    const padding = getStyleValue(computedStyle.paddingBottom) + getStyleValue(computedStyle.paddingTop);
+    const border = getStyleValue(computedStyle.borderBottomWidth) + getStyleValue(computedStyle.borderTopWidth);
+    const innerHeight = inputShallow.scrollHeight;
+    inputShallow.value = "x";
+    const singleRowHeight = inputShallow.scrollHeight;
+    let outerHeight = innerHeight;
+    if (minRows) {
+      outerHeight = Math.max(Number(minRows) * singleRowHeight, outerHeight);
+    }
+    if (maxRows) {
+      outerHeight = Math.min(Number(maxRows) * singleRowHeight, outerHeight);
+    }
+    outerHeight = Math.max(outerHeight, singleRowHeight);
+    const outerHeightStyle = outerHeight + (boxSizing === "border-box" ? padding + border : 0);
+    const overflow = Math.abs(outerHeight - innerHeight) <= 1;
+    return {
+      outerHeightStyle,
+      overflow
+    };
+  }, [maxRows, minRows, props.placeholder]);
+  const updateState = (prevState, newState) => {
+    const {
+      outerHeightStyle,
+      overflow
+    } = newState;
+    if (renders.current < 20 && (outerHeightStyle > 0 && Math.abs((prevState.outerHeightStyle || 0) - outerHeightStyle) > 1 || prevState.overflow !== overflow)) {
+      renders.current += 1;
+      return {
+        overflow,
+        outerHeightStyle
+      };
+    }
+    if (process.env.NODE_ENV !== "production") {
+      if (renders.current === 20) {
+        console.error(["MUI: Too many re-renders. The layout is unstable.", "TextareaAutosize limits the number of renders to prevent an infinite loop."].join("\n"));
+      }
+    }
+    return prevState;
+  };
+  const syncHeight = React.useCallback(() => {
+    const newState = getUpdatedState();
+    if (isEmpty(newState)) {
+      return;
+    }
+    setState((prevState) => {
+      return updateState(prevState, newState);
+    });
+  }, [getUpdatedState]);
+  const syncHeightWithFlushSync = () => {
+    const newState = getUpdatedState();
+    if (isEmpty(newState)) {
+      return;
+    }
+    ReactDOM.flushSync(() => {
+      setState((prevState) => {
+        return updateState(prevState, newState);
+      });
+    });
+  };
+  React.useEffect(() => {
+    const handleResize = debounce(() => {
+      renders.current = 0;
+      if (inputRef.current) {
+        syncHeightWithFlushSync();
+      }
+    });
+    let resizeObserver;
+    const input = inputRef.current;
+    const containerWindow = ownerWindow(input);
+    containerWindow.addEventListener("resize", handleResize);
+    if (typeof ResizeObserver !== "undefined") {
+      resizeObserver = new ResizeObserver(handleResize);
+      resizeObserver.observe(input);
+    }
+    return () => {
+      handleResize.clear();
+      containerWindow.removeEventListener("resize", handleResize);
+      if (resizeObserver) {
+        resizeObserver.disconnect();
+      }
+    };
+  });
+  useEnhancedEffect(() => {
+    syncHeight();
+  });
+  React.useEffect(() => {
+    renders.current = 0;
+  }, [value]);
+  const handleChange = (event) => {
+    renders.current = 0;
+    if (!isControlled) {
+      syncHeight();
+    }
+    if (onChange) {
+      onChange(event);
+    }
+  };
+  return /* @__PURE__ */ jsxs(React.Fragment, {
+    children: [/* @__PURE__ */ jsx("textarea", _extends({
+      value,
+      onChange: handleChange,
+      ref: handleRef,
+      rows: minRows,
+      style: _extends({
+        height: state.outerHeightStyle,
+        // Need a large enough difference to allow scrolling.
+        // This prevents infinite rendering loop.
+        overflow: state.overflow ? "hidden" : void 0
+      }, style)
+    }, other)), /* @__PURE__ */ jsx("textarea", {
+      "aria-hidden": true,
+      className: props.className,
+      readOnly: true,
+      ref: shadowRef,
+      tabIndex: -1,
+      style: _extends({}, styles.shadow, style, {
+        paddingTop: 0,
+        paddingBottom: 0
+      })
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" ? TextareaAutosize.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * Maximum number of rows to display.
+   */
+  maxRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  /**
+   * Minimum number of rows to display.
+   * @default 1
+   */
+  minRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  /**
+   * @ignore
+   */
+  onChange: PropTypes.func,
+  /**
+   * @ignore
+   */
+  placeholder: PropTypes.string,
+  /**
+   * @ignore
+   */
+  style: PropTypes.object,
+  /**
+   * @ignore
+   */
+  value: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.number, PropTypes.string])
+} : void 0;
+export {
+  TextareaAutosize
+};

package/dist/node_modules/@mui/material/{Modal → node_modules/@mui/base/unstable_useModal}/ModalManager.js

@@ -1,6 +1,6 @@
-import getScrollbarSize from "../node_modules/@mui/utils/esm/getScrollbarSize/getScrollbarSize.js";
-import ownerDocument from "../node_modules/@mui/utils/esm/ownerDocument/ownerDocument.js";
-import ownerWindow from "../node_modules/@mui/utils/esm/ownerWindow/ownerWindow.js";
+import getScrollbarSize from "../../../../../utils/getScrollbarSize/getScrollbarSize.js";
+import ownerDocument from "../../../../../utils/ownerDocument/ownerDocument.js";
+import ownerWindow from "../../../../../utils/ownerWindow/ownerWindow.js";
 function isOverflowing(container) {
   const doc = ownerDocument(container);
   if (doc.body === container) {

package/dist/node_modules/@mui/material/{Modal → node_modules/@mui/base/unstable_useModal}/useModal.js

@@ -1,11 +1,11 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from "react";
 import { ModalManager, ariaHidden } from "./ModalManager.js";
-import useForkRef from "../node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
-import useEventCallback from "../node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js";
-import createChainedFunction from "../node_modules/@mui/utils/esm/createChainedFunction/createChainedFunction.js";
-import extractEventHandlers from "../node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
-import ownerDocument from "../node_modules/@mui/utils/esm/ownerDocument/ownerDocument.js";
+import useForkRef from "../../../../../utils/useForkRef/useForkRef.js";
+import useEventCallback from "../../../../../utils/useEventCallback/useEventCallback.js";
+import ownerDocument from "../../../../../utils/ownerDocument/ownerDocument.js";
+import createChainedFunction from "../../../../../utils/createChainedFunction/createChainedFunction.js";
+import { extractEventHandlers } from "../utils/extractEventHandlers.js";
 function getContainer(container) {
   return typeof container === "function" ? container() : container;
 }
@@ -88,9 +88,8 @@ function useModal(parameters) {
   }, [open, handleClose, hasTransition, closeAfterTransition, handleOpen]);
   const createHandleKeyDown = (otherHandlers) => (event) => {
     var _otherHandlers$onKeyD;
-    (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);
-    if (event.key !== "Escape" || event.which === 229 || // Wait until IME is settled.
-    !isTopModal()) {
+    (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null ? void 0 : _otherHandlers$onKeyD.call(otherHandlers, event);
+    if (event.key !== "Escape" || !isTopModal()) {
       return;
     }
     if (!disableEscapeKeyDown) {
@@ -102,7 +101,7 @@ function useModal(parameters) {
   };
   const createHandleBackdropClick = (otherHandlers) => (event) => {
     var _otherHandlers$onClic;
-    (_otherHandlers$onClic = otherHandlers.onClick) == null || _otherHandlers$onClic.call(otherHandlers, event);
+    (_otherHandlers$onClic = otherHandlers.onClick) == null ? void 0 : _otherHandlers$onClic.call(otherHandlers, event);
     if (event.target !== event.currentTarget) {
       return;
     }
@@ -148,8 +147,8 @@ function useModal(parameters) {
       }
     };
     return {
-      onEnter: createChainedFunction(handleEnter, children == null ? void 0 : children.props.onEnter),
-      onExited: createChainedFunction(handleExited, children == null ? void 0 : children.props.onExited)
+      onEnter: createChainedFunction(handleEnter, children.props.onEnter),
+      onExited: createChainedFunction(handleExited, children.props.onExited)
     };
   };
   return {
@@ -164,5 +163,5 @@ function useModal(parameters) {
   };
 }
 export {
-  useModal as default
+  useModal
 };

package/dist/node_modules/@mui/material/{Badge → node_modules/@mui/base/useBadge}/useBadge.js

@@ -1,4 +1,4 @@
-import usePreviousProps from "../node_modules/@mui/utils/esm/usePreviousProps/usePreviousProps.js";
+import usePreviousProps from "../../../../../utils/usePreviousProps/usePreviousProps.js";
 function useBadge(parameters) {
   const {
     badgeContent: badgeContentProp,
@@ -27,5 +27,5 @@ function useBadge(parameters) {
   };
 }
 export {
-  useBadge as default
+  useBadge
 };

package/dist/node_modules/@mui/material/{Slider → node_modules/@mui/base/useSlider}/useSlider.js

@@ -1,19 +1,23 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from "react";
-import areArraysEqual from "../utils/areArraysEqual.js";
-import useControlled from "../node_modules/@mui/utils/esm/useControlled/useControlled.js";
-import clamp from "../node_modules/@mui/utils/esm/clamp/clamp.js";
-import useIsFocusVisible from "../node_modules/@mui/utils/esm/useIsFocusVisible/useIsFocusVisible.js";
-import useForkRef from "../node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
-import useEnhancedEffect from "../node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js";
-import useEventCallback from "../node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js";
-import ownerDocument from "../node_modules/@mui/utils/esm/ownerDocument/ownerDocument.js";
-import extractEventHandlers from "../node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
-import visuallyHidden from "../node_modules/@mui/utils/esm/visuallyHidden/visuallyHidden.js";
+import useControlled from "../../../../../utils/useControlled/useControlled.js";
+import useIsFocusVisible from "../../../../../utils/useIsFocusVisible/useIsFocusVisible.js";
+import useForkRef from "../../../../../utils/useForkRef/useForkRef.js";
+import useEnhancedEffect from "../../../../../utils/useEnhancedEffect/useEnhancedEffect.js";
+import useEventCallback from "../../../../../utils/useEventCallback/useEventCallback.js";
+import ownerDocument from "../../../../../utils/ownerDocument/ownerDocument.js";
+import visuallyHidden from "../../../../../utils/visuallyHidden/visuallyHidden.js";
+import { areArraysEqual } from "../utils/areArraysEqual.js";
 const INTENTIONAL_DRAG_COUNT_THRESHOLD = 2;
 function asc(a, b) {
   return a - b;
 }
+function clamp(value, min, max) {
+  if (value == null) {
+    return min;
+  }
+  return Math.min(Math.max(min, value), max);
+}
 function findClosest(values, currentValue) {
   var _values$reduce;
   const {
@@ -86,7 +90,7 @@ function focusThumb({
   const doc = ownerDocument(sliderRef.current);
   if (!((_sliderRef$current = sliderRef.current) != null && _sliderRef$current.contains(doc.activeElement)) || Number(doc == null || (_doc$activeElement = doc.activeElement) == null ? void 0 : _doc$activeElement.getAttribute("data-index")) !== activeIndex) {
     var _sliderRef$current2;
-    (_sliderRef$current2 = sliderRef.current) == null || _sliderRef$current2.querySelector(`[type="range"][data-index="${activeIndex}"]`).focus();
+    (_sliderRef$current2 = sliderRef.current) == null ? void 0 : _sliderRef$current2.querySelector(`[type="range"][data-index="${activeIndex}"]`).focus();
   }
   if (setActive) {
     setActive(activeIndex);
@@ -156,11 +160,10 @@ function useSlider(parameters) {
     rootRef: ref,
     scale = Identity,
     step = 1,
-    shiftStep = 10,
     tabIndex,
     value: valueProp
   } = parameters;
-  const touchId = React.useRef(void 0);
+  const touchId = React.useRef();
   const [active, setActive] = React.useState(-1);
   const [open, setOpen] = React.useState(-1);
   const [dragging, setDragging] = React.useState(false);
@@ -184,7 +187,7 @@ function useSlider(parameters) {
   });
   const range = Array.isArray(valueDerived);
   let values = range ? valueDerived.slice().sort(asc) : [valueDerived];
-  values = values.map((value) => value == null ? min : clamp(value, min, max));
+  values = values.map((value) => clamp(value, min, max));
   const marks = marksProp === true && step !== null ? [...Array(Math.floor((max - min) / step) + 1)].map((_, index) => ({
     value: min + step * index
   })) : marksProp || [];
@@ -196,7 +199,7 @@ function useSlider(parameters) {
     ref: focusVisibleRef
   } = useIsFocusVisible();
   const [focusedThumbIndex, setFocusedThumbIndex] = React.useState(-1);
-  const sliderRef = React.useRef(null);
+  const sliderRef = React.useRef();
   const handleFocusRef = useForkRef(focusVisibleRef, sliderRef);
   const handleRef = useForkRef(ref, handleFocusRef);
   const createHandleHiddenInputFocus = (otherHandlers) => (event) => {
@@ -207,7 +210,7 @@ function useSlider(parameters) {
       setFocusedThumbIndex(index);
     }
     setOpen(index);
-    otherHandlers == null || (_otherHandlers$onFocu = otherHandlers.onFocus) == null || _otherHandlers$onFocu.call(otherHandlers, event);
+    otherHandlers == null || (_otherHandlers$onFocu = otherHandlers.onFocus) == null ? void 0 : _otherHandlers$onFocu.call(otherHandlers, event);
   };
   const createHandleHiddenInputBlur = (otherHandlers) => (event) => {
     var _otherHandlers$onBlur;
@@ -216,13 +219,27 @@ function useSlider(parameters) {
       setFocusedThumbIndex(-1);
     }
     setOpen(-1);
-    otherHandlers == null || (_otherHandlers$onBlur = otherHandlers.onBlur) == null || _otherHandlers$onBlur.call(otherHandlers, event);
+    otherHandlers == null || (_otherHandlers$onBlur = otherHandlers.onBlur) == null ? void 0 : _otherHandlers$onBlur.call(otherHandlers, event);
   };
-  const changeValue = (event, valueInput) => {
+  useEnhancedEffect(() => {
+    if (disabled && sliderRef.current.contains(document.activeElement)) {
+      var _document$activeEleme;
+      (_document$activeEleme = document.activeElement) == null ? void 0 : _document$activeEleme.blur();
+    }
+  }, [disabled]);
+  if (disabled && active !== -1) {
+    setActive(-1);
+  }
+  if (disabled && focusedThumbIndex !== -1) {
+    setFocusedThumbIndex(-1);
+  }
+  const createHandleHiddenInputChange = (otherHandlers) => (event) => {
+    var _otherHandlers$onChan;
+    (_otherHandlers$onChan = otherHandlers.onChange) == null ? void 0 : _otherHandlers$onChan.call(otherHandlers, event);
     const index = Number(event.currentTarget.getAttribute("data-index"));
     const value = values[index];
     const marksIndex = marksValues.indexOf(value);
-    let newValue = valueInput;
+    let newValue = event.target.valueAsNumber;
     if (marks && step == null) {
       const maxMarksValue = marksValues[marksValues.length - 1];
       if (newValue > maxMarksValue) {
@@ -262,42 +279,7 @@ function useSlider(parameters) {
       onChangeCommitted(event, newValue);
     }
   };
-  const createHandleHiddenInputKeyDown = (otherHandlers) => (event) => {
-    var _otherHandlers$onKeyD;
-    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();
-      }
-    }
-    otherHandlers == null || (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);
-  };
-  useEnhancedEffect(() => {
-    if (disabled && sliderRef.current.contains(document.activeElement)) {
-      var _document$activeEleme;
-      (_document$activeEleme = document.activeElement) == null || _document$activeEleme.blur();
-    }
-  }, [disabled]);
-  if (disabled && active !== -1) {
-    setActive(-1);
-  }
-  if (disabled && focusedThumbIndex !== -1) {
-    setFocusedThumbIndex(-1);
-  }
-  const createHandleHiddenInputChange = (otherHandlers) => (event) => {
-    var _otherHandlers$onChan;
-    (_otherHandlers$onChan = otherHandlers.onChange) == null || _otherHandlers$onChan.call(otherHandlers, event);
-    changeValue(event, event.target.valueAsNumber);
-  };
-  const previousIndex = React.useRef(void 0);
+  const previousIndex = React.useRef();
   let axis = orientation;
   if (isRtl && orientation === "horizontal") {
     axis += "-reverse";
@@ -442,12 +424,8 @@ function useSlider(parameters) {
     }
     moveCount.current = 0;
     const doc = ownerDocument(sliderRef.current);
-    doc.addEventListener("touchmove", handleTouchMove, {
-      passive: true
-    });
-    doc.addEventListener("touchend", handleTouchEnd, {
-      passive: true
-    });
+    doc.addEventListener("touchmove", handleTouchMove);
+    doc.addEventListener("touchend", handleTouchEnd);
   });
   const stopListening = React.useCallback(() => {
     const doc = ownerDocument(sliderRef.current);
@@ -464,7 +442,9 @@ function useSlider(parameters) {
       passive: doesSupportTouchActionNone()
     });
     return () => {
-      slider.removeEventListener("touchstart", handleTouchStart);
+      slider.removeEventListener("touchstart", handleTouchStart, {
+        passive: doesSupportTouchActionNone()
+      });
       stopListening();
     };
   }, [stopListening, handleTouchStart]);
@@ -475,7 +455,7 @@ function useSlider(parameters) {
   }, [disabled, stopListening]);
   const createHandleMouseDown = (otherHandlers) => (event) => {
     var _otherHandlers$onMous;
-    (_otherHandlers$onMous = otherHandlers.onMouseDown) == null || _otherHandlers$onMous.call(otherHandlers, event);
+    (_otherHandlers$onMous = otherHandlers.onMouseDown) == null ? void 0 : _otherHandlers$onMous.call(otherHandlers, event);
     if (disabled) {
       return;
     }
@@ -506,41 +486,37 @@ function useSlider(parameters) {
     }
     moveCount.current = 0;
     const doc = ownerDocument(sliderRef.current);
-    doc.addEventListener("mousemove", handleTouchMove, {
-      passive: true
-    });
+    doc.addEventListener("mousemove", handleTouchMove);
     doc.addEventListener("mouseup", handleTouchEnd);
   };
   const trackOffset = valueToPercent(range ? values[0] : min, min, max);
   const trackLeap = valueToPercent(values[values.length - 1], min, max) - trackOffset;
-  const getRootProps = (externalProps = {}) => {
-    const externalHandlers = extractEventHandlers(externalProps);
+  const getRootProps = (otherHandlers = {}) => {
     const ownEventHandlers = {
-      onMouseDown: createHandleMouseDown(externalHandlers || {})
+      onMouseDown: createHandleMouseDown(otherHandlers || {})
     };
-    const mergedEventHandlers = _extends({}, externalHandlers, ownEventHandlers);
-    return _extends({}, externalProps, {
+    const mergedEventHandlers = _extends({}, otherHandlers, ownEventHandlers);
+    return _extends({
       ref: handleRef
     }, mergedEventHandlers);
   };
   const createHandleMouseOver = (otherHandlers) => (event) => {
     var _otherHandlers$onMous2;
-    (_otherHandlers$onMous2 = otherHandlers.onMouseOver) == null || _otherHandlers$onMous2.call(otherHandlers, event);
+    (_otherHandlers$onMous2 = otherHandlers.onMouseOver) == null ? void 0 : _otherHandlers$onMous2.call(otherHandlers, event);
     const index = Number(event.currentTarget.getAttribute("data-index"));
     setOpen(index);
   };
   const createHandleMouseLeave = (otherHandlers) => (event) => {
     var _otherHandlers$onMous3;
-    (_otherHandlers$onMous3 = otherHandlers.onMouseLeave) == null || _otherHandlers$onMous3.call(otherHandlers, event);
+    (_otherHandlers$onMous3 = otherHandlers.onMouseLeave) == null ? void 0 : _otherHandlers$onMous3.call(otherHandlers, event);
     setOpen(-1);
   };
-  const getThumbProps = (externalProps = {}) => {
-    const externalHandlers = extractEventHandlers(externalProps);
+  const getThumbProps = (otherHandlers = {}) => {
     const ownEventHandlers = {
-      onMouseOver: createHandleMouseOver(externalHandlers || {}),
-      onMouseLeave: createHandleMouseLeave(externalHandlers || {})
+      onMouseOver: createHandleMouseOver(otherHandlers || {}),
+      onMouseLeave: createHandleMouseLeave(otherHandlers || {})
     };
-    return _extends({}, externalProps, externalHandlers, ownEventHandlers);
+    return _extends({}, otherHandlers, ownEventHandlers);
   };
   const getThumbStyle = (index) => {
     return {
@@ -548,16 +524,14 @@ function useSlider(parameters) {
       pointerEvents: active !== -1 && active !== index ? "none" : void 0
     };
   };
-  const getHiddenInputProps = (externalProps = {}) => {
+  const getHiddenInputProps = (otherHandlers = {}) => {
     var _parameters$step;
-    const externalHandlers = extractEventHandlers(externalProps);
     const ownEventHandlers = {
-      onChange: createHandleHiddenInputChange(externalHandlers || {}),
-      onFocus: createHandleHiddenInputFocus(externalHandlers || {}),
-      onBlur: createHandleHiddenInputBlur(externalHandlers || {}),
-      onKeyDown: createHandleHiddenInputKeyDown(externalHandlers || {})
+      onChange: createHandleHiddenInputChange(otherHandlers || {}),
+      onFocus: createHandleHiddenInputFocus(otherHandlers || {}),
+      onBlur: createHandleHiddenInputBlur(otherHandlers || {})
     };
-    const mergedEventHandlers = _extends({}, externalHandlers, ownEventHandlers);
+    const mergedEventHandlers = _extends({}, otherHandlers, ownEventHandlers);
     return _extends({
       tabIndex,
       "aria-labelledby": ariaLabelledby,
@@ -570,7 +544,7 @@ function useSlider(parameters) {
       max: parameters.max,
       step: parameters.step === null && parameters.marks ? "any" : (_parameters$step = parameters.step) != null ? _parameters$step : void 0,
       disabled
-    }, externalProps, mergedEventHandlers, {
+    }, mergedEventHandlers, {
       style: _extends({}, visuallyHidden, {
         direction: isRtl ? "rtl" : "ltr",
         // So that VoiceOver's focus indicator matches the thumb's dimensions