@ultraviolet/ui 1.61.0 → 1.62.0

package/dist/components/Slider/components/DoubleSlider.js

@@ -0,0 +1,285 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { useTheme } from "@emotion/react";
+import { useId, useRef, useState, useMemo, useEffect, useCallback } from "react";
+import { Stack } from "../../Stack/index.js";
+import { Text } from "../../Text/index.js";
+import { SLIDER_WIDTH, THUMB_SIZE } from "../constant.js";
+import { trackStyle, thumbStyle, StyledTooltip, StyledNumberInput } from "../styles.js";
+import { Label } from "./Label.js";
+import { Options } from "./Options.js";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() {
+  return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
+}
+const StyledTextValue = /* @__PURE__ */ _styled(Text, process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["double", "isColumn"].includes(prop),
+  target: "e6m6w314"
+} : {
+  shouldForwardProp: (prop) => !["double", "isColumn"].includes(prop),
+  target: "e6m6w314",
+  label: "StyledTextValue"
+})("min-width:", ({
+  theme,
+  double,
+  isColumn
+}) => double && isColumn ? null : theme.space["5"], ";align-self:", ({
+  double
+}) => double ? "center" : "end", ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx"],"names":[],"mappings":"AAkB0C","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx","sourcesContent":["import { useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { Stack } from '../../Stack'\nimport { Text } from '../../Text'\nimport { SLIDER_WIDTH, THUMB_SIZE } from '../constant'\nimport {\n  StyledNumberInput,\n  StyledTooltip,\n  thumbStyle,\n  trackStyle,\n} from '../styles'\nimport type { DoubleSliderProps } from '../types'\nimport { Label } from './Label'\nimport { Options } from './Options'\n\nconst StyledTextValue = styled(Text, {\n  shouldForwardProp: prop => !['double', 'isColumn'].includes(prop),\n})<{ double: boolean; isColumn: boolean }>`\n  min-width: ${({ theme, double, isColumn }) => (double && isColumn ? null : theme.space['5'])};\n  align-self: ${({ double }) => (double ? 'center' : 'end')};\n`\n\nconst SliderElement = styled('input', {\n  shouldForwardProp: prop => !['themeSlider', 'suffix', 'left'].includes(prop),\n})<{ themeSlider: string; disabled: boolean; suffix: boolean; left: number }>`\n  position: absolute;\n  width: 100%;\n  pointer-events: none;\n  appearance: none;\n  padding: 0;\n  background: transparent;\n  outline: none;\n\n\n  &:focus {\n    &::-moz-range-thumb {\n      border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n      }\n\n      &::-webkit-slider-thumb {\n        border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n\n      }\n  }\n\n  /* Mozilla */\n  &::-moz-range-track {\n    ${trackStyle}\n  }\n  &::-moz-range-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n    }\n\n  /* Other browsers */\n  &::-ms-track {\n    ${trackStyle}\n  }\n\n  &:focus::-webkit-slider-runnable-track {\n    ${trackStyle}\n  }\n\n  &::-webkit-slider-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n  }\n`\nconst DoubleSliderWrapper = styled.div`\n  position: relative;\n  display: flex;\n  align-items: center;\n  width: -webkit-fill-available;\n  width: -moz-available;\n  height: 8px;\n  align-self: center;\n  `\n\nconst CustomRail = styled.div`\n  position: absolute;\n  top: 50%;\n  transform: translateY(-50%);\n  height: 8px;\n  width:100%;\n  min-width: 220px;\n  border-radius: ${({ theme }) => theme.radii.default};\n  background: ${({ theme }) => theme.colors.neutral.borderWeak};\n`\n\nconst InnerRail = styled.div`\n  position: absolute;\n  height: 100%;\n  background-color: ${({ theme }) => theme.colors.primary.border};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-error='true']{\n    background-color: ${({ theme }) => theme.colors.danger.backgroundStrong};\n  }\n\n  &[aria-disabled='true'] {\n    background-color: ${({ theme }) => theme.colors.primary.borderDisabled};\n  }\n`\n\nexport const DoubleSlider = ({\n  name,\n  tooltip,\n  direction,\n  disabled,\n  error,\n  'data-testid': dataTestId,\n  value,\n  onChange,\n  min = 0,\n  max = 100,\n  step = 1,\n  id,\n  onBlur,\n  onFocus,\n  possibleValues,\n  options,\n  unit,\n  label,\n  className,\n  input,\n  prefix,\n  suffix,\n  required,\n  tooltipPosition,\n  'aria-label': ariaLabel,\n}: DoubleSliderProps) => {\n  const { theme } = useTheme()\n  const localId = useId()\n  const finalId = id ?? localId\n  const refSlider = useRef<HTMLInputElement>(null)\n  const safeValue =\n    value && Array.isArray(value) && value.length === 2\n      ? value\n      : [min ?? 0, max ?? 1]\n  const [computedValues, setComputedValues] = useState(safeValue)\n  const [valueToShow, setValuesToShow] = useState<(number | null)[]>(safeValue)\n  const [sliderWidth, setWidth] = useState(\n    refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max,\n  )\n  const [customValue, setCustomValue] = useState<undefined | number[]>(\n    undefined,\n  )\n\n  const activeValue = (side: 'left' | 'right') => {\n    // Find the index of the min value (if side=\"left\") and max value (side=\"right\")\n    if (side === 'left') {\n      if (valueToShow[0] === null) return 0\n      if (valueToShow[1] !== null && valueToShow[1] < valueToShow[0]) return 1\n\n      return 0\n    }\n\n    if (valueToShow[1] === null) return 1\n    if (valueToShow[0] !== null && valueToShow[1] < valueToShow[0]) return 0\n\n    return 1\n  }\n\n  const ticks = useMemo(() => {\n    if (options === true) {\n      return Array.from({ length: max - min + 1 }, (_, index) => ({\n        value: min + index * step,\n        label: String(min + index * step),\n      })).filter(element => element.value <= max && element.value >= min)\n    }\n    if (options) return options\n    if (possibleValues) {\n      return possibleValues.map((element, index) => ({\n        value: index,\n        label: String(element),\n      }))\n    }\n\n    return []\n  }, [max, min, options, possibleValues, step])\n\n  // Default value to be coherent with a custom scale when one is defined\n  useEffect(() => {\n    if (possibleValues) {\n      setCustomValue([\n        possibleValues[Math.min(...computedValues)],\n        possibleValues[Math.max(...computedValues)],\n      ])\n    }\n  }, [possibleValues, computedValues])\n\n  const onChangeCallback = useCallback(\n    (localValue: (number | null)[]) => {\n      setValuesToShow(localValue)\n\n      const leftSliderValue = localValue[0] === null ? min : localValue[0]\n      const rightSliderValue = localValue[1] === null ? max : localValue[1]\n      const newValues = [leftSliderValue, rightSliderValue]\n\n      setComputedValues(newValues)\n      onChange?.([Math.min(...newValues), Math.max(...newValues)])\n    },\n    [max, min, onChange],\n  )\n\n  // Get slider size (for options)\n  useEffect(() => {\n    const setWidthResize = () => {\n      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max)\n    }\n    window.addEventListener('resize', setWidthResize)\n\n    return () => {\n      window.removeEventListener('resize', setWidthResize)\n    }\n  }, [])\n\n  const handleMinChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        optionLabel,\n        customValue ? customValue[1] : computedValues[1],\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[1]),\n        Math.max(newVal, computedValues[1]),\n      ])\n    }\n    onChangeCallback([newVal, computedValues[1]])\n  }\n\n  const handleMaxChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        customValue ? customValue[0] : computedValues[0],\n        optionLabel,\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[0]),\n        Math.max(newVal, computedValues[0]),\n      ])\n    }\n    onChangeCallback([computedValues[0], newVal])\n  }\n\n  const handleChangeInput = (val: number, side?: 'left' | 'right') => {\n    if (side === 'left') {\n      if (valueToShow[1]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[1]),\n          Math.max(val, valueToShow[1]),\n        ])\n      } else onChangeCallback([val, valueToShow[1]])\n    } else if (side === 'right') {\n      if (valueToShow[0]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[0]),\n          Math.max(val, valueToShow[0]),\n        ])\n      } else onChangeCallback([valueToShow[0], val])\n    }\n  }\n\n  const styledValue = (\n    valueNumber: string | number | null,\n    side?: 'left' | 'right',\n  ) =>\n    input && (!options || options === true) && !possibleValues ? (\n      <StyledNumberInput\n        value={\n          typeof valueNumber === 'string'\n            ? parseFloat(valueNumber)\n            : valueNumber\n        }\n        size=\"small\"\n        min={min}\n        max={max}\n        step={step}\n        aria-label={`input-${side}`}\n        controls={false}\n        data-testid={side ? `slider-input-${side}` : 'slider-input'}\n        unit={typeof suffix === 'string' ? suffix : unit}\n        onChange={newVal => {\n          if (newVal !== null) {\n            handleChangeInput(newVal, side)\n          } else if (side === 'left') {\n            onChangeCallback([null, computedValues[1]])\n          } else if (side === 'right') {\n            onChangeCallback([computedValues[0], null])\n          }\n        }}\n        onBlur={event => {\n          // Default to min/max when the input is left empty\n          if (!event.target.value) {\n            if (side === 'left') {\n              const index = activeValue('left')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n\n            if (side === 'right') {\n              const index = activeValue('right')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n          }\n        }}\n      />\n    ) : (\n      <StyledTextValue\n        as=\"span\"\n        variant=\"bodySmall\"\n        sentiment=\"neutral\"\n        placement={direction !== 'row' ? 'right' : 'center'}\n        double\n        isColumn={direction === 'column'}\n        data-testid={\n          dataTestId ? `${dataTestId}-value-${side}` : `value-${side}`\n        }\n      >\n        {prefix}\n        {valueNumber}\n        {suffix ? suffix[side === 'left' ? 0 : 1] : unit}\n      </StyledTextValue>\n    )\n\n  // Position of the sliders to look like one range slider\n  const minPos = ((Math.min(...computedValues) - min) * 100) / (max - min)\n  const maxPos = ((Math.max(...computedValues) - min) * 100) / (max - min)\n\n  const tooltipText = useMemo(() => {\n    if (tooltip === true) {\n      return [Math.min(...computedValues), Math.max(...computedValues)]\n    }\n    if (Array.isArray(tooltip)) return tooltip\n\n    if (typeof tooltip === 'string') return tooltip\n\n    return [null, null]\n  }, [tooltip, computedValues])\n\n  const placementTooltip = [\n    ((computedValues[0] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n    ((computedValues[1] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n  ]\n\n  return (\n    <Stack gap={1} direction=\"column\" justifyContent=\"left\">\n      {label ? (\n        <Stack justifyContent=\"space-between\" direction=\"row\">\n          <Label\n            direction={direction}\n            input={input}\n            finalId={finalId}\n            label={label}\n            required={required}\n          />\n        </Stack>\n      ) : null}\n      <Stack direction={direction} gap={1} width=\"100%\">\n        {direction === 'column' ? (\n          <Stack justifyContent=\"space-between\" direction=\"row\">\n            {styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )}\n            {styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )}\n          </Stack>\n        ) : null}\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )\n          : null}\n\n        <DoubleSliderWrapper>\n          <StyledTooltip\n            text={typeof tooltipText === 'string' ? tooltipText : undefined}\n            placement={tooltipPosition}\n            left={(placementTooltip[0] + placementTooltip[1]) / 2}\n          >\n            <CustomRail>\n              <InnerRail\n                style={{ left: `${minPos}%`, right: `${100 - maxPos}%` }}\n                data-error={!!error}\n                aria-disabled={!!disabled}\n              />\n            </CustomRail>\n\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[0] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[0]}\n            >\n              <SliderElement\n                className={className}\n                name={name}\n                id={finalId}\n                disabled={!!disabled}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                type=\"range\"\n                value={computedValues[0]}\n                min={min}\n                suffix={!!(suffix || unit)}\n                aria-label={ariaLabel ?? name}\n                max={max}\n                step={step}\n                data-testid={dataTestId ? `${dataTestId}-left` : 'handle-left'}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMinChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                ref={refSlider}\n                left={((computedValues[0] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[1] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[1]}\n            >\n              <SliderElement\n                className={className}\n                type=\"range\"\n                value={computedValues[1]}\n                name={name}\n                disabled={!!disabled}\n                suffix={!!(suffix || unit)}\n                id={finalId}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                aria-label={ariaLabel ?? name}\n                data-testid={\n                  dataTestId ? `${dataTestId}-right` : 'handle-right'\n                }\n                min={min}\n                max={max}\n                step={step}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMaxChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                left={((computedValues[1] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n          </StyledTooltip>\n          {options || possibleValues ? (\n            <Options\n              ticks={ticks}\n              min={min}\n              max={max}\n              sliderWidth={sliderWidth}\n              unit={unit}\n              value={computedValues}\n              step={step}\n            />\n          ) : null}\n        </DoubleSliderWrapper>\n\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )\n          : null}\n      </Stack>\n    </Stack>\n  )\n}\n"]} */"));
+const SliderElement = /* @__PURE__ */ _styled("input", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["themeSlider", "suffix", "left"].includes(prop),
+  target: "e6m6w313"
+} : {
+  shouldForwardProp: (prop) => !["themeSlider", "suffix", "left"].includes(prop),
+  target: "e6m6w313",
+  label: "SliderElement"
+})("position:absolute;width:100%;pointer-events:none;appearance:none;padding:0;background:transparent;outline:none;&:focus{&::-moz-range-thumb{border:", ({
+  theme,
+  disabled
+}) => disabled ? null : `1.5px solid ${theme.colors.primary.border}`, ";box-shadow:", ({
+  theme,
+  disabled
+}) => disabled ? null : theme.shadows.focusPrimary, ";}&::-webkit-slider-thumb{border:", ({
+  theme,
+  disabled
+}) => disabled ? null : `1.5px solid ${theme.colors.primary.border}`, ";box-shadow:", ({
+  theme,
+  disabled
+}) => disabled ? null : theme.shadows.focusPrimary, ";}}&::-moz-range-track{", trackStyle, ";}&::-moz-range-thumb{", ({
+  theme,
+  themeSlider,
+  disabled,
+  left
+}) => thumbStyle(theme, themeSlider, disabled, left, true), ";}&::-ms-track{", trackStyle, ";}&:focus::-webkit-slider-runnable-track{", trackStyle, ";}&::-webkit-slider-thumb{", ({
+  theme,
+  themeSlider,
+  disabled,
+  left
+}) => thumbStyle(theme, themeSlider, disabled, left, true), ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx"],"names":[],"mappings":"AAyB6E","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx","sourcesContent":["import { useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { Stack } from '../../Stack'\nimport { Text } from '../../Text'\nimport { SLIDER_WIDTH, THUMB_SIZE } from '../constant'\nimport {\n  StyledNumberInput,\n  StyledTooltip,\n  thumbStyle,\n  trackStyle,\n} from '../styles'\nimport type { DoubleSliderProps } from '../types'\nimport { Label } from './Label'\nimport { Options } from './Options'\n\nconst StyledTextValue = styled(Text, {\n  shouldForwardProp: prop => !['double', 'isColumn'].includes(prop),\n})<{ double: boolean; isColumn: boolean }>`\n  min-width: ${({ theme, double, isColumn }) => (double && isColumn ? null : theme.space['5'])};\n  align-self: ${({ double }) => (double ? 'center' : 'end')};\n`\n\nconst SliderElement = styled('input', {\n  shouldForwardProp: prop => !['themeSlider', 'suffix', 'left'].includes(prop),\n})<{ themeSlider: string; disabled: boolean; suffix: boolean; left: number }>`\n  position: absolute;\n  width: 100%;\n  pointer-events: none;\n  appearance: none;\n  padding: 0;\n  background: transparent;\n  outline: none;\n\n\n  &:focus {\n    &::-moz-range-thumb {\n      border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n      }\n\n      &::-webkit-slider-thumb {\n        border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n\n      }\n  }\n\n  /* Mozilla */\n  &::-moz-range-track {\n    ${trackStyle}\n  }\n  &::-moz-range-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n    }\n\n  /* Other browsers */\n  &::-ms-track {\n    ${trackStyle}\n  }\n\n  &:focus::-webkit-slider-runnable-track {\n    ${trackStyle}\n  }\n\n  &::-webkit-slider-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n  }\n`\nconst DoubleSliderWrapper = styled.div`\n  position: relative;\n  display: flex;\n  align-items: center;\n  width: -webkit-fill-available;\n  width: -moz-available;\n  height: 8px;\n  align-self: center;\n  `\n\nconst CustomRail = styled.div`\n  position: absolute;\n  top: 50%;\n  transform: translateY(-50%);\n  height: 8px;\n  width:100%;\n  min-width: 220px;\n  border-radius: ${({ theme }) => theme.radii.default};\n  background: ${({ theme }) => theme.colors.neutral.borderWeak};\n`\n\nconst InnerRail = styled.div`\n  position: absolute;\n  height: 100%;\n  background-color: ${({ theme }) => theme.colors.primary.border};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-error='true']{\n    background-color: ${({ theme }) => theme.colors.danger.backgroundStrong};\n  }\n\n  &[aria-disabled='true'] {\n    background-color: ${({ theme }) => theme.colors.primary.borderDisabled};\n  }\n`\n\nexport const DoubleSlider = ({\n  name,\n  tooltip,\n  direction,\n  disabled,\n  error,\n  'data-testid': dataTestId,\n  value,\n  onChange,\n  min = 0,\n  max = 100,\n  step = 1,\n  id,\n  onBlur,\n  onFocus,\n  possibleValues,\n  options,\n  unit,\n  label,\n  className,\n  input,\n  prefix,\n  suffix,\n  required,\n  tooltipPosition,\n  'aria-label': ariaLabel,\n}: DoubleSliderProps) => {\n  const { theme } = useTheme()\n  const localId = useId()\n  const finalId = id ?? localId\n  const refSlider = useRef<HTMLInputElement>(null)\n  const safeValue =\n    value && Array.isArray(value) && value.length === 2\n      ? value\n      : [min ?? 0, max ?? 1]\n  const [computedValues, setComputedValues] = useState(safeValue)\n  const [valueToShow, setValuesToShow] = useState<(number | null)[]>(safeValue)\n  const [sliderWidth, setWidth] = useState(\n    refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max,\n  )\n  const [customValue, setCustomValue] = useState<undefined | number[]>(\n    undefined,\n  )\n\n  const activeValue = (side: 'left' | 'right') => {\n    // Find the index of the min value (if side=\"left\") and max value (side=\"right\")\n    if (side === 'left') {\n      if (valueToShow[0] === null) return 0\n      if (valueToShow[1] !== null && valueToShow[1] < valueToShow[0]) return 1\n\n      return 0\n    }\n\n    if (valueToShow[1] === null) return 1\n    if (valueToShow[0] !== null && valueToShow[1] < valueToShow[0]) return 0\n\n    return 1\n  }\n\n  const ticks = useMemo(() => {\n    if (options === true) {\n      return Array.from({ length: max - min + 1 }, (_, index) => ({\n        value: min + index * step,\n        label: String(min + index * step),\n      })).filter(element => element.value <= max && element.value >= min)\n    }\n    if (options) return options\n    if (possibleValues) {\n      return possibleValues.map((element, index) => ({\n        value: index,\n        label: String(element),\n      }))\n    }\n\n    return []\n  }, [max, min, options, possibleValues, step])\n\n  // Default value to be coherent with a custom scale when one is defined\n  useEffect(() => {\n    if (possibleValues) {\n      setCustomValue([\n        possibleValues[Math.min(...computedValues)],\n        possibleValues[Math.max(...computedValues)],\n      ])\n    }\n  }, [possibleValues, computedValues])\n\n  const onChangeCallback = useCallback(\n    (localValue: (number | null)[]) => {\n      setValuesToShow(localValue)\n\n      const leftSliderValue = localValue[0] === null ? min : localValue[0]\n      const rightSliderValue = localValue[1] === null ? max : localValue[1]\n      const newValues = [leftSliderValue, rightSliderValue]\n\n      setComputedValues(newValues)\n      onChange?.([Math.min(...newValues), Math.max(...newValues)])\n    },\n    [max, min, onChange],\n  )\n\n  // Get slider size (for options)\n  useEffect(() => {\n    const setWidthResize = () => {\n      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max)\n    }\n    window.addEventListener('resize', setWidthResize)\n\n    return () => {\n      window.removeEventListener('resize', setWidthResize)\n    }\n  }, [])\n\n  const handleMinChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        optionLabel,\n        customValue ? customValue[1] : computedValues[1],\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[1]),\n        Math.max(newVal, computedValues[1]),\n      ])\n    }\n    onChangeCallback([newVal, computedValues[1]])\n  }\n\n  const handleMaxChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        customValue ? customValue[0] : computedValues[0],\n        optionLabel,\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[0]),\n        Math.max(newVal, computedValues[0]),\n      ])\n    }\n    onChangeCallback([computedValues[0], newVal])\n  }\n\n  const handleChangeInput = (val: number, side?: 'left' | 'right') => {\n    if (side === 'left') {\n      if (valueToShow[1]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[1]),\n          Math.max(val, valueToShow[1]),\n        ])\n      } else onChangeCallback([val, valueToShow[1]])\n    } else if (side === 'right') {\n      if (valueToShow[0]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[0]),\n          Math.max(val, valueToShow[0]),\n        ])\n      } else onChangeCallback([valueToShow[0], val])\n    }\n  }\n\n  const styledValue = (\n    valueNumber: string | number | null,\n    side?: 'left' | 'right',\n  ) =>\n    input && (!options || options === true) && !possibleValues ? (\n      <StyledNumberInput\n        value={\n          typeof valueNumber === 'string'\n            ? parseFloat(valueNumber)\n            : valueNumber\n        }\n        size=\"small\"\n        min={min}\n        max={max}\n        step={step}\n        aria-label={`input-${side}`}\n        controls={false}\n        data-testid={side ? `slider-input-${side}` : 'slider-input'}\n        unit={typeof suffix === 'string' ? suffix : unit}\n        onChange={newVal => {\n          if (newVal !== null) {\n            handleChangeInput(newVal, side)\n          } else if (side === 'left') {\n            onChangeCallback([null, computedValues[1]])\n          } else if (side === 'right') {\n            onChangeCallback([computedValues[0], null])\n          }\n        }}\n        onBlur={event => {\n          // Default to min/max when the input is left empty\n          if (!event.target.value) {\n            if (side === 'left') {\n              const index = activeValue('left')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n\n            if (side === 'right') {\n              const index = activeValue('right')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n          }\n        }}\n      />\n    ) : (\n      <StyledTextValue\n        as=\"span\"\n        variant=\"bodySmall\"\n        sentiment=\"neutral\"\n        placement={direction !== 'row' ? 'right' : 'center'}\n        double\n        isColumn={direction === 'column'}\n        data-testid={\n          dataTestId ? `${dataTestId}-value-${side}` : `value-${side}`\n        }\n      >\n        {prefix}\n        {valueNumber}\n        {suffix ? suffix[side === 'left' ? 0 : 1] : unit}\n      </StyledTextValue>\n    )\n\n  // Position of the sliders to look like one range slider\n  const minPos = ((Math.min(...computedValues) - min) * 100) / (max - min)\n  const maxPos = ((Math.max(...computedValues) - min) * 100) / (max - min)\n\n  const tooltipText = useMemo(() => {\n    if (tooltip === true) {\n      return [Math.min(...computedValues), Math.max(...computedValues)]\n    }\n    if (Array.isArray(tooltip)) return tooltip\n\n    if (typeof tooltip === 'string') return tooltip\n\n    return [null, null]\n  }, [tooltip, computedValues])\n\n  const placementTooltip = [\n    ((computedValues[0] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n    ((computedValues[1] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n  ]\n\n  return (\n    <Stack gap={1} direction=\"column\" justifyContent=\"left\">\n      {label ? (\n        <Stack justifyContent=\"space-between\" direction=\"row\">\n          <Label\n            direction={direction}\n            input={input}\n            finalId={finalId}\n            label={label}\n            required={required}\n          />\n        </Stack>\n      ) : null}\n      <Stack direction={direction} gap={1} width=\"100%\">\n        {direction === 'column' ? (\n          <Stack justifyContent=\"space-between\" direction=\"row\">\n            {styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )}\n            {styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )}\n          </Stack>\n        ) : null}\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )\n          : null}\n\n        <DoubleSliderWrapper>\n          <StyledTooltip\n            text={typeof tooltipText === 'string' ? tooltipText : undefined}\n            placement={tooltipPosition}\n            left={(placementTooltip[0] + placementTooltip[1]) / 2}\n          >\n            <CustomRail>\n              <InnerRail\n                style={{ left: `${minPos}%`, right: `${100 - maxPos}%` }}\n                data-error={!!error}\n                aria-disabled={!!disabled}\n              />\n            </CustomRail>\n\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[0] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[0]}\n            >\n              <SliderElement\n                className={className}\n                name={name}\n                id={finalId}\n                disabled={!!disabled}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                type=\"range\"\n                value={computedValues[0]}\n                min={min}\n                suffix={!!(suffix || unit)}\n                aria-label={ariaLabel ?? name}\n                max={max}\n                step={step}\n                data-testid={dataTestId ? `${dataTestId}-left` : 'handle-left'}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMinChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                ref={refSlider}\n                left={((computedValues[0] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[1] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[1]}\n            >\n              <SliderElement\n                className={className}\n                type=\"range\"\n                value={computedValues[1]}\n                name={name}\n                disabled={!!disabled}\n                suffix={!!(suffix || unit)}\n                id={finalId}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                aria-label={ariaLabel ?? name}\n                data-testid={\n                  dataTestId ? `${dataTestId}-right` : 'handle-right'\n                }\n                min={min}\n                max={max}\n                step={step}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMaxChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                left={((computedValues[1] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n          </StyledTooltip>\n          {options || possibleValues ? (\n            <Options\n              ticks={ticks}\n              min={min}\n              max={max}\n              sliderWidth={sliderWidth}\n              unit={unit}\n              value={computedValues}\n              step={step}\n            />\n          ) : null}\n        </DoubleSliderWrapper>\n\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )\n          : null}\n      </Stack>\n    </Stack>\n  )\n}\n"]} */"));
+const DoubleSliderWrapper = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e6m6w312"
+} : {
+  target: "e6m6w312",
+  label: "DoubleSliderWrapper"
+})(process.env.NODE_ENV === "production" ? {
+  name: "nstg9i",
+  styles: "position:relative;display:flex;align-items:center;width:-webkit-fill-available;width:-moz-available;height:8px;align-self:center"
+} : {
+  name: "nstg9i",
+  styles: "position:relative;display:flex;align-items:center;width:-webkit-fill-available;width:-moz-available;height:8px;align-self:center",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx"],"names":[],"mappings":"AAqEsC","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx","sourcesContent":["import { useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { Stack } from '../../Stack'\nimport { Text } from '../../Text'\nimport { SLIDER_WIDTH, THUMB_SIZE } from '../constant'\nimport {\n  StyledNumberInput,\n  StyledTooltip,\n  thumbStyle,\n  trackStyle,\n} from '../styles'\nimport type { DoubleSliderProps } from '../types'\nimport { Label } from './Label'\nimport { Options } from './Options'\n\nconst StyledTextValue = styled(Text, {\n  shouldForwardProp: prop => !['double', 'isColumn'].includes(prop),\n})<{ double: boolean; isColumn: boolean }>`\n  min-width: ${({ theme, double, isColumn }) => (double && isColumn ? null : theme.space['5'])};\n  align-self: ${({ double }) => (double ? 'center' : 'end')};\n`\n\nconst SliderElement = styled('input', {\n  shouldForwardProp: prop => !['themeSlider', 'suffix', 'left'].includes(prop),\n})<{ themeSlider: string; disabled: boolean; suffix: boolean; left: number }>`\n  position: absolute;\n  width: 100%;\n  pointer-events: none;\n  appearance: none;\n  padding: 0;\n  background: transparent;\n  outline: none;\n\n\n  &:focus {\n    &::-moz-range-thumb {\n      border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n      }\n\n      &::-webkit-slider-thumb {\n        border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n\n      }\n  }\n\n  /* Mozilla */\n  &::-moz-range-track {\n    ${trackStyle}\n  }\n  &::-moz-range-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n    }\n\n  /* Other browsers */\n  &::-ms-track {\n    ${trackStyle}\n  }\n\n  &:focus::-webkit-slider-runnable-track {\n    ${trackStyle}\n  }\n\n  &::-webkit-slider-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n  }\n`\nconst DoubleSliderWrapper = styled.div`\n  position: relative;\n  display: flex;\n  align-items: center;\n  width: -webkit-fill-available;\n  width: -moz-available;\n  height: 8px;\n  align-self: center;\n  `\n\nconst CustomRail = styled.div`\n  position: absolute;\n  top: 50%;\n  transform: translateY(-50%);\n  height: 8px;\n  width:100%;\n  min-width: 220px;\n  border-radius: ${({ theme }) => theme.radii.default};\n  background: ${({ theme }) => theme.colors.neutral.borderWeak};\n`\n\nconst InnerRail = styled.div`\n  position: absolute;\n  height: 100%;\n  background-color: ${({ theme }) => theme.colors.primary.border};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-error='true']{\n    background-color: ${({ theme }) => theme.colors.danger.backgroundStrong};\n  }\n\n  &[aria-disabled='true'] {\n    background-color: ${({ theme }) => theme.colors.primary.borderDisabled};\n  }\n`\n\nexport const DoubleSlider = ({\n  name,\n  tooltip,\n  direction,\n  disabled,\n  error,\n  'data-testid': dataTestId,\n  value,\n  onChange,\n  min = 0,\n  max = 100,\n  step = 1,\n  id,\n  onBlur,\n  onFocus,\n  possibleValues,\n  options,\n  unit,\n  label,\n  className,\n  input,\n  prefix,\n  suffix,\n  required,\n  tooltipPosition,\n  'aria-label': ariaLabel,\n}: DoubleSliderProps) => {\n  const { theme } = useTheme()\n  const localId = useId()\n  const finalId = id ?? localId\n  const refSlider = useRef<HTMLInputElement>(null)\n  const safeValue =\n    value && Array.isArray(value) && value.length === 2\n      ? value\n      : [min ?? 0, max ?? 1]\n  const [computedValues, setComputedValues] = useState(safeValue)\n  const [valueToShow, setValuesToShow] = useState<(number | null)[]>(safeValue)\n  const [sliderWidth, setWidth] = useState(\n    refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max,\n  )\n  const [customValue, setCustomValue] = useState<undefined | number[]>(\n    undefined,\n  )\n\n  const activeValue = (side: 'left' | 'right') => {\n    // Find the index of the min value (if side=\"left\") and max value (side=\"right\")\n    if (side === 'left') {\n      if (valueToShow[0] === null) return 0\n      if (valueToShow[1] !== null && valueToShow[1] < valueToShow[0]) return 1\n\n      return 0\n    }\n\n    if (valueToShow[1] === null) return 1\n    if (valueToShow[0] !== null && valueToShow[1] < valueToShow[0]) return 0\n\n    return 1\n  }\n\n  const ticks = useMemo(() => {\n    if (options === true) {\n      return Array.from({ length: max - min + 1 }, (_, index) => ({\n        value: min + index * step,\n        label: String(min + index * step),\n      })).filter(element => element.value <= max && element.value >= min)\n    }\n    if (options) return options\n    if (possibleValues) {\n      return possibleValues.map((element, index) => ({\n        value: index,\n        label: String(element),\n      }))\n    }\n\n    return []\n  }, [max, min, options, possibleValues, step])\n\n  // Default value to be coherent with a custom scale when one is defined\n  useEffect(() => {\n    if (possibleValues) {\n      setCustomValue([\n        possibleValues[Math.min(...computedValues)],\n        possibleValues[Math.max(...computedValues)],\n      ])\n    }\n  }, [possibleValues, computedValues])\n\n  const onChangeCallback = useCallback(\n    (localValue: (number | null)[]) => {\n      setValuesToShow(localValue)\n\n      const leftSliderValue = localValue[0] === null ? min : localValue[0]\n      const rightSliderValue = localValue[1] === null ? max : localValue[1]\n      const newValues = [leftSliderValue, rightSliderValue]\n\n      setComputedValues(newValues)\n      onChange?.([Math.min(...newValues), Math.max(...newValues)])\n    },\n    [max, min, onChange],\n  )\n\n  // Get slider size (for options)\n  useEffect(() => {\n    const setWidthResize = () => {\n      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max)\n    }\n    window.addEventListener('resize', setWidthResize)\n\n    return () => {\n      window.removeEventListener('resize', setWidthResize)\n    }\n  }, [])\n\n  const handleMinChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        optionLabel,\n        customValue ? customValue[1] : computedValues[1],\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[1]),\n        Math.max(newVal, computedValues[1]),\n      ])\n    }\n    onChangeCallback([newVal, computedValues[1]])\n  }\n\n  const handleMaxChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        customValue ? customValue[0] : computedValues[0],\n        optionLabel,\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[0]),\n        Math.max(newVal, computedValues[0]),\n      ])\n    }\n    onChangeCallback([computedValues[0], newVal])\n  }\n\n  const handleChangeInput = (val: number, side?: 'left' | 'right') => {\n    if (side === 'left') {\n      if (valueToShow[1]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[1]),\n          Math.max(val, valueToShow[1]),\n        ])\n      } else onChangeCallback([val, valueToShow[1]])\n    } else if (side === 'right') {\n      if (valueToShow[0]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[0]),\n          Math.max(val, valueToShow[0]),\n        ])\n      } else onChangeCallback([valueToShow[0], val])\n    }\n  }\n\n  const styledValue = (\n    valueNumber: string | number | null,\n    side?: 'left' | 'right',\n  ) =>\n    input && (!options || options === true) && !possibleValues ? (\n      <StyledNumberInput\n        value={\n          typeof valueNumber === 'string'\n            ? parseFloat(valueNumber)\n            : valueNumber\n        }\n        size=\"small\"\n        min={min}\n        max={max}\n        step={step}\n        aria-label={`input-${side}`}\n        controls={false}\n        data-testid={side ? `slider-input-${side}` : 'slider-input'}\n        unit={typeof suffix === 'string' ? suffix : unit}\n        onChange={newVal => {\n          if (newVal !== null) {\n            handleChangeInput(newVal, side)\n          } else if (side === 'left') {\n            onChangeCallback([null, computedValues[1]])\n          } else if (side === 'right') {\n            onChangeCallback([computedValues[0], null])\n          }\n        }}\n        onBlur={event => {\n          // Default to min/max when the input is left empty\n          if (!event.target.value) {\n            if (side === 'left') {\n              const index = activeValue('left')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n\n            if (side === 'right') {\n              const index = activeValue('right')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n          }\n        }}\n      />\n    ) : (\n      <StyledTextValue\n        as=\"span\"\n        variant=\"bodySmall\"\n        sentiment=\"neutral\"\n        placement={direction !== 'row' ? 'right' : 'center'}\n        double\n        isColumn={direction === 'column'}\n        data-testid={\n          dataTestId ? `${dataTestId}-value-${side}` : `value-${side}`\n        }\n      >\n        {prefix}\n        {valueNumber}\n        {suffix ? suffix[side === 'left' ? 0 : 1] : unit}\n      </StyledTextValue>\n    )\n\n  // Position of the sliders to look like one range slider\n  const minPos = ((Math.min(...computedValues) - min) * 100) / (max - min)\n  const maxPos = ((Math.max(...computedValues) - min) * 100) / (max - min)\n\n  const tooltipText = useMemo(() => {\n    if (tooltip === true) {\n      return [Math.min(...computedValues), Math.max(...computedValues)]\n    }\n    if (Array.isArray(tooltip)) return tooltip\n\n    if (typeof tooltip === 'string') return tooltip\n\n    return [null, null]\n  }, [tooltip, computedValues])\n\n  const placementTooltip = [\n    ((computedValues[0] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n    ((computedValues[1] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n  ]\n\n  return (\n    <Stack gap={1} direction=\"column\" justifyContent=\"left\">\n      {label ? (\n        <Stack justifyContent=\"space-between\" direction=\"row\">\n          <Label\n            direction={direction}\n            input={input}\n            finalId={finalId}\n            label={label}\n            required={required}\n          />\n        </Stack>\n      ) : null}\n      <Stack direction={direction} gap={1} width=\"100%\">\n        {direction === 'column' ? (\n          <Stack justifyContent=\"space-between\" direction=\"row\">\n            {styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )}\n            {styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )}\n          </Stack>\n        ) : null}\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )\n          : null}\n\n        <DoubleSliderWrapper>\n          <StyledTooltip\n            text={typeof tooltipText === 'string' ? tooltipText : undefined}\n            placement={tooltipPosition}\n            left={(placementTooltip[0] + placementTooltip[1]) / 2}\n          >\n            <CustomRail>\n              <InnerRail\n                style={{ left: `${minPos}%`, right: `${100 - maxPos}%` }}\n                data-error={!!error}\n                aria-disabled={!!disabled}\n              />\n            </CustomRail>\n\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[0] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[0]}\n            >\n              <SliderElement\n                className={className}\n                name={name}\n                id={finalId}\n                disabled={!!disabled}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                type=\"range\"\n                value={computedValues[0]}\n                min={min}\n                suffix={!!(suffix || unit)}\n                aria-label={ariaLabel ?? name}\n                max={max}\n                step={step}\n                data-testid={dataTestId ? `${dataTestId}-left` : 'handle-left'}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMinChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                ref={refSlider}\n                left={((computedValues[0] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[1] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[1]}\n            >\n              <SliderElement\n                className={className}\n                type=\"range\"\n                value={computedValues[1]}\n                name={name}\n                disabled={!!disabled}\n                suffix={!!(suffix || unit)}\n                id={finalId}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                aria-label={ariaLabel ?? name}\n                data-testid={\n                  dataTestId ? `${dataTestId}-right` : 'handle-right'\n                }\n                min={min}\n                max={max}\n                step={step}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMaxChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                left={((computedValues[1] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n          </StyledTooltip>\n          {options || possibleValues ? (\n            <Options\n              ticks={ticks}\n              min={min}\n              max={max}\n              sliderWidth={sliderWidth}\n              unit={unit}\n              value={computedValues}\n              step={step}\n            />\n          ) : null}\n        </DoubleSliderWrapper>\n\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )\n          : null}\n      </Stack>\n    </Stack>\n  )\n}\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const CustomRail = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e6m6w311"
+} : {
+  target: "e6m6w311",
+  label: "CustomRail"
+})("position:absolute;top:50%;transform:translateY(-50%);height:8px;width:100%;min-width:220px;border-radius:", ({
+  theme
+}) => theme.radii.default, ";background:", ({
+  theme
+}) => theme.colors.neutral.borderWeak, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx"],"names":[],"mappings":"AA+E6B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx","sourcesContent":["import { useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { Stack } from '../../Stack'\nimport { Text } from '../../Text'\nimport { SLIDER_WIDTH, THUMB_SIZE } from '../constant'\nimport {\n  StyledNumberInput,\n  StyledTooltip,\n  thumbStyle,\n  trackStyle,\n} from '../styles'\nimport type { DoubleSliderProps } from '../types'\nimport { Label } from './Label'\nimport { Options } from './Options'\n\nconst StyledTextValue = styled(Text, {\n  shouldForwardProp: prop => !['double', 'isColumn'].includes(prop),\n})<{ double: boolean; isColumn: boolean }>`\n  min-width: ${({ theme, double, isColumn }) => (double && isColumn ? null : theme.space['5'])};\n  align-self: ${({ double }) => (double ? 'center' : 'end')};\n`\n\nconst SliderElement = styled('input', {\n  shouldForwardProp: prop => !['themeSlider', 'suffix', 'left'].includes(prop),\n})<{ themeSlider: string; disabled: boolean; suffix: boolean; left: number }>`\n  position: absolute;\n  width: 100%;\n  pointer-events: none;\n  appearance: none;\n  padding: 0;\n  background: transparent;\n  outline: none;\n\n\n  &:focus {\n    &::-moz-range-thumb {\n      border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n      }\n\n      &::-webkit-slider-thumb {\n        border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n\n      }\n  }\n\n  /* Mozilla */\n  &::-moz-range-track {\n    ${trackStyle}\n  }\n  &::-moz-range-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n    }\n\n  /* Other browsers */\n  &::-ms-track {\n    ${trackStyle}\n  }\n\n  &:focus::-webkit-slider-runnable-track {\n    ${trackStyle}\n  }\n\n  &::-webkit-slider-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n  }\n`\nconst DoubleSliderWrapper = styled.div`\n  position: relative;\n  display: flex;\n  align-items: center;\n  width: -webkit-fill-available;\n  width: -moz-available;\n  height: 8px;\n  align-self: center;\n  `\n\nconst CustomRail = styled.div`\n  position: absolute;\n  top: 50%;\n  transform: translateY(-50%);\n  height: 8px;\n  width:100%;\n  min-width: 220px;\n  border-radius: ${({ theme }) => theme.radii.default};\n  background: ${({ theme }) => theme.colors.neutral.borderWeak};\n`\n\nconst InnerRail = styled.div`\n  position: absolute;\n  height: 100%;\n  background-color: ${({ theme }) => theme.colors.primary.border};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-error='true']{\n    background-color: ${({ theme }) => theme.colors.danger.backgroundStrong};\n  }\n\n  &[aria-disabled='true'] {\n    background-color: ${({ theme }) => theme.colors.primary.borderDisabled};\n  }\n`\n\nexport const DoubleSlider = ({\n  name,\n  tooltip,\n  direction,\n  disabled,\n  error,\n  'data-testid': dataTestId,\n  value,\n  onChange,\n  min = 0,\n  max = 100,\n  step = 1,\n  id,\n  onBlur,\n  onFocus,\n  possibleValues,\n  options,\n  unit,\n  label,\n  className,\n  input,\n  prefix,\n  suffix,\n  required,\n  tooltipPosition,\n  'aria-label': ariaLabel,\n}: DoubleSliderProps) => {\n  const { theme } = useTheme()\n  const localId = useId()\n  const finalId = id ?? localId\n  const refSlider = useRef<HTMLInputElement>(null)\n  const safeValue =\n    value && Array.isArray(value) && value.length === 2\n      ? value\n      : [min ?? 0, max ?? 1]\n  const [computedValues, setComputedValues] = useState(safeValue)\n  const [valueToShow, setValuesToShow] = useState<(number | null)[]>(safeValue)\n  const [sliderWidth, setWidth] = useState(\n    refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max,\n  )\n  const [customValue, setCustomValue] = useState<undefined | number[]>(\n    undefined,\n  )\n\n  const activeValue = (side: 'left' | 'right') => {\n    // Find the index of the min value (if side=\"left\") and max value (side=\"right\")\n    if (side === 'left') {\n      if (valueToShow[0] === null) return 0\n      if (valueToShow[1] !== null && valueToShow[1] < valueToShow[0]) return 1\n\n      return 0\n    }\n\n    if (valueToShow[1] === null) return 1\n    if (valueToShow[0] !== null && valueToShow[1] < valueToShow[0]) return 0\n\n    return 1\n  }\n\n  const ticks = useMemo(() => {\n    if (options === true) {\n      return Array.from({ length: max - min + 1 }, (_, index) => ({\n        value: min + index * step,\n        label: String(min + index * step),\n      })).filter(element => element.value <= max && element.value >= min)\n    }\n    if (options) return options\n    if (possibleValues) {\n      return possibleValues.map((element, index) => ({\n        value: index,\n        label: String(element),\n      }))\n    }\n\n    return []\n  }, [max, min, options, possibleValues, step])\n\n  // Default value to be coherent with a custom scale when one is defined\n  useEffect(() => {\n    if (possibleValues) {\n      setCustomValue([\n        possibleValues[Math.min(...computedValues)],\n        possibleValues[Math.max(...computedValues)],\n      ])\n    }\n  }, [possibleValues, computedValues])\n\n  const onChangeCallback = useCallback(\n    (localValue: (number | null)[]) => {\n      setValuesToShow(localValue)\n\n      const leftSliderValue = localValue[0] === null ? min : localValue[0]\n      const rightSliderValue = localValue[1] === null ? max : localValue[1]\n      const newValues = [leftSliderValue, rightSliderValue]\n\n      setComputedValues(newValues)\n      onChange?.([Math.min(...newValues), Math.max(...newValues)])\n    },\n    [max, min, onChange],\n  )\n\n  // Get slider size (for options)\n  useEffect(() => {\n    const setWidthResize = () => {\n      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max)\n    }\n    window.addEventListener('resize', setWidthResize)\n\n    return () => {\n      window.removeEventListener('resize', setWidthResize)\n    }\n  }, [])\n\n  const handleMinChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        optionLabel,\n        customValue ? customValue[1] : computedValues[1],\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[1]),\n        Math.max(newVal, computedValues[1]),\n      ])\n    }\n    onChangeCallback([newVal, computedValues[1]])\n  }\n\n  const handleMaxChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        customValue ? customValue[0] : computedValues[0],\n        optionLabel,\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[0]),\n        Math.max(newVal, computedValues[0]),\n      ])\n    }\n    onChangeCallback([computedValues[0], newVal])\n  }\n\n  const handleChangeInput = (val: number, side?: 'left' | 'right') => {\n    if (side === 'left') {\n      if (valueToShow[1]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[1]),\n          Math.max(val, valueToShow[1]),\n        ])\n      } else onChangeCallback([val, valueToShow[1]])\n    } else if (side === 'right') {\n      if (valueToShow[0]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[0]),\n          Math.max(val, valueToShow[0]),\n        ])\n      } else onChangeCallback([valueToShow[0], val])\n    }\n  }\n\n  const styledValue = (\n    valueNumber: string | number | null,\n    side?: 'left' | 'right',\n  ) =>\n    input && (!options || options === true) && !possibleValues ? (\n      <StyledNumberInput\n        value={\n          typeof valueNumber === 'string'\n            ? parseFloat(valueNumber)\n            : valueNumber\n        }\n        size=\"small\"\n        min={min}\n        max={max}\n        step={step}\n        aria-label={`input-${side}`}\n        controls={false}\n        data-testid={side ? `slider-input-${side}` : 'slider-input'}\n        unit={typeof suffix === 'string' ? suffix : unit}\n        onChange={newVal => {\n          if (newVal !== null) {\n            handleChangeInput(newVal, side)\n          } else if (side === 'left') {\n            onChangeCallback([null, computedValues[1]])\n          } else if (side === 'right') {\n            onChangeCallback([computedValues[0], null])\n          }\n        }}\n        onBlur={event => {\n          // Default to min/max when the input is left empty\n          if (!event.target.value) {\n            if (side === 'left') {\n              const index = activeValue('left')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n\n            if (side === 'right') {\n              const index = activeValue('right')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n          }\n        }}\n      />\n    ) : (\n      <StyledTextValue\n        as=\"span\"\n        variant=\"bodySmall\"\n        sentiment=\"neutral\"\n        placement={direction !== 'row' ? 'right' : 'center'}\n        double\n        isColumn={direction === 'column'}\n        data-testid={\n          dataTestId ? `${dataTestId}-value-${side}` : `value-${side}`\n        }\n      >\n        {prefix}\n        {valueNumber}\n        {suffix ? suffix[side === 'left' ? 0 : 1] : unit}\n      </StyledTextValue>\n    )\n\n  // Position of the sliders to look like one range slider\n  const minPos = ((Math.min(...computedValues) - min) * 100) / (max - min)\n  const maxPos = ((Math.max(...computedValues) - min) * 100) / (max - min)\n\n  const tooltipText = useMemo(() => {\n    if (tooltip === true) {\n      return [Math.min(...computedValues), Math.max(...computedValues)]\n    }\n    if (Array.isArray(tooltip)) return tooltip\n\n    if (typeof tooltip === 'string') return tooltip\n\n    return [null, null]\n  }, [tooltip, computedValues])\n\n  const placementTooltip = [\n    ((computedValues[0] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n    ((computedValues[1] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n  ]\n\n  return (\n    <Stack gap={1} direction=\"column\" justifyContent=\"left\">\n      {label ? (\n        <Stack justifyContent=\"space-between\" direction=\"row\">\n          <Label\n            direction={direction}\n            input={input}\n            finalId={finalId}\n            label={label}\n            required={required}\n          />\n        </Stack>\n      ) : null}\n      <Stack direction={direction} gap={1} width=\"100%\">\n        {direction === 'column' ? (\n          <Stack justifyContent=\"space-between\" direction=\"row\">\n            {styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )}\n            {styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )}\n          </Stack>\n        ) : null}\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )\n          : null}\n\n        <DoubleSliderWrapper>\n          <StyledTooltip\n            text={typeof tooltipText === 'string' ? tooltipText : undefined}\n            placement={tooltipPosition}\n            left={(placementTooltip[0] + placementTooltip[1]) / 2}\n          >\n            <CustomRail>\n              <InnerRail\n                style={{ left: `${minPos}%`, right: `${100 - maxPos}%` }}\n                data-error={!!error}\n                aria-disabled={!!disabled}\n              />\n            </CustomRail>\n\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[0] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[0]}\n            >\n              <SliderElement\n                className={className}\n                name={name}\n                id={finalId}\n                disabled={!!disabled}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                type=\"range\"\n                value={computedValues[0]}\n                min={min}\n                suffix={!!(suffix || unit)}\n                aria-label={ariaLabel ?? name}\n                max={max}\n                step={step}\n                data-testid={dataTestId ? `${dataTestId}-left` : 'handle-left'}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMinChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                ref={refSlider}\n                left={((computedValues[0] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[1] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[1]}\n            >\n              <SliderElement\n                className={className}\n                type=\"range\"\n                value={computedValues[1]}\n                name={name}\n                disabled={!!disabled}\n                suffix={!!(suffix || unit)}\n                id={finalId}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                aria-label={ariaLabel ?? name}\n                data-testid={\n                  dataTestId ? `${dataTestId}-right` : 'handle-right'\n                }\n                min={min}\n                max={max}\n                step={step}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMaxChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                left={((computedValues[1] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n          </StyledTooltip>\n          {options || possibleValues ? (\n            <Options\n              ticks={ticks}\n              min={min}\n              max={max}\n              sliderWidth={sliderWidth}\n              unit={unit}\n              value={computedValues}\n              step={step}\n            />\n          ) : null}\n        </DoubleSliderWrapper>\n\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )\n          : null}\n      </Stack>\n    </Stack>\n  )\n}\n"]} */"));
+const InnerRail = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e6m6w310"
+} : {
+  target: "e6m6w310",
+  label: "InnerRail"
+})("position:absolute;height:100%;background-color:", ({
+  theme
+}) => theme.colors.primary.border, ";border-radius:", ({
+  theme
+}) => theme.radii.default, ";&[data-error='true']{background-color:", ({
+  theme
+}) => theme.colors.danger.backgroundStrong, ";}&[aria-disabled='true']{background-color:", ({
+  theme
+}) => theme.colors.primary.borderDisabled, ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx"],"names":[],"mappings":"AA0F4B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/components/DoubleSlider.tsx","sourcesContent":["import { useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { Stack } from '../../Stack'\nimport { Text } from '../../Text'\nimport { SLIDER_WIDTH, THUMB_SIZE } from '../constant'\nimport {\n  StyledNumberInput,\n  StyledTooltip,\n  thumbStyle,\n  trackStyle,\n} from '../styles'\nimport type { DoubleSliderProps } from '../types'\nimport { Label } from './Label'\nimport { Options } from './Options'\n\nconst StyledTextValue = styled(Text, {\n  shouldForwardProp: prop => !['double', 'isColumn'].includes(prop),\n})<{ double: boolean; isColumn: boolean }>`\n  min-width: ${({ theme, double, isColumn }) => (double && isColumn ? null : theme.space['5'])};\n  align-self: ${({ double }) => (double ? 'center' : 'end')};\n`\n\nconst SliderElement = styled('input', {\n  shouldForwardProp: prop => !['themeSlider', 'suffix', 'left'].includes(prop),\n})<{ themeSlider: string; disabled: boolean; suffix: boolean; left: number }>`\n  position: absolute;\n  width: 100%;\n  pointer-events: none;\n  appearance: none;\n  padding: 0;\n  background: transparent;\n  outline: none;\n\n\n  &:focus {\n    &::-moz-range-thumb {\n      border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n      }\n\n      &::-webkit-slider-thumb {\n        border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n      box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n\n      }\n  }\n\n  /* Mozilla */\n  &::-moz-range-track {\n    ${trackStyle}\n  }\n  &::-moz-range-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n    }\n\n  /* Other browsers */\n  &::-ms-track {\n    ${trackStyle}\n  }\n\n  &:focus::-webkit-slider-runnable-track {\n    ${trackStyle}\n  }\n\n  &::-webkit-slider-thumb {\n    ${({ theme, themeSlider, disabled, left }) => thumbStyle(theme, themeSlider, disabled, left, true)}\n  }\n`\nconst DoubleSliderWrapper = styled.div`\n  position: relative;\n  display: flex;\n  align-items: center;\n  width: -webkit-fill-available;\n  width: -moz-available;\n  height: 8px;\n  align-self: center;\n  `\n\nconst CustomRail = styled.div`\n  position: absolute;\n  top: 50%;\n  transform: translateY(-50%);\n  height: 8px;\n  width:100%;\n  min-width: 220px;\n  border-radius: ${({ theme }) => theme.radii.default};\n  background: ${({ theme }) => theme.colors.neutral.borderWeak};\n`\n\nconst InnerRail = styled.div`\n  position: absolute;\n  height: 100%;\n  background-color: ${({ theme }) => theme.colors.primary.border};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-error='true']{\n    background-color: ${({ theme }) => theme.colors.danger.backgroundStrong};\n  }\n\n  &[aria-disabled='true'] {\n    background-color: ${({ theme }) => theme.colors.primary.borderDisabled};\n  }\n`\n\nexport const DoubleSlider = ({\n  name,\n  tooltip,\n  direction,\n  disabled,\n  error,\n  'data-testid': dataTestId,\n  value,\n  onChange,\n  min = 0,\n  max = 100,\n  step = 1,\n  id,\n  onBlur,\n  onFocus,\n  possibleValues,\n  options,\n  unit,\n  label,\n  className,\n  input,\n  prefix,\n  suffix,\n  required,\n  tooltipPosition,\n  'aria-label': ariaLabel,\n}: DoubleSliderProps) => {\n  const { theme } = useTheme()\n  const localId = useId()\n  const finalId = id ?? localId\n  const refSlider = useRef<HTMLInputElement>(null)\n  const safeValue =\n    value && Array.isArray(value) && value.length === 2\n      ? value\n      : [min ?? 0, max ?? 1]\n  const [computedValues, setComputedValues] = useState(safeValue)\n  const [valueToShow, setValuesToShow] = useState<(number | null)[]>(safeValue)\n  const [sliderWidth, setWidth] = useState(\n    refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max,\n  )\n  const [customValue, setCustomValue] = useState<undefined | number[]>(\n    undefined,\n  )\n\n  const activeValue = (side: 'left' | 'right') => {\n    // Find the index of the min value (if side=\"left\") and max value (side=\"right\")\n    if (side === 'left') {\n      if (valueToShow[0] === null) return 0\n      if (valueToShow[1] !== null && valueToShow[1] < valueToShow[0]) return 1\n\n      return 0\n    }\n\n    if (valueToShow[1] === null) return 1\n    if (valueToShow[0] !== null && valueToShow[1] < valueToShow[0]) return 0\n\n    return 1\n  }\n\n  const ticks = useMemo(() => {\n    if (options === true) {\n      return Array.from({ length: max - min + 1 }, (_, index) => ({\n        value: min + index * step,\n        label: String(min + index * step),\n      })).filter(element => element.value <= max && element.value >= min)\n    }\n    if (options) return options\n    if (possibleValues) {\n      return possibleValues.map((element, index) => ({\n        value: index,\n        label: String(element),\n      }))\n    }\n\n    return []\n  }, [max, min, options, possibleValues, step])\n\n  // Default value to be coherent with a custom scale when one is defined\n  useEffect(() => {\n    if (possibleValues) {\n      setCustomValue([\n        possibleValues[Math.min(...computedValues)],\n        possibleValues[Math.max(...computedValues)],\n      ])\n    }\n  }, [possibleValues, computedValues])\n\n  const onChangeCallback = useCallback(\n    (localValue: (number | null)[]) => {\n      setValuesToShow(localValue)\n\n      const leftSliderValue = localValue[0] === null ? min : localValue[0]\n      const rightSliderValue = localValue[1] === null ? max : localValue[1]\n      const newValues = [leftSliderValue, rightSliderValue]\n\n      setComputedValues(newValues)\n      onChange?.([Math.min(...newValues), Math.max(...newValues)])\n    },\n    [max, min, onChange],\n  )\n\n  // Get slider size (for options)\n  useEffect(() => {\n    const setWidthResize = () => {\n      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max)\n    }\n    window.addEventListener('resize', setWidthResize)\n\n    return () => {\n      window.removeEventListener('resize', setWidthResize)\n    }\n  }, [])\n\n  const handleMinChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        optionLabel,\n        customValue ? customValue[1] : computedValues[1],\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[1]),\n        Math.max(newVal, computedValues[1]),\n      ])\n    }\n    onChangeCallback([newVal, computedValues[1]])\n  }\n\n  const handleMaxChange = (newVal: number) => {\n    if (possibleValues) {\n      // Custom scale\n      const optionLabel = possibleValues[newVal]\n      const newCustomValue = [\n        customValue ? customValue[0] : computedValues[0],\n        optionLabel,\n      ]\n      setCustomValue(newCustomValue)\n      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)])\n    } else {\n      onChange?.([\n        Math.min(newVal, computedValues[0]),\n        Math.max(newVal, computedValues[0]),\n      ])\n    }\n    onChangeCallback([computedValues[0], newVal])\n  }\n\n  const handleChangeInput = (val: number, side?: 'left' | 'right') => {\n    if (side === 'left') {\n      if (valueToShow[1]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[1]),\n          Math.max(val, valueToShow[1]),\n        ])\n      } else onChangeCallback([val, valueToShow[1]])\n    } else if (side === 'right') {\n      if (valueToShow[0]) {\n        onChangeCallback([\n          Math.min(val, valueToShow[0]),\n          Math.max(val, valueToShow[0]),\n        ])\n      } else onChangeCallback([valueToShow[0], val])\n    }\n  }\n\n  const styledValue = (\n    valueNumber: string | number | null,\n    side?: 'left' | 'right',\n  ) =>\n    input && (!options || options === true) && !possibleValues ? (\n      <StyledNumberInput\n        value={\n          typeof valueNumber === 'string'\n            ? parseFloat(valueNumber)\n            : valueNumber\n        }\n        size=\"small\"\n        min={min}\n        max={max}\n        step={step}\n        aria-label={`input-${side}`}\n        controls={false}\n        data-testid={side ? `slider-input-${side}` : 'slider-input'}\n        unit={typeof suffix === 'string' ? suffix : unit}\n        onChange={newVal => {\n          if (newVal !== null) {\n            handleChangeInput(newVal, side)\n          } else if (side === 'left') {\n            onChangeCallback([null, computedValues[1]])\n          } else if (side === 'right') {\n            onChangeCallback([computedValues[0], null])\n          }\n        }}\n        onBlur={event => {\n          // Default to min/max when the input is left empty\n          if (!event.target.value) {\n            if (side === 'left') {\n              const index = activeValue('left')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n\n            if (side === 'right') {\n              const index = activeValue('right')\n              if (index === 0) onChangeCallback([min, computedValues[1]])\n              else onChangeCallback([computedValues[0], max])\n            }\n          }\n        }}\n      />\n    ) : (\n      <StyledTextValue\n        as=\"span\"\n        variant=\"bodySmall\"\n        sentiment=\"neutral\"\n        placement={direction !== 'row' ? 'right' : 'center'}\n        double\n        isColumn={direction === 'column'}\n        data-testid={\n          dataTestId ? `${dataTestId}-value-${side}` : `value-${side}`\n        }\n      >\n        {prefix}\n        {valueNumber}\n        {suffix ? suffix[side === 'left' ? 0 : 1] : unit}\n      </StyledTextValue>\n    )\n\n  // Position of the sliders to look like one range slider\n  const minPos = ((Math.min(...computedValues) - min) * 100) / (max - min)\n  const maxPos = ((Math.max(...computedValues) - min) * 100) / (max - min)\n\n  const tooltipText = useMemo(() => {\n    if (tooltip === true) {\n      return [Math.min(...computedValues), Math.max(...computedValues)]\n    }\n    if (Array.isArray(tooltip)) return tooltip\n\n    if (typeof tooltip === 'string') return tooltip\n\n    return [null, null]\n  }, [tooltip, computedValues])\n\n  const placementTooltip = [\n    ((computedValues[0] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n    ((computedValues[1] - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n      THUMB_SIZE / 2,\n  ]\n\n  return (\n    <Stack gap={1} direction=\"column\" justifyContent=\"left\">\n      {label ? (\n        <Stack justifyContent=\"space-between\" direction=\"row\">\n          <Label\n            direction={direction}\n            input={input}\n            finalId={finalId}\n            label={label}\n            required={required}\n          />\n        </Stack>\n      ) : null}\n      <Stack direction={direction} gap={1} width=\"100%\">\n        {direction === 'column' ? (\n          <Stack justifyContent=\"space-between\" direction=\"row\">\n            {styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )}\n            {styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )}\n          </Stack>\n        ) : null}\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[0] : valueToShow[activeValue('left')],\n              'left',\n            )\n          : null}\n\n        <DoubleSliderWrapper>\n          <StyledTooltip\n            text={typeof tooltipText === 'string' ? tooltipText : undefined}\n            placement={tooltipPosition}\n            left={(placementTooltip[0] + placementTooltip[1]) / 2}\n          >\n            <CustomRail>\n              <InnerRail\n                style={{ left: `${minPos}%`, right: `${100 - maxPos}%` }}\n                data-error={!!error}\n                aria-disabled={!!disabled}\n              />\n            </CustomRail>\n\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[0] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[0]}\n            >\n              <SliderElement\n                className={className}\n                name={name}\n                id={finalId}\n                disabled={!!disabled}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                type=\"range\"\n                value={computedValues[0]}\n                min={min}\n                suffix={!!(suffix || unit)}\n                aria-label={ariaLabel ?? name}\n                max={max}\n                step={step}\n                data-testid={dataTestId ? `${dataTestId}-left` : 'handle-left'}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMinChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                ref={refSlider}\n                left={((computedValues[0] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n            <StyledTooltip\n              text={Array.isArray(tooltipText) ? tooltipText[1] : undefined}\n              placement={tooltipPosition}\n              left={placementTooltip[1]}\n            >\n              <SliderElement\n                className={className}\n                type=\"range\"\n                value={computedValues[1]}\n                name={name}\n                disabled={!!disabled}\n                suffix={!!(suffix || unit)}\n                id={finalId}\n                onBlur={onBlur}\n                onFocus={onFocus}\n                data-error={error}\n                data-direction={direction}\n                aria-label={ariaLabel ?? name}\n                data-testid={\n                  dataTestId ? `${dataTestId}-right` : 'handle-right'\n                }\n                min={min}\n                max={max}\n                step={step}\n                onChange={event => {\n                  event.preventDefault()\n                  handleMaxChange(parseFloat(event.target.value))\n                }}\n                themeSlider={theme}\n                left={((computedValues[1] - min) * 100) / (max - min)}\n              />\n            </StyledTooltip>\n          </StyledTooltip>\n          {options || possibleValues ? (\n            <Options\n              ticks={ticks}\n              min={min}\n              max={max}\n              sliderWidth={sliderWidth}\n              unit={unit}\n              value={computedValues}\n              step={step}\n            />\n          ) : null}\n        </DoubleSliderWrapper>\n\n        {direction === 'row'\n          ? styledValue(\n              customValue ? customValue[1] : valueToShow[activeValue('right')],\n              'right',\n            )\n          : null}\n      </Stack>\n    </Stack>\n  )\n}\n"]} */"));
+const DoubleSlider = ({
+  name,
+  tooltip,
+  direction,
+  disabled,
+  error,
+  "data-testid": dataTestId,
+  value,
+  onChange,
+  min = 0,
+  max = 100,
+  step = 1,
+  id,
+  onBlur,
+  onFocus,
+  possibleValues,
+  options,
+  unit,
+  label,
+  className,
+  input,
+  prefix,
+  suffix,
+  required,
+  tooltipPosition,
+  "aria-label": ariaLabel
+}) => {
+  const {
+    theme
+  } = useTheme();
+  const localId = useId();
+  const finalId = id ?? localId;
+  const refSlider = useRef(null);
+  const safeValue = value && Array.isArray(value) && value.length === 2 ? value : [min ?? 0, max ?? 1];
+  const [computedValues, setComputedValues] = useState(safeValue);
+  const [valueToShow, setValuesToShow] = useState(safeValue);
+  const [sliderWidth, setWidth] = useState(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max);
+  const [customValue, setCustomValue] = useState(void 0);
+  const activeValue = (side) => {
+    if (side === "left") {
+      if (valueToShow[0] === null) return 0;
+      if (valueToShow[1] !== null && valueToShow[1] < valueToShow[0]) return 1;
+      return 0;
+    }
+    if (valueToShow[1] === null) return 1;
+    if (valueToShow[0] !== null && valueToShow[1] < valueToShow[0]) return 0;
+    return 1;
+  };
+  const ticks = useMemo(() => {
+    if (options === true) {
+      return Array.from({
+        length: max - min + 1
+      }, (_, index) => ({
+        value: min + index * step,
+        label: String(min + index * step)
+      })).filter((element) => element.value <= max && element.value >= min);
+    }
+    if (options) return options;
+    if (possibleValues) {
+      return possibleValues.map((element, index) => ({
+        value: index,
+        label: String(element)
+      }));
+    }
+    return [];
+  }, [max, min, options, possibleValues, step]);
+  useEffect(() => {
+    if (possibleValues) {
+      setCustomValue([possibleValues[Math.min(...computedValues)], possibleValues[Math.max(...computedValues)]]);
+    }
+  }, [possibleValues, computedValues]);
+  const onChangeCallback = useCallback((localValue) => {
+    setValuesToShow(localValue);
+    const leftSliderValue = localValue[0] === null ? min : localValue[0];
+    const rightSliderValue = localValue[1] === null ? max : localValue[1];
+    const newValues = [leftSliderValue, rightSliderValue];
+    setComputedValues(newValues);
+    onChange?.([Math.min(...newValues), Math.max(...newValues)]);
+  }, [max, min, onChange]);
+  useEffect(() => {
+    const setWidthResize = () => {
+      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max);
+    };
+    window.addEventListener("resize", setWidthResize);
+    return () => {
+      window.removeEventListener("resize", setWidthResize);
+    };
+  }, []);
+  const handleMinChange = (newVal) => {
+    if (possibleValues) {
+      const optionLabel = possibleValues[newVal];
+      const newCustomValue = [optionLabel, customValue ? customValue[1] : computedValues[1]];
+      setCustomValue(newCustomValue);
+      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)]);
+    } else {
+      onChange?.([Math.min(newVal, computedValues[1]), Math.max(newVal, computedValues[1])]);
+    }
+    onChangeCallback([newVal, computedValues[1]]);
+  };
+  const handleMaxChange = (newVal) => {
+    if (possibleValues) {
+      const optionLabel = possibleValues[newVal];
+      const newCustomValue = [customValue ? customValue[0] : computedValues[0], optionLabel];
+      setCustomValue(newCustomValue);
+      onChange?.([Math.min(...newCustomValue), Math.max(...newCustomValue)]);
+    } else {
+      onChange?.([Math.min(newVal, computedValues[0]), Math.max(newVal, computedValues[0])]);
+    }
+    onChangeCallback([computedValues[0], newVal]);
+  };
+  const handleChangeInput = (val, side) => {
+    if (side === "left") {
+      if (valueToShow[1]) {
+        onChangeCallback([Math.min(val, valueToShow[1]), Math.max(val, valueToShow[1])]);
+      } else onChangeCallback([val, valueToShow[1]]);
+    } else if (side === "right") {
+      if (valueToShow[0]) {
+        onChangeCallback([Math.min(val, valueToShow[0]), Math.max(val, valueToShow[0])]);
+      } else onChangeCallback([valueToShow[0], val]);
+    }
+  };
+  const styledValue = (valueNumber, side) => input && (!options || options === true) && !possibleValues ? /* @__PURE__ */ jsx(StyledNumberInput, { value: typeof valueNumber === "string" ? parseFloat(valueNumber) : valueNumber, size: "small", min, max, step, "aria-label": `input-${side}`, controls: false, "data-testid": side ? `slider-input-${side}` : "slider-input", unit: typeof suffix === "string" ? suffix : unit, onChange: (newVal) => {
+    if (newVal !== null) {
+      handleChangeInput(newVal, side);
+    } else if (side === "left") {
+      onChangeCallback([null, computedValues[1]]);
+    } else if (side === "right") {
+      onChangeCallback([computedValues[0], null]);
+    }
+  }, onBlur: (event) => {
+    if (!event.target.value) {
+      if (side === "left") {
+        const index = activeValue("left");
+        if (index === 0) onChangeCallback([min, computedValues[1]]);
+        else onChangeCallback([computedValues[0], max]);
+      }
+      if (side === "right") {
+        const index = activeValue("right");
+        if (index === 0) onChangeCallback([min, computedValues[1]]);
+        else onChangeCallback([computedValues[0], max]);
+      }
+    }
+  } }) : /* @__PURE__ */ jsxs(StyledTextValue, { as: "span", variant: "bodySmall", sentiment: "neutral", placement: direction !== "row" ? "right" : "center", double: true, isColumn: direction === "column", "data-testid": dataTestId ? `${dataTestId}-value-${side}` : `value-${side}`, children: [
+    prefix,
+    valueNumber,
+    suffix ? suffix[side === "left" ? 0 : 1] : unit
+  ] });
+  const minPos = (Math.min(...computedValues) - min) * 100 / (max - min);
+  const maxPos = (Math.max(...computedValues) - min) * 100 / (max - min);
+  const tooltipText = useMemo(() => {
+    if (tooltip === true) {
+      return [Math.min(...computedValues), Math.max(...computedValues)];
+    }
+    if (Array.isArray(tooltip)) return tooltip;
+    if (typeof tooltip === "string") return tooltip;
+    return [null, null];
+  }, [tooltip, computedValues]);
+  const placementTooltip = [(computedValues[0] - min) / (max - min) * (sliderWidth - THUMB_SIZE) + THUMB_SIZE / 2, (computedValues[1] - min) / (max - min) * (sliderWidth - THUMB_SIZE) + THUMB_SIZE / 2];
+  return /* @__PURE__ */ jsxs(Stack, { gap: 1, direction: "column", justifyContent: "left", children: [
+    label ? /* @__PURE__ */ jsx(Stack, { justifyContent: "space-between", direction: "row", children: /* @__PURE__ */ jsx(Label, { direction, input, finalId, label, required }) }) : null,
+    /* @__PURE__ */ jsxs(Stack, { direction, gap: 1, width: "100%", children: [
+      direction === "column" ? /* @__PURE__ */ jsxs(Stack, { justifyContent: "space-between", direction: "row", children: [
+        styledValue(customValue ? customValue[0] : valueToShow[activeValue("left")], "left"),
+        styledValue(customValue ? customValue[1] : valueToShow[activeValue("right")], "right")
+      ] }) : null,
+      direction === "row" ? styledValue(customValue ? customValue[0] : valueToShow[activeValue("left")], "left") : null,
+      /* @__PURE__ */ jsxs(DoubleSliderWrapper, { children: [
+        /* @__PURE__ */ jsxs(StyledTooltip, { text: typeof tooltipText === "string" ? tooltipText : void 0, placement: tooltipPosition, left: (placementTooltip[0] + placementTooltip[1]) / 2, children: [
+          /* @__PURE__ */ jsx(CustomRail, { children: /* @__PURE__ */ jsx(InnerRail, { style: {
+            left: `${minPos}%`,
+            right: `${100 - maxPos}%`
+          }, "data-error": !!error, "aria-disabled": !!disabled }) }),
+          /* @__PURE__ */ jsx(StyledTooltip, { text: Array.isArray(tooltipText) ? tooltipText[0] : void 0, placement: tooltipPosition, left: placementTooltip[0], children: /* @__PURE__ */ jsx(SliderElement, { className, name, id: finalId, disabled: !!disabled, onBlur, onFocus, "data-error": error, "data-direction": direction, type: "range", value: computedValues[0], min, suffix: !!(suffix || unit), "aria-label": ariaLabel ?? name, max, step, "data-testid": dataTestId ? `${dataTestId}-left` : "handle-left", onChange: (event) => {
+            event.preventDefault();
+            handleMinChange(parseFloat(event.target.value));
+          }, themeSlider: theme, ref: refSlider, left: (computedValues[0] - min) * 100 / (max - min) }) }),
+          /* @__PURE__ */ jsx(StyledTooltip, { text: Array.isArray(tooltipText) ? tooltipText[1] : void 0, placement: tooltipPosition, left: placementTooltip[1], children: /* @__PURE__ */ jsx(SliderElement, { className, type: "range", value: computedValues[1], name, disabled: !!disabled, suffix: !!(suffix || unit), id: finalId, onBlur, onFocus, "data-error": error, "data-direction": direction, "aria-label": ariaLabel ?? name, "data-testid": dataTestId ? `${dataTestId}-right` : "handle-right", min, max, step, onChange: (event) => {
+            event.preventDefault();
+            handleMaxChange(parseFloat(event.target.value));
+          }, themeSlider: theme, left: (computedValues[1] - min) * 100 / (max - min) }) })
+        ] }),
+        options || possibleValues ? /* @__PURE__ */ jsx(Options, { ticks, min, max, sliderWidth, unit, value: computedValues, step }) : null
+      ] }),
+      direction === "row" ? styledValue(customValue ? customValue[1] : valueToShow[activeValue("right")], "right") : null
+    ] })
+  ] });
+};
+export {
+  DoubleSlider
+};

package/dist/components/Slider/{Label.cjs → components/Label.cjs}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const jsxRuntime = require("@emotion/react/jsx-runtime");
 const icons = require("@ultraviolet/icons");
-const index = require("../Stack/index.cjs");
-const index$1 = require("../Text/index.cjs");
+const index = require("../../Stack/index.cjs");
+const index$1 = require("../../Text/index.cjs");
 const Label = ({
   direction,
   input,

package/dist/components/Slider/{Label.d.ts → components/Label.d.ts}

@@ -1,2 +1,2 @@
-import type { LabelProps } from './types';
+import type { LabelProps } from '../types';
 export declare const Label: ({ direction, input, finalId, label, required, }: LabelProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/components/Slider/{Label.js → components/Label.js}

@@ -1,7 +1,7 @@
 import { jsxs, jsx } from "@emotion/react/jsx-runtime";
 import { Icon } from "@ultraviolet/icons";
-import { Stack } from "../Stack/index.js";
-import { Text } from "../Text/index.js";
+import { Stack } from "../../Stack/index.js";
+import { Text } from "../../Text/index.js";
 const Label = ({
   direction,
   input,

package/dist/components/Slider/components/Options.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("@emotion/react/jsx-runtime");
+const _styled = require("@emotion/styled/base");
+const index = require("../../Text/index.cjs");
+const constant = require("../constant.cjs");
+const _interopDefaultCompat = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
+const _styled__default = /* @__PURE__ */ _interopDefaultCompat(_styled);
+const DataList = /* @__PURE__ */ _styled__default.default("datalist", process.env.NODE_ENV === "production" ? {
+  target: "e1dbiu721"
+} : {
+  target: "e1dbiu721",
+  label: "DataList"
+})("width:100%;display:flex;position:relative;height:", ({
+  theme
+}) => theme.typography.caption.lineHeight, ";&[data-double='true']{margin-top:", ({
+  theme
+}) => theme.space["5"], ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const Option = /* @__PURE__ */ _styled__default.default("span", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["left", "width"].includes(prop),
+  target: "e1dbiu720"
+} : {
+  shouldForwardProp: (prop) => !["left", "width"].includes(prop),
+  target: "e1dbiu720",
+  label: "Option"
+})("display:flex;left:", ({
+  left
+}) => left, "%;position:absolute;transform:translateX(-50%);&[data-element-left='true']{transform:none;}&[data-element-right='true']{transform:translateX(-100%);}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const Options = ({
+  ticks,
+  min,
+  max,
+  sliderWidth,
+  unit,
+  value,
+  step
+}) => {
+  const optionWidth = (sliderWidth - constant.THUMB_SIZE / 2) * step / (max - min);
+  return /* @__PURE__ */ jsxRuntime.jsx(DataList, { "data-double": Array.isArray(value), children: ticks.map((element, index$1, {
+    length
+  }) => {
+    const left = (index$1 * step - min) * 100 / (max - min);
+    const formatedElement = unit && (index$1 === 0 || index$1 === length - 1) ? (element.label ?? String(element.value)).concat(unit) : element.label ?? String(element.value);
+    const isSelected = typeof value === "number" ? element.value === value : value.includes(element.value);
+    return /* @__PURE__ */ jsxRuntime.jsx(Option, { left, width: optionWidth, "data-value": element.value, "data-element-left": index$1 === 0, "data-element-right": index$1 === length - 1, children: /* @__PURE__ */ jsxRuntime.jsx(index.Text, { as: "p", variant: isSelected ? "captionStrong" : "caption", sentiment: isSelected ? "primary" : "neutral", children: formatedElement }) }, element.value);
+  }) });
+};
+exports.DataList = DataList;
+exports.Option = Option;
+exports.Options = Options;