dune-react 0.0.1 → 0.0.2

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/slider/root/SliderRoot.js

@@ -0,0 +1,278 @@
+import * as React from "react";
+import { ownerDocument } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/owner.js";
+import { useControlled } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useControlled.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useValueAsRef } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useValueAsRef.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { warn } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/warn.js";
+import { createChangeEventDetails, createGenericEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useValueChanged } from "../../utils/useValueChanged.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { clamp } from "../../utils/clamp.js";
+import { areArraysEqual } from "../../utils/areArraysEqual.js";
+import { CompositeList } from "../../composite/list/CompositeList.js";
+import { useField } from "../../field/useField.js";
+import { useFieldRootContext } from "../../field/root/FieldRootContext.js";
+import { useFormContext } from "../../form/FormContext.js";
+import { useLabelableContext } from "../../labelable-provider/LabelableContext.js";
+import { getDefaultLabelId, resolveAriaLabelledBy } from "../../utils/resolveAriaLabelledBy.js";
+import { asc } from "../utils/asc.js";
+import { getSliderValue } from "../utils/getSliderValue.js";
+import { validateMinimumDistance } from "../utils/validateMinimumDistance.js";
+import { sliderStateAttributesMapping } from "./stateAttributesMapping.js";
+import { SliderRootContext } from "./SliderRootContext.js";
+import { jsx } from "react/jsx-runtime";
+import { activeElement } from "../../floating-ui-react/utils/element.js";
+import { none, keyboard, inputChange } from "../../utils/reason-parts.js";
+function getSliderChangeEventReason(event) {
+  return "key" in event ? keyboard : 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;
+}
+const SliderRoot = /* @__PURE__ */ React.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,
+    name: nameProp,
+    onValueChange: onValueChangeProp,
+    onValueCommitted: onValueCommittedProp,
+    orientation = "horizontal",
+    step = 1,
+    thumbCollisionBehavior = "push",
+    thumbAlignment = "center",
+    value: valueProp,
+    ...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] = React.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 = React.useRef(null);
+  const controlRef = React.useRef(null);
+  const thumbRefs = React.useRef([]);
+  const pressedInputRef = React.useRef(null);
+  const pressedThumbCenterOffsetRef = React.useRef(null);
+  const pressedThumbIndexRef = React.useRef(-1);
+  const pressedValuesRef = React.useRef(null);
+  const lastChangedValueRef = React.useRef(null);
+  const lastChangeReasonRef = React.useRef("none");
+  const formatOptionsRef = useValueAsRef(format);
+  const [active, setActiveState] = React.useState(-1);
+  const [lastUsedThumbIndex, setLastUsedThumbIndex] = React.useState(-1);
+  const [dragging, setDragging] = React.useState(false);
+  const [thumbMap, setThumbMap] = React.useState(() => /* @__PURE__ */ new Map());
+  const [indicatorPosition, setIndicatorPosition] = React.useState([void 0, void 0]);
+  const setActive = useStableCallback((value) => {
+    setActiveState(value);
+    if (value !== -1) {
+      setLastUsedThumbIndex(value);
+    }
+  });
+  useField({
+    id,
+    commit: validation.commit,
+    value: valueUnwrapped,
+    controlRef,
+    name,
+    getValue: () => 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 = React.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(none, void 0, void 0, {
+      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, void 0, {
+        activeThumbIndex: index
+      }));
+      setTouched(true);
+      const nextValue = lastChangedValueRef.current ?? newValue;
+      onValueCommitted(nextValue, createGenericEventDetails(reason, event.nativeEvent));
+    }
+  });
+  if (process.env.NODE_ENV !== "production") {
+    if (min >= max) {
+      warn("Slider `max` must be greater than `min`.");
+    }
+  }
+  useIsoLayoutEffect(() => {
+    var _a;
+    const activeEl = activeElement(ownerDocument(sliderRef.current));
+    if (disabled && activeEl && ((_a = sliderRef.current) == null ? void 0 : _a.contains(activeEl))) {
+      activeEl.blur();
+    }
+  }, [disabled]);
+  if (disabled && active !== -1) {
+    setActive(-1);
+  }
+  const state = React.useMemo(() => ({
+    ...fieldState,
+    activeThumbIndex: active,
+    disabled,
+    dragging,
+    orientation,
+    max,
+    min,
+    minStepsBetweenValues,
+    step,
+    values
+  }), [fieldState, active, disabled, dragging, max, min, minStepsBetweenValues, orientation, step, values]);
+  const contextValue = React.useMemo(() => ({
+    active,
+    controlRef,
+    disabled,
+    dragging,
+    validation,
+    formatOptionsRef,
+    handleInputChange,
+    indicatorPosition,
+    inset: thumbAlignment !== "center",
+    labelId: ariaLabelledby,
+    rootLabelId: defaultLabelId,
+    largeStep,
+    lastUsedThumbIndex,
+    lastChangedValueRef,
+    lastChangeReasonRef,
+    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, 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 (process.env.NODE_ENV !== "production") SliderRoot.displayName = "SliderRoot";
+export {
+  SliderRoot
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/slider/root/SliderRootContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const SliderRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") SliderRootContext.displayName = "SliderRootContext";
+function useSliderRootContext() {
+  const context = React.useContext(SliderRootContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: SliderRootContext is missing. Slider parts must be placed within <Slider.Root>." : formatErrorMessage(62));
+  }
+  return context;
+}
+export {
+  SliderRootContext,
+  useSliderRootContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/slider/root/stateAttributesMapping.js

@@ -0,0 +1,13 @@
+import { fieldValidityMapping } from "../../field/utils/constants.js";
+const sliderStateAttributesMapping = {
+  activeThumbIndex: () => null,
+  max: () => null,
+  min: () => null,
+  minStepsBetweenValues: () => null,
+  step: () => null,
+  values: () => null,
+  ...fieldValidityMapping
+};
+export {
+  sliderStateAttributesMapping
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/slider/thumb/SliderThumb.js

@@ -0,0 +1,330 @@
+import * as React from "react";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { useOnMount } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useOnMount.js";
+import { useMergedRefs } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useMergedRefs.js";
+import { visuallyHidden } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/visuallyHidden.js";
+import { formatNumber } from "../../utils/formatNumber.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { valueToPercent } from "../../utils/valueToPercent.js";
+import { COMPOSITE_KEYS, HOME, END, ARROW_LEFT, ARROW_DOWN, ARROW_RIGHT, ARROW_UP } from "../../composite/composite.js";
+import { useCompositeListItem } from "../../composite/list/useCompositeListItem.js";
+import { useDirection } from "../../direction-provider/DirectionContext.js";
+import { useCSPContext } from "../../csp-provider/CSPContext.js";
+import { useFieldRootContext } from "../../field/root/FieldRootContext.js";
+import { useLabelableId } from "../../labelable-provider/useLabelableId.js";
+import { getMidpoint } from "../utils/getMidpoint.js";
+import { getSliderValue } from "../utils/getSliderValue.js";
+import { roundValueToStep } from "../utils/roundValueToStep.js";
+import { useSliderRootContext } from "../root/SliderRootContext.js";
+import { sliderStateAttributesMapping } from "../root/stateAttributesMapping.js";
+import { SliderThumbDataAttributes } from "./SliderThumbDataAttributes.js";
+import { script } from "./prehydrationScript.min.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { mergeProps } from "../../merge-props/mergeProps.js";
+const PAGE_UP = "PageUp";
+const PAGE_DOWN = "PageDown";
+const ALL_KEYS = /* @__PURE__ */ new Set([ARROW_UP, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, HOME, END, PAGE_UP, PAGE_DOWN]);
+function getDefaultAriaValueText(values, index, format, locale) {
+  if (index < 0) {
+    return void 0;
+  }
+  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) : void 0;
+}
+function getNewValue(thumbValue, step, direction, min, max) {
+  return direction === 1 ? Math.min(thumbValue + step, max) : Math.max(thumbValue - step, min);
+}
+const SliderThumb = /* @__PURE__ */ React.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,
+    ...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,
+    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 = React.useRef(null);
+  const inputRef = React.useRef(null);
+  const defaultInputId = useBaseUiId();
+  const labelableId = useLabelableId();
+  const inputId = range ? defaultInputId : labelableId;
+  const thumbMetadata = React.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 [isMounted, setIsMounted] = React.useState(false);
+  const [positionPercent, setPositionPercent] = React.useState();
+  useOnMount(() => setIsMounted(true));
+  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;
+    setPositionPercent(nextPositionPercent);
+    if (index === 0) {
+      setIndicatorPosition((prevPosition) => [nextPositionPercent, prevPosition[1]]);
+    } else if (last) {
+      setIndicatorPosition((prevPosition) => [prevPosition[0], nextPositionPercent]);
+    }
+  });
+  useIsoLayoutEffect(() => {
+    if (inset) {
+      queueMicrotask(getInsetPosition);
+    }
+  }, [getInsetPosition, inset]);
+  useIsoLayoutEffect(() => {
+    if (inset) {
+      getInsetPosition();
+    }
+  }, [getInsetPosition, inset, thumbValuePercent]);
+  const getThumbStyle = React.useCallback(() => {
+    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;
+    }
+    if (!inset) {
+      if (!Number.isFinite(thumbValuePercent)) {
+        return visuallyHidden;
+      }
+      return {
+        position: "absolute",
+        [startEdge]: `${thumbValuePercent}%`,
+        [crossOffsetProperty]: "50%",
+        translate: `${(vertical || !rtl ? -1 : 1) * 50}% ${(vertical ? 1 : -1) * 50}%`,
+        zIndex
+      };
+    }
+    return {
+      ["--position"]: `${positionPercent}%`,
+      visibility: renderBeforeHydration && !isMounted || positionPercent === void 0 ? "hidden" : void 0,
+      position: "absolute",
+      [startEdge]: "var(--position)",
+      [crossOffsetProperty]: "50%",
+      translate: `${(vertical || !rtl ? -1 : 1) * 50}% ${(vertical ? 1 : -1) * 50}%`,
+      zIndex
+    };
+  }, [activeIndex, index, inset, isMounted, positionPercent, range, renderBeforeHydration, rtl, safeLastUsedThumbIndex, thumbValuePercent, vertical]);
+  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 : void 0),
+    "aria-describedby": ariaDescribedByProp,
+    "aria-orientation": orientation,
+    "aria-valuenow": thumbValue,
+    "aria-valuetext": typeof getAriaValueTextProp === "function" ? getAriaValueTextProp(formatNumber(thumbValue, locale, formatOptionsRef.current ?? void 0), thumbValue, index) : getDefaultAriaValueText(sliderValues, index, formatOptionsRef.current ?? void 0, locale),
+    disabled,
+    id: inputId,
+    max,
+    min,
+    name,
+    onChange(event) {
+      handleInputChange(event.target.valueAsNumber, index, event);
+    },
+    onFocus() {
+      setActive(index);
+      setFocused(true);
+    },
+    onBlur() {
+      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;
+      }
+      if (newValue !== null) {
+        handleInputChange(newValue, index, event);
+        event.preventDefault();
+      }
+    },
+    step,
+    style: {
+      ...visuallyHidden,
+      // So that VoiceOver's focus indicator matches the thumb's dimensions
+      width: "100%",
+      height: "100%",
+      writingMode: cssWritingMode
+    },
+    tabIndex: tabIndexProp ?? void 0,
+    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(React.Fragment, {
+        children: [childrenProp, /* @__PURE__ */ jsx("input", {
+          ref: mergedInputRef,
+          ...inputProps
+        }), inset && !isMounted && renderBeforeHydration && // this must be rendered with the last thumb to ensure all
+        // preceding thumbs are already rendered in the DOM
+        last && /* @__PURE__ */ jsx("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: getThumbStyle(),
+      suppressHydrationWarning: renderBeforeHydration || void 0,
+      tabIndex: -1
+    }, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") SliderThumb.displayName = "SliderThumb";
+export {
+  SliderThumb
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/slider/thumb/SliderThumbDataAttributes.js

@@ -0,0 +1,15 @@
+let 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;
+}({});
+export {
+  SliderThumbDataAttributes
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/slider/thumb/prehydrationScript.min.js

@@ -0,0 +1,4 @@
+const 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"))))}}();';
+export {
+  script
+};