@stevederico/skateboard-ui 3.9.0 → 3.11.0

package/dist/shadcn/lib/base-ui/slider.js

@@ -0,0 +1,1583 @@
+/* @base-ui/react 1.5.0 — vendored (MIT — MUI Inc).
+ * Refresh: scripts/vendor-base-ui.js (see header for instructions).
+ * Do not edit by hand. */
+import {
+  getDefaultLabelId,
+  resolveAriaLabelledBy
+} from "./_chunk-b5ya6xds.js";
+import {
+  clamp
+} from "./_chunk-yzr7eg4b.js";
+import {
+  useIsHydrating
+} from "./_chunk-p0e2qacz.js";
+import {
+  useCSPContext
+} from "./_chunk-watha94s.js";
+import {
+  focusElementWithVisible,
+  useLabel
+} from "./_chunk-ghn1tzt8.js";
+import {
+  useLabelableId
+} from "./_chunk-23rx7haq.js";
+import {
+  formatNumber,
+  valueToPercent
+} from "./_chunk-ffpjy0ta.js";
+import"./_chunk-vgkfmtbe.js";
+import {
+  useFormContext,
+  useRegisterFieldControl
+} from "./_chunk-95tf2rxq.js";
+import {
+  fieldValidityMapping,
+  useFieldRootContext,
+  useLabelableContext
+} from "./_chunk-8ctgmf06.js";
+import"./_chunk-dzvjwv25.js";
+import {
+  useCompositeListItem
+} from "./_chunk-3enq1vat.js";
+import {
+  CompositeList
+} from "./_chunk-j29xjete.js";
+import"./_chunk-3xpke33f.js";
+import {
+  useDirection
+} from "./_chunk-gy0bpkmx.js";
+import {
+  useControlled
+} from "./_chunk-9x63vfqj.js";
+import"./_chunk-1vw45v38.js";
+import {
+  activeElement,
+  contains,
+  getTarget,
+  matchesFocusVisible
+} from "./_chunk-cgptgywc.js";
+import {
+  ARROW_DOWN,
+  ARROW_LEFT,
+  ARROW_RIGHT,
+  ARROW_UP,
+  COMPOSITE_KEYS,
+  END,
+  HOME,
+  PAGE_DOWN,
+  PAGE_UP
+} from "./_chunk-pv7b791x.js";
+import"./_chunk-kw8nnq00.js";
+import"./_chunk-rrh8rt4v.js";
+import {
+  useValueChanged
+} from "./_chunk-s5pwkz8v.js";
+import {
+  visuallyHidden
+} from "./_chunk-dan0mva4.js";
+import {
+  addEventListener
+} from "./_chunk-ase0ydtt.js";
+import {
+  useValueAsRef
+} from "./_chunk-6kqramh9.js";
+import {
+  ownerDocument
+} from "./_chunk-451nqgsa.js";
+import {
+  createChangeEventDetails,
+  createGenericEventDetails,
+  exports_reason_parts
+} from "./_chunk-e56mpvk1.js";
+import {
+  useBaseUiId
+} from "./_chunk-wdqynnjf.js";
+import {
+  useAnimationFrame
+} from "./_chunk-8a9vv8am.js";
+import"./_chunk-6ejf1z1r.js";
+import"./_chunk-hm5h9vsk.js";
+import {
+  getWindow,
+  isElement,
+  isHTMLElement
+} from "./_chunk-000kmre8.js";
+import {
+  useStableCallback
+} from "./_chunk-cwvtvwc7.js";
+import {
+  useIsoLayoutEffect
+} from "./_chunk-5tze5c8q.js";
+import {
+  useMergedRefs,
+  useRenderElement,
+  warn
+} from "./_chunk-x8xehj6d.js";
+import {
+  __export,
+  mergeProps
+} from "./_chunk-svxv97ph.js";
+
+// node_modules/@base-ui/react/esm/slider/index.parts.js
+var exports_index_parts = {};
+__export(exports_index_parts, {
+  Value: () => SliderValue,
+  Track: () => SliderTrack,
+  Thumb: () => SliderThumb,
+  Root: () => SliderRoot,
+  Label: () => SliderLabel,
+  Indicator: () => SliderIndicator,
+  Control: () => SliderControl
+});
+
+// node_modules/@base-ui/react/esm/slider/root/SliderRoot.js
+import * as React2 from "react";
+
+// node_modules/@base-ui/react/esm/internals/areArraysEqual.js
+function areArraysEqual(array1, array2, itemComparer = (a, b) => a === b) {
+  return array1.length === array2.length && array1.every((value, index) => itemComparer(value, array2[index]));
+}
+
+// node_modules/@base-ui/react/esm/slider/utils/asc.js
+function asc(a, b) {
+  return a - b;
+}
+
+// node_modules/@base-ui/react/esm/slider/utils/replaceArrayItemAtIndex.js
+function replaceArrayItemAtIndex(array, index, newValue) {
+  const output = array.slice();
+  output[index] = newValue;
+  return output.sort(asc);
+}
+
+// node_modules/@base-ui/react/esm/slider/utils/getSliderValue.js
+function getSliderValue(valueInput, index, min, max, range, values) {
+  let newValue = valueInput;
+  newValue = clamp(newValue, min, max);
+  if (range) {
+    newValue = replaceArrayItemAtIndex(values, index, clamp(newValue, values[index - 1] || -Infinity, values[index + 1] || Infinity));
+  }
+  return newValue;
+}
+
+// node_modules/@base-ui/react/esm/slider/utils/validateMinimumDistance.js
+function validateMinimumDistance(values, step, minStepsBetweenValues) {
+  if (!Array.isArray(values)) {
+    return true;
+  }
+  const distances = values.reduce((acc, val, index, vals) => {
+    if (index === vals.length - 1) {
+      return acc;
+    }
+    acc.push(Math.abs(val - vals[index + 1]));
+    return acc;
+  }, []);
+  return Math.min(...distances) >= step * minStepsBetweenValues;
+}
+
+// node_modules/@base-ui/react/esm/slider/root/stateAttributesMapping.js
+var sliderStateAttributesMapping = {
+  activeThumbIndex: () => null,
+  max: () => null,
+  min: () => null,
+  minStepsBetweenValues: () => null,
+  step: () => null,
+  values: () => null,
+  ...fieldValidityMapping
+};
+
+// node_modules/@base-ui/react/esm/slider/root/SliderRootContext.js
+import * as React from "react";
+"use client";
+var SliderRootContext = /* @__PURE__ */ React.createContext(undefined);
+if (true)
+  SliderRootContext.displayName = "SliderRootContext";
+function useSliderRootContext() {
+  const context = React.useContext(SliderRootContext);
+  if (context === undefined) {
+    throw new Error("Base UI: SliderRootContext is missing. Slider parts must be placed within <Slider.Root>.");
+  }
+  return context;
+}
+
+// node_modules/@base-ui/react/esm/slider/root/SliderRoot.js
+import { jsx as _jsx } from "react/jsx-runtime";
+"use client";
+function getSliderChangeEventReason(event) {
+  return "key" in event ? exports_reason_parts.keyboard : exports_reason_parts.inputChange;
+}
+function areValuesEqual(newValue, oldValue) {
+  if (typeof newValue === "number" && typeof oldValue === "number") {
+    return newValue === oldValue;
+  }
+  if (Array.isArray(newValue) && Array.isArray(oldValue)) {
+    return areArraysEqual(newValue, oldValue);
+  }
+  return false;
+}
+var SliderRoot = /* @__PURE__ */ React2.forwardRef(function SliderRoot2(componentProps, forwardedRef) {
+  const {
+    "aria-labelledby": ariaLabelledByProp,
+    className,
+    defaultValue,
+    disabled: disabledProp = false,
+    id: idProp,
+    format,
+    largeStep = 10,
+    locale,
+    render,
+    max = 100,
+    min = 0,
+    minStepsBetweenValues = 0,
+    form,
+    name: nameProp,
+    onValueChange: onValueChangeProp,
+    onValueCommitted: onValueCommittedProp,
+    orientation = "horizontal",
+    step = 1,
+    thumbCollisionBehavior = "push",
+    thumbAlignment = "center",
+    value: valueProp,
+    style,
+    ...elementProps
+  } = componentProps;
+  const id = useBaseUiId(idProp);
+  const defaultLabelId = getDefaultLabelId(id);
+  const onValueChange = useStableCallback(onValueChangeProp);
+  const onValueCommitted = useStableCallback(onValueCommittedProp);
+  const {
+    clearErrors
+  } = useFormContext();
+  const {
+    state: fieldState,
+    disabled: fieldDisabled,
+    name: fieldName,
+    setTouched,
+    setDirty,
+    validityData,
+    shouldValidateOnChange,
+    validation
+  } = useFieldRootContext();
+  const {
+    labelId: fieldLabelId
+  } = useLabelableContext();
+  const [labelId, setLabelId] = React2.useState();
+  const ariaLabelledby = ariaLabelledByProp ?? resolveAriaLabelledBy(fieldLabelId, labelId);
+  const disabled = fieldDisabled || disabledProp;
+  const name = fieldName ?? nameProp;
+  const [valueUnwrapped, setValueUnwrapped] = useControlled({
+    controlled: valueProp,
+    default: defaultValue ?? min,
+    name: "Slider"
+  });
+  const sliderRef = React2.useRef(null);
+  const controlRef = React2.useRef(null);
+  const thumbRefs = React2.useRef([]);
+  const pressedInputRef = React2.useRef(null);
+  const pressedThumbCenterOffsetRef = React2.useRef(null);
+  const pressedThumbIndexRef = React2.useRef(-1);
+  const pressedValuesRef = React2.useRef(null);
+  const lastChangedValueRef = React2.useRef(null);
+  const lastChangeReasonRef = React2.useRef("none");
+  const formatOptionsRef = useValueAsRef(format);
+  const [active, setActiveState] = React2.useState(-1);
+  const [lastUsedThumbIndex, setLastUsedThumbIndex] = React2.useState(-1);
+  const [dragging, setDragging] = React2.useState(false);
+  const [thumbMap, setThumbMap] = React2.useState(() => new Map);
+  const [indicatorPosition, setIndicatorPosition] = React2.useState([undefined, undefined]);
+  const setActive = useStableCallback((value) => {
+    setActiveState(value);
+    if (value !== -1) {
+      setLastUsedThumbIndex(value);
+    }
+  });
+  useRegisterFieldControl(controlRef, id, valueUnwrapped);
+  useValueChanged(valueUnwrapped, () => {
+    clearErrors(name);
+    if (shouldValidateOnChange()) {
+      validation.commit(valueUnwrapped);
+    } else {
+      validation.commit(valueUnwrapped, true);
+    }
+    const initialValue = validityData.initialValue;
+    let isDirty;
+    if (Array.isArray(valueUnwrapped) && Array.isArray(initialValue)) {
+      isDirty = !areArraysEqual(valueUnwrapped, initialValue);
+    } else {
+      isDirty = valueUnwrapped !== initialValue;
+    }
+    setDirty(isDirty);
+  });
+  const registerFieldControlRef = useStableCallback((element2) => {
+    if (element2) {
+      controlRef.current = element2;
+    }
+  });
+  const range = Array.isArray(valueUnwrapped);
+  const values = React2.useMemo(() => {
+    if (!range) {
+      return [clamp(valueUnwrapped, min, max)];
+    }
+    return valueUnwrapped.slice().sort(asc);
+  }, [max, min, range, valueUnwrapped]);
+  const setValue = useStableCallback((newValue, details) => {
+    if (Number.isNaN(newValue) || areValuesEqual(newValue, valueUnwrapped)) {
+      return;
+    }
+    const changeDetails = details ?? createChangeEventDetails(exports_reason_parts.none, undefined, undefined, {
+      activeThumbIndex: -1
+    });
+    lastChangeReasonRef.current = changeDetails.reason;
+    const nativeEvent = changeDetails.event;
+    const EventConstructor = nativeEvent.constructor ?? Event;
+    const clonedEvent = new EventConstructor(nativeEvent.type, nativeEvent);
+    Object.defineProperty(clonedEvent, "target", {
+      writable: true,
+      value: {
+        value: newValue,
+        name
+      }
+    });
+    changeDetails.event = clonedEvent;
+    lastChangedValueRef.current = newValue;
+    onValueChange(newValue, changeDetails);
+    if (changeDetails.isCanceled) {
+      return;
+    }
+    setValueUnwrapped(newValue);
+  });
+  const handleInputChange = useStableCallback((valueInput, index, event) => {
+    const newValue = getSliderValue(valueInput, index, min, max, range, values);
+    if (validateMinimumDistance(newValue, step, minStepsBetweenValues)) {
+      const reason = getSliderChangeEventReason(event);
+      setValue(newValue, createChangeEventDetails(reason, event.nativeEvent, undefined, {
+        activeThumbIndex: index
+      }));
+      setTouched(true);
+      const nextValue = lastChangedValueRef.current ?? newValue;
+      onValueCommitted(nextValue, createGenericEventDetails(reason, event.nativeEvent));
+    }
+  });
+  if (true) {
+    if (min >= max) {
+      warn("Slider `max` must be greater than `min`.");
+    }
+  }
+  useIsoLayoutEffect(() => {
+    const activeEl = activeElement(ownerDocument(sliderRef.current));
+    if (disabled && contains(sliderRef.current, activeEl)) {
+      activeEl.blur();
+    }
+  }, [disabled]);
+  if (disabled && active !== -1) {
+    setActive(-1);
+  }
+  const state = React2.useMemo(() => ({
+    ...fieldState,
+    activeThumbIndex: active,
+    disabled,
+    dragging,
+    orientation,
+    max,
+    min,
+    minStepsBetweenValues,
+    step,
+    values
+  }), [fieldState, active, disabled, dragging, max, min, minStepsBetweenValues, orientation, step, values]);
+  const contextValue = React2.useMemo(() => ({
+    active,
+    controlRef,
+    disabled,
+    dragging,
+    validation,
+    formatOptionsRef,
+    handleInputChange,
+    indicatorPosition,
+    inset: thumbAlignment !== "center",
+    labelId: ariaLabelledby,
+    rootLabelId: defaultLabelId,
+    largeStep,
+    lastUsedThumbIndex,
+    lastChangedValueRef,
+    lastChangeReasonRef,
+    form,
+    locale,
+    max,
+    min,
+    minStepsBetweenValues,
+    name,
+    onValueCommitted,
+    orientation,
+    pressedInputRef,
+    pressedThumbCenterOffsetRef,
+    pressedThumbIndexRef,
+    pressedValuesRef,
+    registerFieldControlRef,
+    renderBeforeHydration: thumbAlignment === "edge",
+    setActive,
+    setDragging,
+    setIndicatorPosition,
+    setLabelId,
+    setValue,
+    state,
+    step,
+    thumbCollisionBehavior,
+    thumbMap,
+    thumbRefs,
+    values
+  }), [active, controlRef, ariaLabelledby, defaultLabelId, disabled, dragging, validation, formatOptionsRef, handleInputChange, indicatorPosition, largeStep, lastUsedThumbIndex, lastChangedValueRef, lastChangeReasonRef, form, locale, max, min, minStepsBetweenValues, name, onValueCommitted, orientation, pressedInputRef, pressedThumbCenterOffsetRef, pressedThumbIndexRef, pressedValuesRef, registerFieldControlRef, setActive, setDragging, setIndicatorPosition, setLabelId, setValue, state, step, thumbCollisionBehavior, thumbAlignment, thumbMap, thumbRefs, values]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, sliderRef],
+    props: [{
+      "aria-labelledby": ariaLabelledby,
+      id,
+      role: "group"
+    }, validation.getValidationProps, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+  return /* @__PURE__ */ _jsx(SliderRootContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ _jsx(CompositeList, {
+      elementsRef: thumbRefs,
+      onMapChange: setThumbMap,
+      children: element
+    })
+  });
+});
+if (true)
+  SliderRoot.displayName = "SliderRoot";
+// node_modules/@base-ui/react/esm/slider/label/SliderLabel.js
+import * as React3 from "react";
+"use client";
+var SliderLabel = /* @__PURE__ */ React3.forwardRef(function SliderLabel2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const elementPropsWithoutId = elementProps;
+  delete elementPropsWithoutId.id;
+  const {
+    state,
+    setLabelId,
+    controlRef,
+    rootLabelId
+  } = useSliderRootContext();
+  function focusControl(event, controlId) {
+    if (controlId) {
+      const controlElement = ownerDocument(event.currentTarget).getElementById(controlId);
+      if (isHTMLElement(controlElement)) {
+        focusElementWithVisible(controlElement);
+        return;
+      }
+    }
+    const fallbackInputs = controlRef.current?.querySelectorAll('input[type="range"]');
+    const fallbackInput = fallbackInputs?.length === 1 ? fallbackInputs[0] : null;
+    if (isHTMLElement(fallbackInput)) {
+      focusElementWithVisible(fallbackInput);
+    }
+  }
+  const labelProps = useLabel({
+    id: rootLabelId,
+    setLabelId,
+    focusControl
+  });
+  return useRenderElement("div", componentProps, {
+    ref: forwardedRef,
+    state,
+    props: [labelProps, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+});
+if (true)
+  SliderLabel.displayName = "SliderLabel";
+// node_modules/@base-ui/react/esm/slider/value/SliderValue.js
+import * as React4 from "react";
+"use client";
+var SliderValue = /* @__PURE__ */ React4.forwardRef(function SliderValue2(componentProps, forwardedRef) {
+  const {
+    "aria-live": ariaLive = "off",
+    render,
+    className,
+    children,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    thumbMap,
+    state,
+    values,
+    formatOptionsRef,
+    locale
+  } = useSliderRootContext();
+  let htmlFor = "";
+  for (const thumbMetadata of thumbMap.values()) {
+    if (thumbMetadata?.inputId) {
+      htmlFor += `${thumbMetadata.inputId} `;
+    }
+  }
+  const outputFor = htmlFor.trim() === "" ? undefined : htmlFor.trim();
+  const formattedValues = React4.useMemo(() => {
+    const arr = [];
+    for (let i = 0;i < values.length; i += 1) {
+      arr.push(formatNumber(values[i], locale, formatOptionsRef.current ?? undefined));
+    }
+    return arr;
+  }, [formatOptionsRef, locale, values]);
+  const defaultDisplayValue = values.map((v, i) => formattedValues[i] || v).join(" – ");
+  const element = useRenderElement("output", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      "aria-live": ariaLive,
+      children: typeof children === "function" ? children(formattedValues, values) : defaultDisplayValue,
+      htmlFor: outputFor
+    }, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+  return element;
+});
+if (true)
+  SliderValue.displayName = "SliderValue";
+// node_modules/@base-ui/react/esm/slider/control/SliderControl.js
+import * as React5 from "react";
+
+// node_modules/@base-ui/react/esm/slider/utils/getMidpoint.js
+function getMidpoint(element) {
+  const rect = element.getBoundingClientRect();
+  return {
+    x: (rect.left + rect.right) / 2,
+    y: (rect.top + rect.bottom) / 2
+  };
+}
+
+// node_modules/@base-ui/react/esm/slider/utils/roundValueToStep.js
+function getDecimalPrecision(num) {
+  if (num === 0) {
+    return 0;
+  }
+  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 decimalPart = num.toString().split(".")[1];
+  return decimalPart ? decimalPart.length : 0;
+}
+function roundValueToStep(value, step, min) {
+  const nearest = Math.round((value - min) / step) * step + min;
+  return Number(nearest.toFixed(Math.max(getDecimalPrecision(step), getDecimalPrecision(min))));
+}
+
+// node_modules/@base-ui/react/esm/slider/utils/getPushedThumbValues.js
+function getPushedThumbValues({
+  values,
+  index,
+  nextValue,
+  min,
+  max,
+  step,
+  minStepsBetweenValues,
+  initialValues
+}) {
+  if (values.length === 0) {
+    return [];
+  }
+  const nextValues = values.slice();
+  const minValueDifference = step * minStepsBetweenValues;
+  const lastIndex = nextValues.length - 1;
+  const baseInitialValues = initialValues ?? values;
+  const indexMin = min + index * minValueDifference;
+  const indexMax = max - (lastIndex - index) * minValueDifference;
+  nextValues[index] = clamp(nextValue, indexMin, indexMax);
+  for (let i = index + 1;i <= lastIndex; i += 1) {
+    const minAllowed = nextValues[i - 1] + minValueDifference;
+    const maxAllowed = max - (lastIndex - i) * minValueDifference;
+    const initialValue = baseInitialValues[i] ?? nextValues[i];
+    let candidate = Math.max(nextValues[i], minAllowed);
+    if (initialValue < candidate) {
+      candidate = Math.max(initialValue, minAllowed);
+    }
+    nextValues[i] = clamp(candidate, minAllowed, maxAllowed);
+  }
+  for (let i = index - 1;i >= 0; i -= 1) {
+    const maxAllowed = nextValues[i + 1] - minValueDifference;
+    const minAllowed = min + i * minValueDifference;
+    const initialValue = baseInitialValues[i] ?? nextValues[i];
+    let candidate = Math.min(nextValues[i], maxAllowed);
+    if (initialValue > candidate) {
+      candidate = Math.min(initialValue, maxAllowed);
+    }
+    nextValues[i] = clamp(candidate, minAllowed, maxAllowed);
+  }
+  for (let i = 0;i <= lastIndex; i += 1) {
+    nextValues[i] = Number(nextValues[i].toFixed(12));
+  }
+  return nextValues;
+}
+
+// node_modules/@base-ui/react/esm/slider/utils/resolveThumbCollision.js
+function resolveThumbCollision({
+  behavior,
+  values,
+  currentValues,
+  initialValues,
+  pressedIndex,
+  nextValue,
+  min,
+  max,
+  step,
+  minStepsBetweenValues
+}) {
+  const activeValues = currentValues ?? values;
+  const baselineValues = initialValues ?? values;
+  const range = activeValues.length > 1;
+  if (!range) {
+    return {
+      value: nextValue,
+      thumbIndex: 0,
+      didSwap: false
+    };
+  }
+  const minValueDifference = step * minStepsBetweenValues;
+  switch (behavior) {
+    case "swap": {
+      const pressedInitialValue = activeValues[pressedIndex];
+      const epsilon = 0.0000001;
+      const candidateValues = activeValues.slice();
+      const previousNeighbor = candidateValues[pressedIndex - 1];
+      const nextNeighbor = candidateValues[pressedIndex + 1];
+      const lowerBound = previousNeighbor != null ? previousNeighbor + minValueDifference : min;
+      const upperBound = nextNeighbor != null ? nextNeighbor - minValueDifference : max;
+      const constrainedValue = clamp(nextValue, lowerBound, upperBound);
+      const pressedValueAfterClamp = Number(constrainedValue.toFixed(12));
+      candidateValues[pressedIndex] = pressedValueAfterClamp;
+      const movingForward = nextValue > pressedInitialValue;
+      const movingBackward = nextValue < pressedInitialValue;
+      const shouldSwapForward = movingForward && nextNeighbor != null && nextValue >= nextNeighbor - epsilon;
+      const shouldSwapBackward = movingBackward && previousNeighbor != null && nextValue <= previousNeighbor + epsilon;
+      if (!shouldSwapForward && !shouldSwapBackward) {
+        return {
+          value: candidateValues,
+          thumbIndex: pressedIndex,
+          didSwap: false
+        };
+      }
+      const targetIndex = shouldSwapForward ? pressedIndex + 1 : pressedIndex - 1;
+      const initialValuesForPush = candidateValues.map((_, index) => {
+        if (index === pressedIndex) {
+          return pressedValueAfterClamp;
+        }
+        const baseline = baselineValues[index];
+        if (baseline != null) {
+          return baseline;
+        }
+        return activeValues[index];
+      });
+      let nextValueForTarget = nextValue;
+      if (shouldSwapForward) {
+        nextValueForTarget = Math.max(nextValue, candidateValues[targetIndex]);
+      } else {
+        nextValueForTarget = Math.min(nextValue, candidateValues[targetIndex]);
+      }
+      const adjustedValues = getPushedThumbValues({
+        values: candidateValues,
+        index: targetIndex,
+        nextValue: nextValueForTarget,
+        min,
+        max,
+        step,
+        minStepsBetweenValues,
+        initialValues: initialValuesForPush
+      });
+      const neighborIndex = shouldSwapForward ? targetIndex - 1 : targetIndex + 1;
+      if (neighborIndex >= 0 && neighborIndex < adjustedValues.length) {
+        const previousValue = adjustedValues[neighborIndex - 1];
+        const nextValueAfter = adjustedValues[neighborIndex + 1];
+        let neighborLowerBound = previousValue != null ? previousValue + minValueDifference : min;
+        neighborLowerBound = Math.max(neighborLowerBound, min + neighborIndex * minValueDifference);
+        let neighborUpperBound = nextValueAfter != null ? nextValueAfter - minValueDifference : max;
+        neighborUpperBound = Math.min(neighborUpperBound, max - (adjustedValues.length - 1 - neighborIndex) * minValueDifference);
+        const restoredValue = clamp(pressedValueAfterClamp, neighborLowerBound, neighborUpperBound);
+        adjustedValues[neighborIndex] = Number(restoredValue.toFixed(12));
+      }
+      return {
+        value: adjustedValues,
+        thumbIndex: targetIndex,
+        didSwap: true
+      };
+    }
+    case "push": {
+      const nextValues = getPushedThumbValues({
+        values: activeValues,
+        index: pressedIndex,
+        nextValue,
+        min,
+        max,
+        step,
+        minStepsBetweenValues
+      });
+      return {
+        value: nextValues,
+        thumbIndex: pressedIndex,
+        didSwap: false
+      };
+    }
+    case "none":
+    default: {
+      const candidateValues = activeValues.slice();
+      const previousNeighbor = candidateValues[pressedIndex - 1];
+      const nextNeighbor = candidateValues[pressedIndex + 1];
+      const lowerBound = previousNeighbor != null ? previousNeighbor + minValueDifference : min;
+      const upperBound = nextNeighbor != null ? nextNeighbor - minValueDifference : max;
+      const constrainedValue = clamp(nextValue, lowerBound, upperBound);
+      candidateValues[pressedIndex] = Number(constrainedValue.toFixed(12));
+      return {
+        value: candidateValues,
+        thumbIndex: pressedIndex,
+        didSwap: false
+      };
+    }
+  }
+}
+
+// node_modules/@base-ui/react/esm/slider/control/SliderControl.js
+"use client";
+var INTENTIONAL_DRAG_COUNT_THRESHOLD = 2;
+function getControlOffset(styles, vertical) {
+  if (!styles) {
+    return {
+      start: 0,
+      end: 0
+    };
+  }
+  function parseSize(value) {
+    const parsed = value != null ? parseFloat(value) : 0;
+    return Number.isNaN(parsed) ? 0 : parsed;
+  }
+  const start = !vertical ? "InlineStart" : "Top";
+  const end = !vertical ? "InlineEnd" : "Bottom";
+  return {
+    start: parseSize(styles[`border${start}Width`]) + parseSize(styles[`padding${start}`]),
+    end: parseSize(styles[`border${end}Width`]) + parseSize(styles[`padding${end}`])
+  };
+}
+function getFingerCoords(event, touchIdRef) {
+  if (touchIdRef.current != null && event.changedTouches) {
+    const touchEvent = event;
+    for (let i = 0;i < touchEvent.changedTouches.length; i += 1) {
+      const touch = touchEvent.changedTouches[i];
+      if (touch.identifier === touchIdRef.current) {
+        return {
+          x: touch.clientX,
+          y: touch.clientY
+        };
+      }
+    }
+    return null;
+  }
+  return {
+    x: event.clientX,
+    y: event.clientY
+  };
+}
+var SliderControl = /* @__PURE__ */ React5.forwardRef(function SliderControl2(componentProps, forwardedRef) {
+  const {
+    render: renderProp,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    disabled,
+    dragging,
+    inset,
+    lastChangedValueRef,
+    lastChangeReasonRef,
+    max,
+    min,
+    minStepsBetweenValues,
+    onValueCommitted,
+    orientation,
+    pressedInputRef,
+    pressedThumbCenterOffsetRef,
+    pressedThumbIndexRef,
+    pressedValuesRef,
+    registerFieldControlRef,
+    renderBeforeHydration,
+    setActive,
+    setDragging,
+    setValue,
+    state,
+    step,
+    thumbCollisionBehavior,
+    thumbRefs,
+    values
+  } = useSliderRootContext();
+  const direction = useDirection();
+  const range = values.length > 1;
+  const vertical = orientation === "vertical";
+  const controlRef = React5.useRef(null);
+  const stylesRef = React5.useRef(null);
+  const setStylesRef = useStableCallback((element2) => {
+    if (element2 && stylesRef.current == null) {
+      stylesRef.current = getWindow(element2).getComputedStyle(element2);
+    }
+  });
+  const touchIdRef = React5.useRef(null);
+  const moveCountRef = React5.useRef(0);
+  const insetThumbOffsetRef = React5.useRef(0);
+  const latestValuesRef = useValueAsRef(values);
+  function updatePressedThumb(nextIndex) {
+    if (pressedThumbIndexRef.current !== nextIndex) {
+      pressedThumbIndexRef.current = nextIndex;
+    }
+    const thumbElement = thumbRefs.current[nextIndex];
+    if (!thumbElement) {
+      pressedThumbCenterOffsetRef.current = null;
+      pressedInputRef.current = null;
+      return;
+    }
+    pressedInputRef.current = thumbElement.querySelector('input[type="range"]');
+  }
+  function getFingerState(fingerCoords) {
+    const control = controlRef.current;
+    if (!control) {
+      return null;
+    }
+    const {
+      width,
+      height,
+      bottom,
+      left,
+      right
+    } = control.getBoundingClientRect();
+    const controlOffset = getControlOffset(stylesRef.current, vertical);
+    const insetThumbOffset = insetThumbOffsetRef.current;
+    const controlSize = (vertical ? height : width) - controlOffset.start - controlOffset.end - insetThumbOffset * 2;
+    const thumbCenterOffset = pressedThumbCenterOffsetRef.current ?? 0;
+    const fingerX = fingerCoords.x - thumbCenterOffset;
+    const fingerY = fingerCoords.y - thumbCenterOffset;
+    const valueSize = vertical ? bottom - fingerY - controlOffset.end : (direction === "rtl" ? right - fingerX : fingerX - left) - controlOffset.start;
+    const valueRescaled = clamp((valueSize - insetThumbOffset) / controlSize, 0, 1);
+    let newValue = (max - min) * valueRescaled + min;
+    newValue = roundValueToStep(newValue, step, min);
+    newValue = clamp(newValue, min, max);
+    if (!range) {
+      return {
+        value: newValue,
+        thumbIndex: 0,
+        didSwap: false
+      };
+    }
+    const thumbIndex = pressedThumbIndexRef.current;
+    if (thumbIndex < 0) {
+      return null;
+    }
+    const collisionResult = resolveThumbCollision({
+      behavior: thumbCollisionBehavior,
+      values,
+      currentValues: latestValuesRef.current ?? values,
+      initialValues: pressedValuesRef.current,
+      pressedIndex: thumbIndex,
+      nextValue: newValue,
+      min,
+      max,
+      step,
+      minStepsBetweenValues
+    });
+    if (thumbCollisionBehavior === "swap" && collisionResult.didSwap) {
+      updatePressedThumb(collisionResult.thumbIndex);
+    } else {
+      pressedThumbIndexRef.current = collisionResult.thumbIndex;
+    }
+    return collisionResult;
+  }
+  function startPressing(fingerCoords) {
+    pressedValuesRef.current = range ? values.slice() : null;
+    latestValuesRef.current = values;
+    const pressedThumbIndex = pressedThumbIndexRef.current;
+    let closestThumbIndex = pressedThumbIndex;
+    if (pressedThumbIndex > -1 && pressedThumbIndex < values.length) {
+      if (values[pressedThumbIndex] === max) {
+        let candidateIndex = pressedThumbIndex;
+        while (candidateIndex > 0 && values[candidateIndex - 1] === max) {
+          candidateIndex -= 1;
+        }
+        closestThumbIndex = candidateIndex;
+      }
+    } else {
+      const axis = !vertical ? "x" : "y";
+      let minDistance;
+      closestThumbIndex = -1;
+      for (let i = 0;i < thumbRefs.current.length; i += 1) {
+        const thumbEl = thumbRefs.current[i];
+        if (isElement(thumbEl)) {
+          const midpoint = getMidpoint(thumbEl);
+          const distance = Math.abs(fingerCoords[axis] - midpoint[axis]);
+          if (minDistance === undefined || distance <= minDistance) {
+            closestThumbIndex = i;
+            minDistance = distance;
+          }
+        }
+      }
+    }
+    if (closestThumbIndex > -1 && closestThumbIndex !== pressedThumbIndex) {
+      updatePressedThumb(closestThumbIndex);
+    }
+    if (inset) {
+      const thumbEl = thumbRefs.current[closestThumbIndex];
+      if (isElement(thumbEl)) {
+        const thumbRect = thumbEl.getBoundingClientRect();
+        const side = !vertical ? "width" : "height";
+        insetThumbOffsetRef.current = thumbRect[side] / 2;
+      }
+    }
+  }
+  function focusThumb(thumbIndex) {
+    const input = thumbRefs.current?.[thumbIndex]?.querySelector('input[type="range"]');
+    if (!input) {
+      return;
+    }
+    input.focus({
+      preventScroll: true,
+      focusVisible: false
+    });
+  }
+  const handleTouchMove = useStableCallback((nativeEvent) => {
+    const fingerCoords = getFingerCoords(nativeEvent, touchIdRef);
+    if (fingerCoords == null) {
+      return;
+    }
+    moveCountRef.current += 1;
+    if (nativeEvent.type === "pointermove" && nativeEvent.buttons === 0) {
+      handleTouchEnd(nativeEvent);
+      return;
+    }
+    const finger = getFingerState(fingerCoords);
+    if (finger == null) {
+      return;
+    }
+    if (validateMinimumDistance(finger.value, step, minStepsBetweenValues)) {
+      if (!dragging && moveCountRef.current > INTENTIONAL_DRAG_COUNT_THRESHOLD) {
+        setDragging(true);
+      }
+      setValue(finger.value, createChangeEventDetails(exports_reason_parts.drag, nativeEvent, undefined, {
+        activeThumbIndex: finger.thumbIndex
+      }));
+      latestValuesRef.current = Array.isArray(finger.value) ? finger.value : [finger.value];
+      if (finger.didSwap) {
+        focusThumb(finger.thumbIndex);
+      }
+    }
+  });
+  function handleTouchEnd(nativeEvent) {
+    setActive(-1);
+    setDragging(false);
+    pressedInputRef.current = null;
+    pressedThumbCenterOffsetRef.current = null;
+    const fingerCoords = getFingerCoords(nativeEvent, touchIdRef);
+    const finger = fingerCoords != null ? getFingerState(fingerCoords) : null;
+    if (finger != null) {
+      const commitReason = lastChangeReasonRef.current;
+      onValueCommitted(lastChangedValueRef.current ?? finger.value, createGenericEventDetails(commitReason, nativeEvent));
+    }
+    if ("pointerType" in nativeEvent && controlRef.current?.hasPointerCapture(nativeEvent.pointerId)) {
+      controlRef.current?.releasePointerCapture(nativeEvent.pointerId);
+    }
+    pressedThumbIndexRef.current = -1;
+    touchIdRef.current = null;
+    pressedValuesRef.current = null;
+    stopListening();
+  }
+  const handleTouchStart = useStableCallback((nativeEvent) => {
+    if (disabled) {
+      return;
+    }
+    const touch = nativeEvent.changedTouches[0];
+    if (touch != null) {
+      touchIdRef.current = touch.identifier;
+    }
+    const fingerCoords = getFingerCoords(nativeEvent, touchIdRef);
+    if (fingerCoords != null) {
+      startPressing(fingerCoords);
+      const finger = getFingerState(fingerCoords);
+      if (finger == null) {
+        return;
+      }
+      focusThumb(finger.thumbIndex);
+      setValue(finger.value, createChangeEventDetails(exports_reason_parts.trackPress, nativeEvent, undefined, {
+        activeThumbIndex: finger.thumbIndex
+      }));
+      latestValuesRef.current = Array.isArray(finger.value) ? finger.value : [finger.value];
+      if (finger.didSwap) {
+        focusThumb(finger.thumbIndex);
+      }
+    }
+    moveCountRef.current = 0;
+    const doc = ownerDocument(controlRef.current);
+    doc.addEventListener("touchmove", handleTouchMove, {
+      passive: true
+    });
+    doc.addEventListener("touchend", handleTouchEnd, {
+      passive: true
+    });
+  });
+  const stopListening = useStableCallback(() => {
+    const doc = ownerDocument(controlRef.current);
+    doc.removeEventListener("pointermove", handleTouchMove);
+    doc.removeEventListener("pointerup", handleTouchEnd);
+    doc.removeEventListener("touchmove", handleTouchMove);
+    doc.removeEventListener("touchend", handleTouchEnd);
+    pressedValuesRef.current = null;
+  });
+  const focusFrame = useAnimationFrame();
+  React5.useEffect(() => {
+    const control = controlRef.current;
+    if (!control) {
+      return () => stopListening();
+    }
+    const unsubscribeTouchStart = addEventListener(control, "touchstart", handleTouchStart, {
+      passive: true
+    });
+    return () => {
+      unsubscribeTouchStart();
+      focusFrame.cancel();
+      stopListening();
+    };
+  }, [stopListening, handleTouchStart, controlRef, focusFrame]);
+  React5.useEffect(() => {
+    if (disabled) {
+      stopListening();
+    }
+  }, [disabled, stopListening]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, registerFieldControlRef, controlRef, setStylesRef],
+    props: [{
+      ["data-base-ui-slider-control"]: renderBeforeHydration ? "" : undefined,
+      onPointerDown(event) {
+        const control = controlRef.current;
+        const target = getTarget(event.nativeEvent);
+        if (!control || disabled || event.defaultPrevented || !isElement(target) || event.button !== 0) {
+          return;
+        }
+        const fingerCoords = getFingerCoords(event, touchIdRef);
+        if (fingerCoords != null) {
+          startPressing(fingerCoords);
+          const finger = getFingerState(fingerCoords);
+          if (finger == null) {
+            return;
+          }
+          const pressedOnFocusedThumb = contains(thumbRefs.current[finger.thumbIndex], activeElement(ownerDocument(control)));
+          if (pressedOnFocusedThumb) {
+            event.preventDefault();
+          } else {
+            focusFrame.request(() => {
+              focusThumb(finger.thumbIndex);
+            });
+          }
+          setDragging(true);
+          const pressedOnAnyThumb = pressedThumbCenterOffsetRef.current != null;
+          if (!pressedOnAnyThumb) {
+            setValue(finger.value, createChangeEventDetails(exports_reason_parts.trackPress, event.nativeEvent, undefined, {
+              activeThumbIndex: finger.thumbIndex
+            }));
+            latestValuesRef.current = Array.isArray(finger.value) ? finger.value : [finger.value];
+            if (finger.didSwap) {
+              focusThumb(finger.thumbIndex);
+            }
+          }
+        }
+        if (event.nativeEvent.pointerId) {
+          control.setPointerCapture(event.nativeEvent.pointerId);
+        }
+        moveCountRef.current = 0;
+        const doc = ownerDocument(controlRef.current);
+        doc.addEventListener("pointermove", handleTouchMove, {
+          passive: true
+        });
+        doc.addEventListener("pointerup", handleTouchEnd, {
+          once: true
+        });
+      }
+    }, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+  return element;
+});
+if (true)
+  SliderControl.displayName = "SliderControl";
+// node_modules/@base-ui/react/esm/slider/track/SliderTrack.js
+import * as React6 from "react";
+"use client";
+var SliderTrack = /* @__PURE__ */ React6.forwardRef(function SliderTrack2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    state
+  } = useSliderRootContext();
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      style: {
+        position: "relative"
+      }
+    }, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+  return element;
+});
+if (true)
+  SliderTrack.displayName = "SliderTrack";
+// node_modules/@base-ui/react/esm/slider/thumb/SliderThumb.js
+import * as React7 from "react";
+
+// node_modules/@base-ui/react/esm/slider/thumb/SliderThumbDataAttributes.js
+var SliderThumbDataAttributes = /* @__PURE__ */ function(SliderThumbDataAttributes2) {
+  SliderThumbDataAttributes2["index"] = "data-index";
+  SliderThumbDataAttributes2["dragging"] = "data-dragging";
+  SliderThumbDataAttributes2["orientation"] = "data-orientation";
+  SliderThumbDataAttributes2["disabled"] = "data-disabled";
+  SliderThumbDataAttributes2["valid"] = "data-valid";
+  SliderThumbDataAttributes2["invalid"] = "data-invalid";
+  SliderThumbDataAttributes2["touched"] = "data-touched";
+  SliderThumbDataAttributes2["dirty"] = "data-dirty";
+  SliderThumbDataAttributes2["focused"] = "data-focused";
+  return SliderThumbDataAttributes2;
+}({});
+
+// node_modules/@base-ui/react/esm/slider/thumb/prehydrationScript.min.js
+var script = '!function(){const t=document.currentScript?.parentElement;if(!t)return;const e=t.closest("[data-base-ui-slider-control]");if(!e)return;const r=e.querySelector("[data-base-ui-slider-indicator]"),i=e.getBoundingClientRect(),n="vertical"===e.getAttribute("data-orientation")?"height":"width",o=e.querySelectorAll(\'input[type="range"]\'),l=o.length>1,s=o.length-1;let a=null,u=null;for(let t=0;t<o.length;t+=1){const e=o[t],y=parseFloat(e.getAttribute("value")??"");if(Number.isNaN(y))return;const c=e.parentElement;if(!c)return;const p=parseFloat(e.getAttribute("max")??"100"),g=parseFloat(e.getAttribute("min")??"0"),b=c?.getBoundingClientRect(),d=i[n]-b[n],m=100*(y-g)/(p-g),v=(b[n]/2+d*m/100)/i[n]*100;c.style.setProperty("--position",`${v}%`),Number.isFinite(v)&&(c.style.removeProperty("visibility"),r&&(0===t?(a=v,r.style.setProperty("--start-position",`${v}%`),l||r.style.removeProperty("visibility")):t===s&&(u=v-(a??0),r.style.setProperty("--end-position",`${v}%`),r.style.setProperty("--relative-size",`${u}%`),r.style.removeProperty("visibility"))))}}();';
+
+// node_modules/@base-ui/react/esm/slider/thumb/SliderThumb.js
+import { jsx as _jsx2, jsxs as _jsxs } from "react/jsx-runtime";
+"use client";
+var ALL_KEYS = new Set([...COMPOSITE_KEYS, PAGE_UP, PAGE_DOWN]);
+function getDefaultAriaValueText(values, index, format, locale) {
+  if (index < 0) {
+    return;
+  }
+  if (values.length === 2) {
+    if (index === 0) {
+      return `${formatNumber(values[index], locale, format)} start range`;
+    }
+    return `${formatNumber(values[index], locale, format)} end range`;
+  }
+  return format ? formatNumber(values[index], locale, format) : undefined;
+}
+function getNewValue(thumbValue, increment, direction, min, max) {
+  const value = direction === 1 ? thumbValue + increment : thumbValue - increment;
+  const roundedValue = Number(value.toFixed(Math.max(getDecimalPrecision(thumbValue), getDecimalPrecision(increment), getDecimalPrecision(min))));
+  return clamp(roundedValue, min, max);
+}
+var SliderThumb = /* @__PURE__ */ React7.forwardRef(function SliderThumb2(componentProps, forwardedRef) {
+  const {
+    render,
+    children: childrenProp,
+    className,
+    "aria-describedby": ariaDescribedByProp,
+    "aria-label": ariaLabelProp,
+    "aria-labelledby": ariaLabelledByProp,
+    disabled: disabledProp = false,
+    getAriaLabel: getAriaLabelProp,
+    getAriaValueText: getAriaValueTextProp,
+    id: idProp,
+    index: indexProp,
+    inputRef: inputRefProp,
+    onBlur: onBlurProp,
+    onFocus: onFocusProp,
+    onKeyDown: onKeyDownProp,
+    tabIndex: tabIndexProp,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    nonce
+  } = useCSPContext();
+  const id = useBaseUiId(idProp);
+  const {
+    active: activeIndex,
+    lastUsedThumbIndex,
+    controlRef,
+    disabled: contextDisabled,
+    validation,
+    formatOptionsRef,
+    handleInputChange,
+    inset,
+    labelId,
+    largeStep,
+    locale,
+    max,
+    min,
+    minStepsBetweenValues,
+    form,
+    name,
+    orientation,
+    pressedInputRef,
+    pressedThumbCenterOffsetRef,
+    pressedThumbIndexRef,
+    renderBeforeHydration,
+    setActive,
+    setIndicatorPosition,
+    state,
+    step,
+    values: sliderValues
+  } = useSliderRootContext();
+  const direction = useDirection();
+  const disabled = disabledProp || contextDisabled;
+  const range = sliderValues.length > 1;
+  const vertical = orientation === "vertical";
+  const rtl = direction === "rtl";
+  const {
+    setTouched,
+    setFocused,
+    validationMode
+  } = useFieldRootContext();
+  const thumbRef = React7.useRef(null);
+  const inputRef = React7.useRef(null);
+  const restoringFocusVisibleRef = React7.useRef(false);
+  const defaultInputId = useBaseUiId();
+  const labelableId = useLabelableId();
+  const inputId = range ? defaultInputId : labelableId;
+  const thumbMetadata = React7.useMemo(() => ({
+    inputId
+  }), [inputId]);
+  const {
+    ref: listItemRef,
+    index: compositeIndex
+  } = useCompositeListItem({
+    metadata: thumbMetadata
+  });
+  const index = !range ? 0 : indexProp ?? compositeIndex;
+  const last = index === sliderValues.length - 1;
+  const thumbValue = sliderValues[index];
+  const thumbValuePercent = valueToPercent(thumbValue, min, max);
+  const [positionPercent, setPositionPercent] = React7.useState();
+  const isHydrating = useIsHydrating();
+  const safeLastUsedThumbIndex = lastUsedThumbIndex >= 0 && lastUsedThumbIndex < sliderValues.length ? lastUsedThumbIndex : -1;
+  const getInsetPosition = useStableCallback(() => {
+    const control = controlRef.current;
+    const thumb = thumbRef.current;
+    if (!control || !thumb) {
+      return;
+    }
+    const thumbRect = thumb.getBoundingClientRect();
+    const controlRect = control.getBoundingClientRect();
+    const side = vertical ? "height" : "width";
+    const controlSize = controlRect[side] - thumbRect[side];
+    const thumbOffsetFromControlEdge = thumbRect[side] / 2 + controlSize * thumbValuePercent / 100;
+    const nextPositionPercent = thumbOffsetFromControlEdge / controlRect[side] * 100;
+    const nextInsetPosition = Number.isFinite(nextPositionPercent) ? nextPositionPercent : undefined;
+    setPositionPercent(nextInsetPosition);
+    if (index === 0) {
+      setIndicatorPosition((prevPosition) => [nextInsetPosition, prevPosition[1]]);
+    } else if (last) {
+      setIndicatorPosition((prevPosition) => [prevPosition[0], nextInsetPosition]);
+    }
+  });
+  useIsoLayoutEffect(() => {
+    if (inset) {
+      queueMicrotask(getInsetPosition);
+    }
+  }, [getInsetPosition, inset]);
+  useIsoLayoutEffect(() => {
+    if (inset) {
+      getInsetPosition();
+    }
+  }, [getInsetPosition, inset, thumbValuePercent]);
+  useIsoLayoutEffect(() => {
+    if (!inset) {
+      return;
+    }
+    const control = controlRef.current;
+    const thumb = thumbRef.current;
+    if (!control || !thumb) {
+      return;
+    }
+    const ResizeObserverCtor = getWindow(control).ResizeObserver;
+    if (typeof ResizeObserverCtor !== "function") {
+      return;
+    }
+    const resizeObserver = new ResizeObserverCtor(getInsetPosition);
+    resizeObserver.observe(control);
+    resizeObserver.observe(thumb);
+    return () => {
+      resizeObserver.disconnect();
+    };
+  }, [controlRef, getInsetPosition, inset]);
+  const startEdge = vertical ? "bottom" : "insetInlineStart";
+  const crossOffsetProperty = vertical ? "left" : "top";
+  let zIndex;
+  if (range) {
+    if (activeIndex === index) {
+      zIndex = 2;
+    } else if (safeLastUsedThumbIndex === index) {
+      zIndex = 1;
+    }
+  } else if (activeIndex === index) {
+    zIndex = 1;
+  }
+  let thumbStyle;
+  if (inset) {
+    thumbStyle = {
+      ["--position"]: `${positionPercent ?? 0}%`,
+      visibility: renderBeforeHydration && isHydrating || positionPercent === undefined ? "hidden" : undefined,
+      position: "absolute",
+      [startEdge]: "var(--position)",
+      [crossOffsetProperty]: "50%",
+      translate: `${(vertical || !rtl ? -1 : 1) * 50}% ${(vertical ? 1 : -1) * 50}%`,
+      zIndex
+    };
+  } else {
+    thumbStyle = !Number.isFinite(thumbValuePercent) ? visuallyHidden : {
+      position: "absolute",
+      [startEdge]: `${thumbValuePercent}%`,
+      [crossOffsetProperty]: "50%",
+      translate: `${(vertical || !rtl ? -1 : 1) * 50}% ${(vertical ? 1 : -1) * 50}%`,
+      zIndex
+    };
+  }
+  let cssWritingMode;
+  if (orientation === "vertical") {
+    cssWritingMode = rtl ? "vertical-rl" : "vertical-lr";
+  }
+  const ariaLabel = typeof getAriaLabelProp === "function" ? getAriaLabelProp(index) : ariaLabelProp;
+  const inputProps = mergeProps({
+    "aria-label": ariaLabel,
+    "aria-labelledby": ariaLabelledByProp ?? (ariaLabel == null ? labelId : undefined),
+    "aria-describedby": ariaDescribedByProp,
+    "aria-orientation": orientation,
+    "aria-valuenow": thumbValue,
+    "aria-valuetext": typeof getAriaValueTextProp === "function" ? getAriaValueTextProp(formatNumber(thumbValue, locale, formatOptionsRef.current ?? undefined), thumbValue, index) : getDefaultAriaValueText(sliderValues, index, formatOptionsRef.current ?? undefined, locale),
+    disabled,
+    form,
+    id: inputId,
+    max,
+    min,
+    name,
+    onChange(event) {
+      handleInputChange(event.currentTarget.valueAsNumber, index, event);
+    },
+    onFocus(event) {
+      const isRestoringFocusVisible = restoringFocusVisibleRef.current;
+      restoringFocusVisibleRef.current = false;
+      setActive(index);
+      setFocused(true);
+      if (isRestoringFocusVisible) {
+        event.stopPropagation();
+      }
+    },
+    onBlur(event) {
+      if (restoringFocusVisibleRef.current) {
+        event.stopPropagation();
+        return;
+      }
+      if (!thumbRef.current) {
+        return;
+      }
+      setActive(-1);
+      setTouched(true);
+      setFocused(false);
+      if (validationMode === "onBlur") {
+        validation.commit(getSliderValue(thumbValue, index, min, max, range, sliderValues));
+      }
+    },
+    onKeyDown(event) {
+      if (!ALL_KEYS.has(event.key)) {
+        return;
+      }
+      if (COMPOSITE_KEYS.has(event.key)) {
+        event.stopPropagation();
+      }
+      let newValue = null;
+      const roundedValue = roundValueToStep(thumbValue, step, min);
+      switch (event.key) {
+        case ARROW_UP:
+          newValue = getNewValue(roundedValue, event.shiftKey ? largeStep : step, 1, min, max);
+          break;
+        case ARROW_RIGHT:
+          newValue = getNewValue(roundedValue, event.shiftKey ? largeStep : step, rtl ? -1 : 1, min, max);
+          break;
+        case ARROW_DOWN:
+          newValue = getNewValue(roundedValue, event.shiftKey ? largeStep : step, -1, min, max);
+          break;
+        case ARROW_LEFT:
+          newValue = getNewValue(roundedValue, event.shiftKey ? largeStep : step, rtl ? 1 : -1, min, max);
+          break;
+        case PAGE_UP:
+          newValue = getNewValue(roundedValue, largeStep, 1, min, max);
+          break;
+        case PAGE_DOWN:
+          newValue = getNewValue(roundedValue, largeStep, -1, min, max);
+          break;
+        case END:
+          newValue = max;
+          if (range) {
+            newValue = Number.isFinite(sliderValues[index + 1]) ? sliderValues[index + 1] - step * minStepsBetweenValues : max;
+          }
+          break;
+        case HOME:
+          newValue = min;
+          if (range) {
+            newValue = Number.isFinite(sliderValues[index - 1]) ? sliderValues[index - 1] + step * minStepsBetweenValues : min;
+          }
+          break;
+        default:
+          break;
+      }
+      if (newValue !== null) {
+        const input = event.currentTarget;
+        if (!matchesFocusVisible(input)) {
+          restoringFocusVisibleRef.current = true;
+          input.blur();
+          input.focus({
+            preventScroll: true,
+            focusVisible: true
+          });
+        }
+        handleInputChange(newValue, index, event);
+        event.preventDefault();
+      }
+    },
+    step,
+    style: {
+      ...visuallyHidden,
+      width: "100%",
+      height: "100%",
+      writingMode: cssWritingMode
+    },
+    tabIndex: tabIndexProp ?? undefined,
+    type: "range",
+    value: thumbValue ?? ""
+  }, validation.getInputValidationProps);
+  const mergedInputRef = useMergedRefs(inputRef, validation.inputRef, inputRefProp);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, listItemRef, thumbRef],
+    props: [{
+      [SliderThumbDataAttributes.index]: index,
+      children: /* @__PURE__ */ _jsxs(React7.Fragment, {
+        children: [childrenProp, /* @__PURE__ */ _jsx2("input", {
+          ref: mergedInputRef,
+          ...inputProps,
+          suppressHydrationWarning: true
+        }), inset && isHydrating && renderBeforeHydration && last && /* @__PURE__ */ _jsx2("script", {
+          nonce,
+          dangerouslySetInnerHTML: {
+            __html: script
+          },
+          suppressHydrationWarning: true
+        })]
+      }),
+      id,
+      onBlur: onBlurProp,
+      onFocus: onFocusProp,
+      onPointerDown(event) {
+        pressedThumbIndexRef.current = index;
+        if (thumbRef.current != null) {
+          const axis = orientation === "horizontal" ? "x" : "y";
+          const midpoint = getMidpoint(thumbRef.current);
+          const offset = (orientation === "horizontal" ? event.clientX : event.clientY) - midpoint[axis];
+          pressedThumbCenterOffsetRef.current = offset;
+        }
+        if (inputRef.current != null && pressedInputRef.current !== inputRef.current) {
+          pressedInputRef.current = inputRef.current;
+        }
+      },
+      style: thumbStyle,
+      suppressHydrationWarning: renderBeforeHydration || undefined
+    }, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+  return element;
+});
+if (true)
+  SliderThumb.displayName = "SliderThumb";
+// node_modules/@base-ui/react/esm/slider/indicator/SliderIndicator.js
+import * as React8 from "react";
+"use client";
+function getInsetStyles(vertical, range, start, end, renderBeforeHydration, hydrating) {
+  const visibility = start === undefined || range && end === undefined ? "hidden" : undefined;
+  const startEdge = vertical ? "bottom" : "insetInlineStart";
+  const mainSide = vertical ? "height" : "width";
+  const crossSide = vertical ? "width" : "height";
+  const styles = {
+    visibility: renderBeforeHydration && hydrating ? "hidden" : visibility,
+    position: vertical ? "absolute" : "relative",
+    [crossSide]: "inherit"
+  };
+  styles["--start-position"] = `${start ?? 0}%`;
+  if (!range) {
+    styles[startEdge] = 0;
+    styles[mainSide] = "var(--start-position)";
+    return styles;
+  }
+  styles["--relative-size"] = `${(end ?? 0) - (start ?? 0)}%`;
+  styles[startEdge] = "var(--start-position)";
+  styles[mainSide] = "var(--relative-size)";
+  return styles;
+}
+function getCenteredStyles(vertical, range, start, end) {
+  const startEdge = vertical ? "bottom" : "insetInlineStart";
+  const mainSide = vertical ? "height" : "width";
+  const crossSide = vertical ? "width" : "height";
+  const styles = {
+    position: vertical ? "absolute" : "relative",
+    [crossSide]: "inherit"
+  };
+  if (!range) {
+    styles[startEdge] = 0;
+    styles[mainSide] = `${start}%`;
+    return styles;
+  }
+  const size = end - start;
+  styles[startEdge] = `${start}%`;
+  styles[mainSide] = `${size}%`;
+  return styles;
+}
+var SliderIndicator = /* @__PURE__ */ React8.forwardRef(function SliderIndicator2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    style: styleProp,
+    ...elementProps
+  } = componentProps;
+  const {
+    indicatorPosition,
+    inset,
+    max,
+    min,
+    orientation,
+    renderBeforeHydration,
+    state,
+    values
+  } = useSliderRootContext();
+  const isHydrating = useIsHydrating();
+  const vertical = orientation === "vertical";
+  const range = values.length > 1;
+  const style = inset ? getInsetStyles(vertical, range, indicatorPosition[0], indicatorPosition[1], renderBeforeHydration, isHydrating) : getCenteredStyles(vertical, range, valueToPercent(values[0], min, max), valueToPercent(values[values.length - 1], min, max));
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      ["data-base-ui-slider-indicator"]: renderBeforeHydration ? "" : undefined,
+      style,
+      suppressHydrationWarning: renderBeforeHydration || undefined
+    }, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+  return element;
+});
+if (true)
+  SliderIndicator.displayName = "SliderIndicator";
+export {
+  exports_index_parts as Slider
+};