@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/Slider/Slider.js

@@ -1,28 +1,31 @@
-import * as Q from "react";
-import e from "../../../../../../../_virtual/index.js";
-import { clsx as F } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.js";
-import { isHostComponent as E } from "../utils/isHostComponent.js";
-import { getSliderUtilityClass as ke } from "./sliderClasses.js";
-import { resolveComponentProps as Te } from "../utils/resolveComponentProps.js";
-import { useClassNamesOverride as he } from "../utils/ClassNameConfigurator.js";
-import { jsxs as M, jsx as p } from "react/jsx-runtime";
-import { useSlider as Pe, valueToPercent as W } from "../useSlider/useSlider.js";
-import c from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.js";
-import Le from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/composeClasses/composeClasses.js";
-import X from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/chainPropTypes/chainPropTypes.js";
-function Z(l) {
-  return l;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+import PropTypes from "../../../../../../../_virtual/index.js";
+import { clsx } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { isHostComponent } from "../utils/isHostComponent.js";
+import { getSliderUtilityClass } from "./sliderClasses.js";
+import { resolveComponentProps } from "../utils/resolveComponentProps.js";
+import { useClassNamesOverride } from "../utils/ClassNameConfigurator.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useSlider, valueToPercent } from "../useSlider/useSlider.js";
+import useSlotProps from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.js";
+import composeClasses from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/composeClasses/composeClasses.js";
+import chainPropTypes from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/chainPropTypes/chainPropTypes.js";
+function Identity(x) {
+  return x;
 }
-const Oe = (l) => {
+__name(Identity, "Identity");
+const useUtilityClasses = /* @__PURE__ */ __name((ownerState) => {
   const {
-    disabled: m,
-    dragging: L,
-    marked: O,
-    orientation: S,
-    track: f
-  } = l;
-  return Le({
-    root: ["root", m && "disabled", L && "dragging", O && "marked", S === "vertical" && "vertical", f === "inverted" && "trackInverted", f === !1 && "trackFalse"],
+    disabled,
+    dragging,
+    marked,
+    orientation,
+    track
+  } = ownerState;
+  const slots = {
+    root: ["root", disabled && "disabled", dragging && "dragging", marked && "marked", orientation === "vertical" && "vertical", track === "inverted" && "trackInverted", track === false && "trackFalse"],
     rail: ["rail"],
     track: ["track"],
     mark: ["mark"],
@@ -30,202 +33,232 @@ const Oe = (l) => {
     markLabel: ["markLabel"],
     markLabelActive: ["markLabelActive"],
     valueLabel: ["valueLabel"],
-    thumb: ["thumb", m && "disabled"],
+    thumb: ["thumb", disabled && "disabled"],
     active: ["active"],
     disabled: ["disabled"],
     focusVisible: ["focusVisible"]
-  }, he(ke));
-}, Se = /* @__PURE__ */ Q.forwardRef(function(m, L) {
+  };
+  return composeClasses(slots, useClassNamesOverride(getSliderUtilityClass));
+}, "useUtilityClasses");
+const Slider = /* @__PURE__ */ React.forwardRef(/* @__PURE__ */ __name(function Slider2(props, forwardedRef) {
   const {
-    "aria-label": O,
-    "aria-valuetext": S,
-    "aria-labelledby": f,
-    className: U,
-    disableSwap: $ = !1,
-    disabled: z = !1,
-    getAriaLabel: H,
-    getAriaValueText: Y,
-    marks: ee = !1,
-    max: d = 100,
-    min: y = 0,
-    name: xe,
-    onChange: Ae,
-    onChangeCommitted: Ne,
-    orientation: ae = "horizontal",
-    shiftStep: te = 10,
-    scale: v = Z,
-    step: re = 1,
-    tabIndex: Ve,
-    track: g = "normal",
-    value: Ce,
-    valueLabelFormat: b = Z,
-    isRtl: le = !1,
-    defaultValue: oe,
-    slotProps: i = {},
-    slots: u = {},
-    ...ne
-  } = m, q = {
-    ...m,
-    marks: ee,
-    disabled: z,
-    disableSwap: $,
-    isRtl: le,
-    defaultValue: oe,
-    max: d,
-    min: y,
-    orientation: ae,
-    scale: v,
-    step: re,
-    shiftStep: te,
-    track: g,
-    valueLabelFormat: b
-  }, {
-    axisProps: k,
-    getRootProps: se,
-    getHiddenInputProps: ie,
-    getThumbProps: ue,
-    active: x,
-    axis: T,
-    range: D,
-    focusedThumbIndex: A,
-    dragging: ce,
-    marks: N,
-    values: o,
-    trackOffset: me,
-    trackLeap: pe,
-    getThumbStyle: be
-  } = Pe({
-    ...q,
-    rootRef: L
-  }), n = {
-    ...q,
-    marked: N.length > 0 && N.some((a) => a.label),
-    dragging: ce,
-    focusedThumbIndex: A,
-    activeThumbIndex: x
-  }, s = Oe(n), _ = u.root ?? "span", fe = c({
-    elementType: _,
-    getSlotProps: se,
-    externalSlotProps: i.root,
-    externalForwardedProps: ne,
-    ownerState: n,
-    className: [s.root, U]
-  }), B = u.rail ?? "span", de = c({
-    elementType: B,
-    externalSlotProps: i.rail,
-    ownerState: n,
-    className: s.rail
-  }), G = u.track ?? "span", ye = c({
-    elementType: G,
-    externalSlotProps: i.track,
+    "aria-label": ariaLabel,
+    "aria-valuetext": ariaValuetext,
+    "aria-labelledby": ariaLabelledby,
+    className,
+    disableSwap = false,
+    disabled = false,
+    getAriaLabel,
+    getAriaValueText,
+    marks: marksProp = false,
+    max = 100,
+    min = 0,
+    name,
+    onChange,
+    onChangeCommitted,
+    orientation = "horizontal",
+    shiftStep = 10,
+    scale = Identity,
+    step = 1,
+    tabIndex,
+    track = "normal",
+    value: valueProp,
+    valueLabelFormat = Identity,
+    isRtl = false,
+    defaultValue,
+    slotProps = {},
+    slots = {},
+    ...other
+  } = props;
+  const partialOwnerState = {
+    ...props,
+    marks: marksProp,
+    disabled,
+    disableSwap,
+    isRtl,
+    defaultValue,
+    max,
+    min,
+    orientation,
+    scale,
+    step,
+    shiftStep,
+    track,
+    valueLabelFormat
+  };
+  const {
+    axisProps,
+    getRootProps,
+    getHiddenInputProps,
+    getThumbProps,
+    active,
+    axis,
+    range,
+    focusedThumbIndex,
+    dragging,
+    marks,
+    values,
+    trackOffset,
+    trackLeap,
+    getThumbStyle
+  } = useSlider({
+    ...partialOwnerState,
+    rootRef: forwardedRef
+  });
+  const ownerState = {
+    ...partialOwnerState,
+    marked: marks.length > 0 && marks.some((mark) => mark.label),
+    dragging,
+    focusedThumbIndex,
+    activeThumbIndex: active
+  };
+  const classes = useUtilityClasses(ownerState);
+  const Root = slots.root ?? "span";
+  const rootProps = useSlotProps({
+    elementType: Root,
+    getSlotProps: getRootProps,
+    externalSlotProps: slotProps.root,
+    externalForwardedProps: other,
+    ownerState,
+    className: [classes.root, className]
+  });
+  const Rail = slots.rail ?? "span";
+  const railProps = useSlotProps({
+    elementType: Rail,
+    externalSlotProps: slotProps.rail,
+    ownerState,
+    className: classes.rail
+  });
+  const Track = slots.track ?? "span";
+  const trackProps = useSlotProps({
+    elementType: Track,
+    externalSlotProps: slotProps.track,
     additionalProps: {
       style: {
-        ...k[T].offset(me),
-        ...k[T].leap(pe)
+        ...axisProps[axis].offset(trackOffset),
+        ...axisProps[axis].leap(trackLeap)
       }
     },
-    ownerState: n,
-    className: s.track
-  }), J = u.thumb ?? "span", V = c({
-    elementType: J,
-    getSlotProps: ue,
-    externalSlotProps: i.thumb,
-    ownerState: n,
-    skipResolvingSlotProps: !0
-  }), h = u.valueLabel, ve = c({
-    elementType: h,
-    externalSlotProps: i.valueLabel,
-    ownerState: n
-  }), C = u.mark ?? "span", w = c({
-    elementType: C,
-    externalSlotProps: i.mark,
-    ownerState: n,
-    className: s.mark
-  }), I = u.markLabel ?? "span", R = c({
-    elementType: I,
-    externalSlotProps: i.markLabel,
-    ownerState: n
-  }), K = u.input || "input", ge = c({
-    elementType: K,
-    getSlotProps: ie,
-    externalSlotProps: i.input,
-    ownerState: n
+    ownerState,
+    className: classes.track
+  });
+  const Thumb = slots.thumb ?? "span";
+  const thumbProps = useSlotProps({
+    elementType: Thumb,
+    getSlotProps: getThumbProps,
+    externalSlotProps: slotProps.thumb,
+    ownerState,
+    skipResolvingSlotProps: true
+  });
+  const ValueLabel = slots.valueLabel;
+  const valueLabelProps = useSlotProps({
+    elementType: ValueLabel,
+    externalSlotProps: slotProps.valueLabel,
+    ownerState
   });
-  return /* @__PURE__ */ M(_, {
-    ...fe,
-    children: [/* @__PURE__ */ p(B, {
-      ...de
-    }), /* @__PURE__ */ p(G, {
-      ...ye
-    }), N.filter((a) => a.value >= y && a.value <= d).map((a, t) => {
-      const j = W(a.value, y, d), P = k[T].offset(j);
-      let r;
-      return g === !1 ? r = o.indexOf(a.value) !== -1 : r = g === "normal" && (D ? a.value >= o[0] && a.value <= o[o.length - 1] : a.value <= o[0]) || g === "inverted" && (D ? a.value <= o[0] || a.value >= o[o.length - 1] : a.value >= o[0]), /* @__PURE__ */ M(Q.Fragment, {
-        children: [/* @__PURE__ */ p(C, {
-          "data-index": t,
-          ...w,
-          ...!E(C) && {
-            markActive: r
+  const Mark = slots.mark ?? "span";
+  const markProps = useSlotProps({
+    elementType: Mark,
+    externalSlotProps: slotProps.mark,
+    ownerState,
+    className: classes.mark
+  });
+  const MarkLabel = slots.markLabel ?? "span";
+  const markLabelProps = useSlotProps({
+    elementType: MarkLabel,
+    externalSlotProps: slotProps.markLabel,
+    ownerState
+  });
+  const Input = slots.input || "input";
+  const inputProps = useSlotProps({
+    elementType: Input,
+    getSlotProps: getHiddenInputProps,
+    externalSlotProps: slotProps.input,
+    ownerState
+  });
+  return /* @__PURE__ */ jsxs(Root, {
+    ...rootProps,
+    children: [/* @__PURE__ */ jsx(Rail, {
+      ...railProps
+    }), /* @__PURE__ */ jsx(Track, {
+      ...trackProps
+    }), marks.filter((mark) => mark.value >= min && mark.value <= max).map((mark, index) => {
+      const percent = valueToPercent(mark.value, min, max);
+      const style = axisProps[axis].offset(percent);
+      let markActive;
+      if (track === false) {
+        markActive = values.indexOf(mark.value) !== -1;
+      } else {
+        markActive = track === "normal" && (range ? mark.value >= values[0] && mark.value <= values[values.length - 1] : mark.value <= values[0]) || track === "inverted" && (range ? mark.value <= values[0] || mark.value >= values[values.length - 1] : mark.value >= values[0]);
+      }
+      return /* @__PURE__ */ jsxs(React.Fragment, {
+        children: [/* @__PURE__ */ jsx(Mark, {
+          "data-index": index,
+          ...markProps,
+          ...!isHostComponent(Mark) && {
+            markActive
           },
           style: {
-            ...P,
-            ...w.style
+            ...style,
+            ...markProps.style
           },
-          className: F(w.className, r && s.markActive)
-        }), a.label != null ? /* @__PURE__ */ p(I, {
-          "aria-hidden": !0,
-          "data-index": t,
-          ...R,
-          ...!E(I) && {
-            markLabelActive: r
+          className: clsx(markProps.className, markActive && classes.markActive)
+        }), mark.label != null ? /* @__PURE__ */ jsx(MarkLabel, {
+          "aria-hidden": true,
+          "data-index": index,
+          ...markLabelProps,
+          ...!isHostComponent(MarkLabel) && {
+            markLabelActive: markActive
           },
           style: {
-            ...P,
-            ...R.style
+            ...style,
+            ...markLabelProps.style
           },
-          className: F(s.markLabel, R.className, r && s.markLabelActive),
-          children: a.label
+          className: clsx(classes.markLabel, markLabelProps.className, markActive && classes.markLabelActive),
+          children: mark.label
         }) : null]
-      }, t);
-    }), o.map((a, t) => {
-      const j = W(a, y, d), P = k[T].offset(j), r = Te(i.thumb, n, {
-        index: t,
-        focused: A === t,
-        active: x === t
+      }, index);
+    }), values.map((value, index) => {
+      const percent = valueToPercent(value, min, max);
+      const style = axisProps[axis].offset(percent);
+      const resolvedSlotProps = resolveComponentProps(slotProps.thumb, ownerState, {
+        index,
+        focused: focusedThumbIndex === index,
+        active: active === index
       });
-      return /* @__PURE__ */ M(J, {
-        "data-index": t,
-        ...V,
-        ...r,
-        className: F(s.thumb, V.className, r == null ? void 0 : r.className, x === t && s.active, A === t && s.focusVisible),
+      return /* @__PURE__ */ jsxs(Thumb, {
+        "data-index": index,
+        ...thumbProps,
+        ...resolvedSlotProps,
+        className: clsx(classes.thumb, thumbProps.className, resolvedSlotProps == null ? void 0 : resolvedSlotProps.className, active === index && classes.active, focusedThumbIndex === index && classes.focusVisible),
         style: {
-          ...P,
-          ...be(t),
-          ...V.style,
-          ...r == null ? void 0 : r.style
+          ...style,
+          ...getThumbStyle(index),
+          ...thumbProps.style,
+          ...resolvedSlotProps == null ? void 0 : resolvedSlotProps.style
         },
-        children: [/* @__PURE__ */ p(K, {
-          "data-index": t,
-          "aria-label": H ? H(t) : O,
-          "aria-valuenow": v(a),
-          "aria-labelledby": f,
-          "aria-valuetext": Y ? Y(v(a), t) : S,
-          value: o[t],
-          ...ge
-        }), h ? /* @__PURE__ */ p(h, {
-          ...!E(h) && {
-            valueLabelFormat: b,
-            index: t,
-            disabled: z
+        children: [/* @__PURE__ */ jsx(Input, {
+          "data-index": index,
+          "aria-label": getAriaLabel ? getAriaLabel(index) : ariaLabel,
+          "aria-valuenow": scale(value),
+          "aria-labelledby": ariaLabelledby,
+          "aria-valuetext": getAriaValueText ? getAriaValueText(scale(value), index) : ariaValuetext,
+          value: values[index],
+          ...inputProps
+        }), ValueLabel ? /* @__PURE__ */ jsx(ValueLabel, {
+          ...!isHostComponent(ValueLabel) && {
+            valueLabelFormat,
+            index,
+            disabled
           },
-          ...ve,
-          children: typeof b == "function" ? b(v(a), t) : b
+          ...valueLabelProps,
+          children: typeof valueLabelFormat === "function" ? valueLabelFormat(scale(value), index) : valueLabelFormat
         }) : null]
-      }, t);
+      }, index);
     })]
   });
-});
-process.env.NODE_ENV !== "production" && (Se.propTypes = {
+}, "Slider"));
+process.env.NODE_ENV !== "production" ? Slider.propTypes = {
   // ┌────────────────────────────── Warning ──────────────────────────────┐
   // │ These PropTypes are generated from the TypeScript type definitions. │
   // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
@@ -233,36 +266,48 @@ process.env.NODE_ENV !== "production" && (Se.propTypes = {
   /**
    * The label of the slider.
    */
-  "aria-label": X(e.string, (l) => Array.isArray(l.value || l.defaultValue) && l["aria-label"] != null ? new Error("MUI: You need to use the `getAriaLabel` prop instead of `aria-label` when using a range slider.") : null),
+  "aria-label": chainPropTypes(PropTypes.string, (props) => {
+    const range = Array.isArray(props.value || props.defaultValue);
+    if (range && props["aria-label"] != null) {
+      return new Error("MUI: You need to use the `getAriaLabel` prop instead of `aria-label` when using a range slider.");
+    }
+    return null;
+  }),
   /**
    * The id of the element containing a label for the slider.
    */
-  "aria-labelledby": e.string,
+  "aria-labelledby": PropTypes.string,
   /**
    * A string value that provides a user-friendly name for the current value of the slider.
    */
-  "aria-valuetext": X(e.string, (l) => Array.isArray(l.value || l.defaultValue) && l["aria-valuetext"] != null ? new Error("MUI: You need to use the `getAriaValueText` prop instead of `aria-valuetext` when using a range slider.") : null),
+  "aria-valuetext": chainPropTypes(PropTypes.string, (props) => {
+    const range = Array.isArray(props.value || props.defaultValue);
+    if (range && props["aria-valuetext"] != null) {
+      return new Error("MUI: You need to use the `getAriaValueText` prop instead of `aria-valuetext` when using a range slider.");
+    }
+    return null;
+  }),
   /**
    * The default value. Use when the component is not controlled.
    */
-  defaultValue: e.oneOfType([e.arrayOf(e.number), e.number]),
+  defaultValue: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.number), PropTypes.number]),
   /**
    * If `true`, the component is disabled.
    * @default false
    */
-  disabled: e.bool,
+  disabled: PropTypes.bool,
   /**
    * If `true`, the active thumb doesn't swap when moving pointer over a thumb while dragging another thumb.
    * @default false
    */
-  disableSwap: e.bool,
+  disableSwap: PropTypes.bool,
   /**
    * Accepts a function which returns a string value that provides a user-friendly name for the thumb labels of the slider.
    * This is important for screen reader users.
    * @param {number} index The thumb label's index to format.
    * @returns {string}
    */
-  getAriaLabel: e.func,
+  getAriaLabel: PropTypes.func,
   /**
    * Accepts a function which returns a string value that provides a user-friendly name for the current value of the slider.
    * This is important for screen reader users.
@@ -270,38 +315,38 @@ process.env.NODE_ENV !== "production" && (Se.propTypes = {
    * @param {number} index The thumb label's index to format.
    * @returns {string}
    */
-  getAriaValueText: e.func,
+  getAriaValueText: PropTypes.func,
   /**
    * If `true` the Slider will be rendered right-to-left (with the lowest value on the right-hand side).
    * @default false
    */
-  isRtl: e.bool,
+  isRtl: PropTypes.bool,
   /**
    * Marks indicate predetermined values to which the user can move the slider.
    * If `true` the marks are spaced according the value of the `step` prop.
    * If an array, it should contain objects with `value` and an optional `label` keys.
    * @default false
    */
-  marks: e.oneOfType([e.arrayOf(e.shape({
-    label: e.node,
-    value: e.number.isRequired
-  })), e.bool]),
+  marks: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.shape({
+    label: PropTypes.node,
+    value: PropTypes.number.isRequired
+  })), PropTypes.bool]),
   /**
    * The maximum allowed value of the slider.
    * Should not be equal to min.
    * @default 100
    */
-  max: e.number,
+  max: PropTypes.number,
   /**
    * The minimum allowed value of the slider.
    * Should not be equal to max.
    * @default 0
    */
-  min: e.number,
+  min: PropTypes.number,
   /**
    * Name attribute of the hidden `input` element.
    */
-  name: e.string,
+  name: PropTypes.string,
   /**
    * Callback function that is fired when the slider's value changed.
    *
@@ -311,19 +356,19 @@ process.env.NODE_ENV !== "production" && (Se.propTypes = {
    * @param {number | number[]} value The new value.
    * @param {number} activeThumb Index of the currently moved thumb.
    */
-  onChange: e.func,
+  onChange: PropTypes.func,
   /**
    * Callback function that is fired when the `mouseup` is triggered.
    *
    * @param {React.SyntheticEvent | Event} event The event source of the callback. **Warning**: This is a generic event not a change event.
    * @param {number | number[]} value The new value.
    */
-  onChangeCommitted: e.func,
+  onChangeCommitted: PropTypes.func,
   /**
    * The component orientation.
    * @default 'horizontal'
    */
-  orientation: e.oneOf(["horizontal", "vertical"]),
+  orientation: PropTypes.oneOf(["horizontal", "vertical"]),
   /**
    * A transformation function, to change the scale of the slider.
    * @param {any} x
@@ -332,40 +377,40 @@ process.env.NODE_ENV !== "production" && (Se.propTypes = {
    *   return x;
    * }
    */
-  scale: e.func,
+  scale: PropTypes.func,
   /**
    * The granularity with which the slider can step through values when using Page Up/Page Down or Shift + Arrow Up/Arrow Down.
    * @default 10
    */
-  shiftStep: e.number,
+  shiftStep: PropTypes.number,
   /**
    * The props used for each slot inside the Slider.
    * @default {}
    */
-  slotProps: e.shape({
-    input: e.oneOfType([e.func, e.object]),
-    mark: e.oneOfType([e.func, e.object]),
-    markLabel: e.oneOfType([e.func, e.object]),
-    rail: e.oneOfType([e.func, e.object]),
-    root: e.oneOfType([e.func, e.object]),
-    thumb: e.oneOfType([e.func, e.object]),
-    track: e.oneOfType([e.func, e.object]),
-    valueLabel: e.oneOfType([e.any, e.func])
+  slotProps: PropTypes.shape({
+    input: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    mark: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    markLabel: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    rail: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    thumb: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    track: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+    valueLabel: PropTypes.oneOfType([PropTypes.any, PropTypes.func])
   }),
   /**
    * The components used for each slot inside the Slider.
    * Either a string to use a HTML element or a component.
    * @default {}
    */
-  slots: e.shape({
-    input: e.elementType,
-    mark: e.elementType,
-    markLabel: e.elementType,
-    rail: e.elementType,
-    root: e.elementType,
-    thumb: e.elementType,
-    track: e.elementType,
-    valueLabel: e.elementType
+  slots: PropTypes.shape({
+    input: PropTypes.elementType,
+    mark: PropTypes.elementType,
+    markLabel: PropTypes.elementType,
+    rail: PropTypes.elementType,
+    root: PropTypes.elementType,
+    thumb: PropTypes.elementType,
+    track: PropTypes.elementType,
+    valueLabel: PropTypes.elementType
   }),
   /**
    * The granularity with which the slider can step through values. (A "discrete" slider.)
@@ -375,11 +420,11 @@ process.env.NODE_ENV !== "production" && (Se.propTypes = {
    * When step is `null`, the thumb can only be slid onto marks provided with the `marks` prop.
    * @default 1
    */
-  step: e.number,
+  step: PropTypes.number,
   /**
    * Tab index attribute of the hidden `input` element.
    */
-  tabIndex: e.number,
+  tabIndex: PropTypes.number,
   /**
    * The track presentation:
    *
@@ -388,12 +433,12 @@ process.env.NODE_ENV !== "production" && (Se.propTypes = {
    * - `false` the track will render without a bar.
    * @default 'normal'
    */
-  track: e.oneOf(["inverted", "normal", !1]),
+  track: PropTypes.oneOf(["inverted", "normal", false]),
   /**
    * The value of the slider.
    * For ranged sliders, provide an array with two values.
    */
-  value: e.oneOfType([e.arrayOf(e.number), e.number]),
+  value: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.number), PropTypes.number]),
   /**
    * The format function the value label's value.
    *
@@ -407,8 +452,8 @@ process.env.NODE_ENV !== "production" && (Se.propTypes = {
    *   return x;
    * }
    */
-  valueLabelFormat: e.oneOfType([e.func, e.string])
-});
+  valueLabelFormat: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
+} : void 0;
 export {
-  Se as Slider
+  Slider
 };