add all frontend files

node_modules/antd/es/slider/Context.d.ts

@@ -0,0 +1,9 @@
+import type { SliderProps as RcSliderProps } from 'rc-slider';
+import type { DirectionType } from '../config-provider';
+export interface SliderInternalContextProps {
+    handleRender?: RcSliderProps['handleRender'];
+    direction?: DirectionType;
+}
+/** @private Internal context. Do not use in your production. */
+declare const SliderInternalContext: import("react").Context<SliderInternalContextProps>;
+export default SliderInternalContext;

node_modules/antd/es/slider/Context.js

@@ -0,0 +1,4 @@
+import { createContext } from 'react';
+/** @private Internal context. Do not use in your production. */
+const SliderInternalContext = /*#__PURE__*/createContext({});
+export default SliderInternalContext;

node_modules/antd/es/slider/SliderTooltip.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { SliderRef } from 'rc-slider/lib/Slider';
+import type { TooltipProps } from '../tooltip';
+export type SliderTooltipProps = TooltipProps & {
+    draggingDelete?: boolean;
+    value?: number;
+};
+declare const SliderTooltip: React.ForwardRefExoticComponent<SliderTooltipProps & React.RefAttributes<SliderRef>>;
+export default SliderTooltip;

node_modules/antd/es/slider/SliderTooltip.js

@@ -0,0 +1,45 @@
+"use client";
+
+import * as React from 'react';
+import { useRef } from 'react';
+import raf from "rc-util/es/raf";
+import { composeRef } from "rc-util/es/ref";
+import Tooltip from '../tooltip';
+const SliderTooltip = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    open,
+    draggingDelete,
+    value
+  } = props;
+  const innerRef = useRef(null);
+  const mergedOpen = open && !draggingDelete;
+  const rafRef = useRef(null);
+  function cancelKeepAlign() {
+    raf.cancel(rafRef.current);
+    rafRef.current = null;
+  }
+  function keepAlign() {
+    rafRef.current = raf(() => {
+      var _a;
+      (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.forceAlign();
+      rafRef.current = null;
+    });
+  }
+  React.useEffect(() => {
+    if (mergedOpen) {
+      keepAlign();
+    } else {
+      cancelKeepAlign();
+    }
+    return cancelKeepAlign;
+  }, [mergedOpen, props.title, value]);
+  return /*#__PURE__*/React.createElement(Tooltip, Object.assign({
+    ref: composeRef(innerRef, ref)
+  }, props, {
+    open: mergedOpen
+  }));
+});
+if (process.env.NODE_ENV !== 'production') {
+  SliderTooltip.displayName = 'SliderTooltip';
+}
+export default SliderTooltip;

node_modules/antd/es/slider/index.d.ts

@@ -0,0 +1,109 @@
+import React from 'react';
+import type { SliderProps as RcSliderProps } from 'rc-slider';
+import type { SliderRef } from 'rc-slider/lib/Slider';
+import type { GetProp } from '../_util/type';
+import type { AbstractTooltipProps, TooltipPlacement } from '../tooltip';
+export type SliderMarks = RcSliderProps['marks'];
+export type SemanticName = 'root' | 'tracks' | 'track' | 'rail' | 'handle';
+export type SliderClassNames = Partial<Record<SemanticName, string>>;
+export type SliderStyles = Partial<Record<SemanticName, React.CSSProperties>>;
+export interface SliderProps extends RcSliderProps {
+    classNames?: SliderClassNames;
+    styles?: SliderStyles;
+}
+interface HandleGeneratorInfo {
+    value?: number;
+    dragging?: boolean;
+    index: number;
+}
+export type HandleGeneratorFn = (config: {
+    tooltipPrefixCls?: string;
+    prefixCls?: string;
+    info: HandleGeneratorInfo;
+}) => React.ReactElement;
+export type Formatter = ((value?: number) => React.ReactNode) | null;
+export interface SliderTooltipProps extends AbstractTooltipProps {
+    prefixCls?: string;
+    open?: boolean;
+    placement?: TooltipPlacement;
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    formatter?: Formatter;
+    autoAdjustOverflow?: boolean;
+}
+export interface SliderBaseProps {
+    prefixCls?: string;
+    reverse?: boolean;
+    min?: number;
+    max?: number;
+    step?: null | number;
+    marks?: SliderMarks;
+    dots?: boolean;
+    included?: boolean;
+    disabled?: boolean;
+    keyboard?: boolean;
+    vertical?: boolean;
+    className?: string;
+    rootClassName?: string;
+    id?: string;
+    style?: React.CSSProperties;
+    tooltip?: SliderTooltipProps;
+    autoFocus?: boolean;
+    styles?: SliderProps['styles'];
+    classNames?: SliderProps['classNames'];
+    onFocus?: React.FocusEventHandler<HTMLDivElement>;
+    onBlur?: React.FocusEventHandler<HTMLDivElement>;
+    /** @deprecated `tooltipPrefixCls` is deprecated. Please use `tooltip.prefixCls` instead. */
+    tooltipPrefixCls?: string;
+    /** @deprecated `tipFormatter` is deprecated. Please use `tooltip.formatter` instead. */
+    tipFormatter?: Formatter;
+    /** @deprecated `tooltipVisible` is deprecated. Please use `tooltip.open` instead. */
+    tooltipVisible?: boolean;
+    /**
+     * @deprecated `getTooltipPopupContainer` is deprecated. Please use `tooltip.getPopupContainer`
+     *   instead.
+     */
+    getTooltipPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    /** @deprecated `tooltipPlacement` is deprecated. Please use `tooltip.placement` instead. */
+    tooltipPlacement?: TooltipPlacement;
+    tabIndex?: SliderProps['tabIndex'];
+    ariaLabelForHandle?: SliderProps['ariaLabelForHandle'];
+    ariaLabelledByForHandle?: SliderProps['ariaLabelledByForHandle'];
+    ariaRequired?: SliderProps['ariaRequired'];
+    ariaValueTextFormatterForHandle?: SliderProps['ariaValueTextFormatterForHandle'];
+}
+export interface SliderSingleProps extends SliderBaseProps {
+    range?: false;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    /** @deprecated Please use `onChangeComplete` instead */
+    onAfterChange?: (value: number) => void;
+    onChangeComplete?: (value: number) => void;
+    /** @deprecated Please use `styles.handle` instead */
+    handleStyle?: React.CSSProperties;
+    /** @deprecated Please use `styles.track` instead */
+    trackStyle?: React.CSSProperties;
+    /** @deprecated Please use `styles.rail` instead */
+    railStyle?: React.CSSProperties;
+}
+export interface SliderRangeProps extends SliderBaseProps {
+    range: true | SliderRange;
+    value?: number[];
+    defaultValue?: number[];
+    onChange?: (value: number[]) => void;
+    /** @deprecated Please use `onChangeComplete` instead */
+    onAfterChange?: (value: number[]) => void;
+    onChangeComplete?: (value: number[]) => void;
+    /** @deprecated Please use `styles.handle` instead */
+    handleStyle?: React.CSSProperties[];
+    /** @deprecated Please use `styles.track` instead */
+    trackStyle?: React.CSSProperties[];
+    /** @deprecated Please use `styles.rail` instead */
+    railStyle?: React.CSSProperties;
+}
+type SliderRange = Exclude<GetProp<RcSliderProps, 'range'>, boolean>;
+export type Opens = {
+    [index: number]: boolean;
+};
+declare const Slider: React.ForwardRefExoticComponent<(SliderSingleProps | SliderRangeProps) & React.RefAttributes<SliderRef>>;
+export default Slider;

node_modules/antd/es/slider/index.js

@@ -0,0 +1,251 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import React from 'react';
+import classNames from 'classnames';
+import RcSlider from 'rc-slider';
+import raf from "rc-util/es/raf";
+import { devUseWarning } from '../_util/warning';
+import DisabledContext from '../config-provider/DisabledContext';
+import SliderInternalContext from './Context';
+import SliderTooltip from './SliderTooltip';
+import useStyle from './style';
+import useRafLock from './useRafLock';
+import { useComponentConfig } from '../config-provider/context';
+function getTipFormatter(tipFormatter, legacyTipFormatter) {
+  if (tipFormatter || tipFormatter === null) {
+    return tipFormatter;
+  }
+  if (legacyTipFormatter || legacyTipFormatter === null) {
+    return legacyTipFormatter;
+  }
+  return val => typeof val === 'number' ? val.toString() : '';
+}
+const Slider = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+      prefixCls: customizePrefixCls,
+      range,
+      className,
+      rootClassName,
+      style,
+      disabled,
+      // Deprecated Props
+      tooltipPrefixCls: legacyTooltipPrefixCls,
+      tipFormatter: legacyTipFormatter,
+      tooltipVisible: legacyTooltipVisible,
+      getTooltipPopupContainer: legacyGetTooltipPopupContainer,
+      tooltipPlacement: legacyTooltipPlacement,
+      tooltip = {},
+      onChangeComplete,
+      classNames: sliderClassNames,
+      styles
+    } = props,
+    restProps = __rest(props, ["prefixCls", "range", "className", "rootClassName", "style", "disabled", "tooltipPrefixCls", "tipFormatter", "tooltipVisible", "getTooltipPopupContainer", "tooltipPlacement", "tooltip", "onChangeComplete", "classNames", "styles"]);
+  const {
+    vertical
+  } = props;
+  const {
+    getPrefixCls,
+    direction: contextDirection,
+    className: contextClassName,
+    style: contextStyle,
+    classNames: contextClassNames,
+    styles: contextStyles,
+    getPopupContainer
+  } = useComponentConfig('slider');
+  const contextDisabled = React.useContext(DisabledContext);
+  const mergedDisabled = disabled !== null && disabled !== void 0 ? disabled : contextDisabled;
+  // ============================= Context ==============================
+  const {
+    handleRender: contextHandleRender,
+    direction: internalContextDirection
+  } = React.useContext(SliderInternalContext);
+  const mergedDirection = internalContextDirection || contextDirection;
+  const isRTL = mergedDirection === 'rtl';
+  // =============================== Open ===============================
+  const [hoverOpen, setHoverOpen] = useRafLock();
+  const [focusOpen, setFocusOpen] = useRafLock();
+  const tooltipProps = Object.assign({}, tooltip);
+  const {
+    open: tooltipOpen,
+    placement: tooltipPlacement,
+    getPopupContainer: getTooltipPopupContainer,
+    prefixCls: customizeTooltipPrefixCls,
+    formatter: tipFormatter
+  } = tooltipProps;
+  const lockOpen = tooltipOpen !== null && tooltipOpen !== void 0 ? tooltipOpen : legacyTooltipVisible;
+  const activeOpen = (hoverOpen || focusOpen) && lockOpen !== false;
+  const mergedTipFormatter = getTipFormatter(tipFormatter, legacyTipFormatter);
+  // ============================= Change ==============================
+  const [dragging, setDragging] = useRafLock();
+  const onInternalChangeComplete = nextValues => {
+    onChangeComplete === null || onChangeComplete === void 0 ? void 0 : onChangeComplete(nextValues);
+    setDragging(false);
+  };
+  // ============================ Placement ============================
+  const getTooltipPlacement = (placement, vert) => {
+    if (placement) {
+      return placement;
+    }
+    if (!vert) {
+      return 'top';
+    }
+    return isRTL ? 'left' : 'right';
+  };
+  // ============================== Style ===============================
+  const prefixCls = getPrefixCls('slider', customizePrefixCls);
+  const [wrapCSSVar, hashId, cssVarCls] = useStyle(prefixCls);
+  const rootClassNames = classNames(className, contextClassName, contextClassNames.root, sliderClassNames === null || sliderClassNames === void 0 ? void 0 : sliderClassNames.root, rootClassName, {
+    [`${prefixCls}-rtl`]: isRTL,
+    [`${prefixCls}-lock`]: dragging
+  }, hashId, cssVarCls);
+  // make reverse default on rtl direction
+  if (isRTL && !restProps.vertical) {
+    restProps.reverse = !restProps.reverse;
+  }
+  // ============================= Warning ==============================
+  // Warning for deprecated usage
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = devUseWarning('Slider');
+    [['tooltipPrefixCls', 'prefixCls'], ['getTooltipPopupContainer', 'getPopupContainer'], ['tipFormatter', 'formatter'], ['tooltipPlacement', 'placement'], ['tooltipVisible', 'open']].forEach(([deprecatedName, newName]) => {
+      warning.deprecated(!(deprecatedName in props), deprecatedName, `tooltip.${newName}`);
+    });
+  }
+  // ============================== Handle ==============================
+  React.useEffect(() => {
+    const onMouseUp = () => {
+      // Delay for 1 frame to make the click to enable hide tooltip
+      // even when the handle is focused
+      raf(() => {
+        setFocusOpen(false);
+      }, 1);
+    };
+    document.addEventListener('mouseup', onMouseUp);
+    return () => {
+      document.removeEventListener('mouseup', onMouseUp);
+    };
+  }, []);
+  const useActiveTooltipHandle = range && !lockOpen;
+  const handleRender = contextHandleRender || ((node, info) => {
+    const {
+      index
+    } = info;
+    const nodeProps = node.props;
+    function proxyEvent(eventName, event, triggerRestPropsEvent) {
+      var _a, _b, _c, _d;
+      if (triggerRestPropsEvent) {
+        (_b = (_a = restProps)[eventName]) === null || _b === void 0 ? void 0 : _b.call(_a, event);
+      }
+      (_d = (_c = nodeProps)[eventName]) === null || _d === void 0 ? void 0 : _d.call(_c, event);
+    }
+    const passedProps = Object.assign(Object.assign({}, nodeProps), {
+      onMouseEnter: e => {
+        setHoverOpen(true);
+        proxyEvent('onMouseEnter', e);
+      },
+      onMouseLeave: e => {
+        setHoverOpen(false);
+        proxyEvent('onMouseLeave', e);
+      },
+      onMouseDown: e => {
+        setFocusOpen(true);
+        setDragging(true);
+        proxyEvent('onMouseDown', e);
+      },
+      onFocus: e => {
+        var _a;
+        setFocusOpen(true);
+        (_a = restProps.onFocus) === null || _a === void 0 ? void 0 : _a.call(restProps, e);
+        proxyEvent('onFocus', e, true);
+      },
+      onBlur: e => {
+        var _a;
+        setFocusOpen(false);
+        (_a = restProps.onBlur) === null || _a === void 0 ? void 0 : _a.call(restProps, e);
+        proxyEvent('onBlur', e, true);
+      }
+    });
+    const cloneNode = /*#__PURE__*/React.cloneElement(node, passedProps);
+    const open = (!!lockOpen || activeOpen) && mergedTipFormatter !== null;
+    // Wrap on handle with Tooltip when is single mode or multiple with all show tooltip
+    if (!useActiveTooltipHandle) {
+      return /*#__PURE__*/React.createElement(SliderTooltip, Object.assign({}, tooltipProps, {
+        prefixCls: getPrefixCls('tooltip', customizeTooltipPrefixCls !== null && customizeTooltipPrefixCls !== void 0 ? customizeTooltipPrefixCls : legacyTooltipPrefixCls),
+        title: mergedTipFormatter ? mergedTipFormatter(info.value) : '',
+        value: info.value,
+        open: open,
+        placement: getTooltipPlacement(tooltipPlacement !== null && tooltipPlacement !== void 0 ? tooltipPlacement : legacyTooltipPlacement, vertical),
+        key: index,
+        classNames: {
+          root: `${prefixCls}-tooltip`
+        },
+        getPopupContainer: getTooltipPopupContainer || legacyGetTooltipPopupContainer || getPopupContainer
+      }), cloneNode);
+    }
+    return cloneNode;
+  });
+  // ========================== Active Handle ===========================
+  const activeHandleRender = useActiveTooltipHandle ? (handle, info) => {
+    const cloneNode = /*#__PURE__*/React.cloneElement(handle, {
+      style: Object.assign(Object.assign({}, handle.props.style), {
+        visibility: 'hidden'
+      })
+    });
+    return /*#__PURE__*/React.createElement(SliderTooltip, Object.assign({}, tooltipProps, {
+      prefixCls: getPrefixCls('tooltip', customizeTooltipPrefixCls !== null && customizeTooltipPrefixCls !== void 0 ? customizeTooltipPrefixCls : legacyTooltipPrefixCls),
+      title: mergedTipFormatter ? mergedTipFormatter(info.value) : '',
+      open: mergedTipFormatter !== null && activeOpen,
+      placement: getTooltipPlacement(tooltipPlacement !== null && tooltipPlacement !== void 0 ? tooltipPlacement : legacyTooltipPlacement, vertical),
+      key: "tooltip",
+      classNames: {
+        root: `${prefixCls}-tooltip`
+      },
+      getPopupContainer: getTooltipPopupContainer || legacyGetTooltipPopupContainer || getPopupContainer,
+      draggingDelete: info.draggingDelete
+    }), cloneNode);
+  } : undefined;
+  // ============================== Render ==============================
+  const rootStyle = Object.assign(Object.assign(Object.assign(Object.assign({}, contextStyles.root), contextStyle), styles === null || styles === void 0 ? void 0 : styles.root), style);
+  const mergedTracks = Object.assign(Object.assign({}, contextStyles.tracks), styles === null || styles === void 0 ? void 0 : styles.tracks);
+  const mergedTracksClassNames = classNames(contextClassNames.tracks, sliderClassNames === null || sliderClassNames === void 0 ? void 0 : sliderClassNames.tracks);
+  return wrapCSSVar(
+  /*#__PURE__*/
+  // @ts-ignore
+  React.createElement(RcSlider, Object.assign({}, restProps, {
+    classNames: Object.assign({
+      handle: classNames(contextClassNames.handle, sliderClassNames === null || sliderClassNames === void 0 ? void 0 : sliderClassNames.handle),
+      rail: classNames(contextClassNames.rail, sliderClassNames === null || sliderClassNames === void 0 ? void 0 : sliderClassNames.rail),
+      track: classNames(contextClassNames.track, sliderClassNames === null || sliderClassNames === void 0 ? void 0 : sliderClassNames.track)
+    }, mergedTracksClassNames ? {
+      tracks: mergedTracksClassNames
+    } : {}),
+    styles: Object.assign({
+      handle: Object.assign(Object.assign({}, contextStyles.handle), styles === null || styles === void 0 ? void 0 : styles.handle),
+      rail: Object.assign(Object.assign({}, contextStyles.rail), styles === null || styles === void 0 ? void 0 : styles.rail),
+      track: Object.assign(Object.assign({}, contextStyles.track), styles === null || styles === void 0 ? void 0 : styles.track)
+    }, Object.keys(mergedTracks).length ? {
+      tracks: mergedTracks
+    } : {}),
+    step: restProps.step,
+    range: range,
+    className: rootClassNames,
+    style: rootStyle,
+    disabled: mergedDisabled,
+    ref: ref,
+    prefixCls: prefixCls,
+    handleRender: handleRender,
+    activeHandleRender: activeHandleRender,
+    onChangeComplete: onInternalChangeComplete
+  })));
+});
+if (process.env.NODE_ENV !== 'production') {
+  Slider.displayName = 'Slider';
+}
+export default Slider;

node_modules/antd/es/slider/style/index.d.ts

@@ -0,0 +1,97 @@
+import type * as React from 'react';
+import type { GetDefaultToken } from '../../theme/internal';
+export interface ComponentToken {
+    /**
+     * @desc 滑动输入高度
+     * @descEN Height of slider
+     */
+    controlSize: number;
+    /**
+     * @desc 轨道高度
+     * @descEN Height of rail
+     */
+    railSize: number;
+    /**
+     * @desc 滑块尺寸
+     * @descEN Size of handle
+     */
+    handleSize: number;
+    /**
+     * @desc 滑块尺寸（悬浮态）
+     * @descEN Size of handle when hover
+     */
+    handleSizeHover: number;
+    /**
+     * @desc 滑块边框宽度
+     * @descEN Border width of handle
+     */
+    handleLineWidth: number | string;
+    /**
+     * @desc 滑块边框宽度（悬浮态）
+     * @descEN Border width of handle when hover
+     */
+    handleLineWidthHover: number | string;
+    /**
+     * @desc 滑块圆点尺寸
+     * @descEN Size of dot
+     */
+    dotSize: number;
+    /**
+     * @desc 轨道背景色
+     * @descEN Background color of rail
+     */
+    railBg: string;
+    /**
+     * @desc 轨道背景色（悬浮态）
+     * @descEN Background color of rail when hover
+     */
+    railHoverBg: string;
+    /**
+     * @desc 轨道已覆盖部分背景色
+     * @descEN Background color of track
+     */
+    trackBg: string;
+    /**
+     * @desc 轨道已覆盖部分背景色（悬浮态）
+     * @descEN Background color of track when hover
+     */
+    trackHoverBg: string;
+    /**
+     * @desc 滑块颜色
+     * @descEN Color of handle
+     */
+    handleColor: string;
+    /**
+     * @desc 滑块激活态边框色
+     * @descEN Border color of handle when active
+     */
+    handleActiveColor: string;
+    /**
+     * @desc 滑块激活态外框色
+     * @descEN Outline color of handle when active
+     */
+    handleActiveOutlineColor: string;
+    /**
+     * @desc 滑块禁用颜色
+     * @descEN Color of handle when disabled
+     */
+    handleColorDisabled: string;
+    /**
+     * @desc 圆点边框颜色
+     * @descEN Border color of dot
+     */
+    dotBorderColor: string;
+    /**
+     * @desc 圆点激活态边框颜色
+     * @descEN Border color of dot when active
+     */
+    dotActiveBorderColor: string;
+    /**
+     * @desc 轨道禁用态背景色
+     * @descEN Background color of track when disabled
+     */
+    trackBgDisabled: string;
+}
+export declare const prepareComponentToken: GetDefaultToken<'Slider'>;
+declare const _default: (prefixCls: string, rootCls?: string) => readonly [(node: React.ReactElement) => React.ReactElement, string, string];
+export default _default;

node_modules/antd/es/slider/style/index.js

@@ -0,0 +1,331 @@
+import { unit } from '@ant-design/cssinjs';
+import { FastColor } from '@ant-design/fast-color';
+import { resetComponent } from '../../style';
+import { genStyleHooks, mergeToken } from '../../theme/internal';
+// =============================== Base ===============================
+const genBaseStyle = token => {
+  const {
+    componentCls,
+    antCls,
+    controlSize,
+    dotSize,
+    marginFull,
+    marginPart,
+    colorFillContentHover,
+    handleColorDisabled,
+    calc,
+    handleSize,
+    handleSizeHover,
+    handleActiveColor,
+    handleActiveOutlineColor,
+    handleLineWidth,
+    handleLineWidthHover,
+    motionDurationMid
+  } = token;
+  return {
+    [componentCls]: Object.assign(Object.assign({}, resetComponent(token)), {
+      position: 'relative',
+      height: controlSize,
+      margin: `${unit(marginPart)} ${unit(marginFull)}`,
+      padding: 0,
+      cursor: 'pointer',
+      touchAction: 'none',
+      '&-vertical': {
+        margin: `${unit(marginFull)} ${unit(marginPart)}`
+      },
+      [`${componentCls}-rail`]: {
+        position: 'absolute',
+        backgroundColor: token.railBg,
+        borderRadius: token.borderRadiusXS,
+        transition: `background-color ${motionDurationMid}`
+      },
+      [`${componentCls}-track,${componentCls}-tracks`]: {
+        position: 'absolute',
+        transition: `background-color ${motionDurationMid}`
+      },
+      [`${componentCls}-track`]: {
+        backgroundColor: token.trackBg,
+        borderRadius: token.borderRadiusXS
+      },
+      [`${componentCls}-track-draggable`]: {
+        boxSizing: 'content-box',
+        backgroundClip: 'content-box',
+        border: 'solid rgba(0,0,0,0)'
+      },
+      '&:hover': {
+        [`${componentCls}-rail`]: {
+          backgroundColor: token.railHoverBg
+        },
+        [`${componentCls}-track`]: {
+          backgroundColor: token.trackHoverBg
+        },
+        [`${componentCls}-dot`]: {
+          borderColor: colorFillContentHover
+        },
+        [`${componentCls}-handle::after`]: {
+          boxShadow: `0 0 0 ${unit(handleLineWidth)} ${token.colorPrimaryBorderHover}`
+        },
+        [`${componentCls}-dot-active`]: {
+          borderColor: token.dotActiveBorderColor
+        }
+      },
+      [`${componentCls}-handle`]: {
+        position: 'absolute',
+        width: handleSize,
+        height: handleSize,
+        outline: 'none',
+        userSelect: 'none',
+        // Dragging status
+        '&-dragging-delete': {
+          opacity: 0
+        },
+        // 扩大选区
+        '&::before': {
+          content: '""',
+          position: 'absolute',
+          insetInlineStart: calc(handleLineWidth).mul(-1).equal(),
+          insetBlockStart: calc(handleLineWidth).mul(-1).equal(),
+          width: calc(handleSize).add(calc(handleLineWidth).mul(2)).equal(),
+          height: calc(handleSize).add(calc(handleLineWidth).mul(2)).equal(),
+          backgroundColor: 'transparent'
+        },
+        '&::after': {
+          content: '""',
+          position: 'absolute',
+          insetBlockStart: 0,
+          insetInlineStart: 0,
+          width: handleSize,
+          height: handleSize,
+          backgroundColor: token.colorBgElevated,
+          boxShadow: `0 0 0 ${unit(handleLineWidth)} ${token.handleColor}`,
+          outline: `0px solid transparent`,
+          borderRadius: '50%',
+          cursor: 'pointer',
+          transition: `
+            inset-inline-start ${motionDurationMid},
+            inset-block-start ${motionDurationMid},
+            width ${motionDurationMid},
+            height ${motionDurationMid},
+            box-shadow ${motionDurationMid},
+            outline ${motionDurationMid}
+          `
+        },
+        '&:hover, &:active, &:focus': {
+          '&::before': {
+            insetInlineStart: calc(handleSizeHover).sub(handleSize).div(2).add(handleLineWidthHover).mul(-1).equal(),
+            insetBlockStart: calc(handleSizeHover).sub(handleSize).div(2).add(handleLineWidthHover).mul(-1).equal(),
+            width: calc(handleSizeHover).add(calc(handleLineWidthHover).mul(2)).equal(),
+            height: calc(handleSizeHover).add(calc(handleLineWidthHover).mul(2)).equal()
+          },
+          '&::after': {
+            boxShadow: `0 0 0 ${unit(handleLineWidthHover)} ${handleActiveColor}`,
+            outline: `6px solid ${handleActiveOutlineColor}`,
+            width: handleSizeHover,
+            height: handleSizeHover,
+            insetInlineStart: token.calc(handleSize).sub(handleSizeHover).div(2).equal(),
+            insetBlockStart: token.calc(handleSize).sub(handleSizeHover).div(2).equal()
+          }
+        }
+      },
+      [`&-lock ${componentCls}-handle`]: {
+        '&::before, &::after': {
+          transition: 'none'
+        }
+      },
+      [`${componentCls}-mark`]: {
+        position: 'absolute',
+        fontSize: token.fontSize
+      },
+      [`${componentCls}-mark-text`]: {
+        position: 'absolute',
+        display: 'inline-block',
+        color: token.colorTextDescription,
+        textAlign: 'center',
+        wordBreak: 'keep-all',
+        cursor: 'pointer',
+        userSelect: 'none',
+        '&-active': {
+          color: token.colorText
+        }
+      },
+      [`${componentCls}-step`]: {
+        position: 'absolute',
+        background: 'transparent',
+        pointerEvents: 'none'
+      },
+      [`${componentCls}-dot`]: {
+        position: 'absolute',
+        width: dotSize,
+        height: dotSize,
+        backgroundColor: token.colorBgElevated,
+        border: `${unit(handleLineWidth)} solid ${token.dotBorderColor}`,
+        borderRadius: '50%',
+        cursor: 'pointer',
+        transition: `border-color ${token.motionDurationSlow}`,
+        pointerEvents: 'auto',
+        '&-active': {
+          borderColor: token.dotActiveBorderColor
+        }
+      },
+      [`&${componentCls}-disabled`]: {
+        cursor: 'not-allowed',
+        [`${componentCls}-rail`]: {
+          backgroundColor: `${token.railBg} !important`
+        },
+        [`${componentCls}-track`]: {
+          backgroundColor: `${token.trackBgDisabled} !important`
+        },
+        [`
+          ${componentCls}-dot
+        `]: {
+          backgroundColor: token.colorBgElevated,
+          borderColor: token.trackBgDisabled,
+          boxShadow: 'none',
+          cursor: 'not-allowed'
+        },
+        [`${componentCls}-handle::after`]: {
+          backgroundColor: token.colorBgElevated,
+          cursor: 'not-allowed',
+          width: handleSize,
+          height: handleSize,
+          boxShadow: `0 0 0 ${unit(handleLineWidth)} ${handleColorDisabled}`,
+          insetInlineStart: 0,
+          insetBlockStart: 0
+        },
+        [`
+          ${componentCls}-mark-text,
+          ${componentCls}-dot
+        `]: {
+          cursor: `not-allowed !important`
+        }
+      },
+      [`&-tooltip ${antCls}-tooltip-inner`]: {
+        minWidth: 'unset'
+      }
+    })
+  };
+};
+// ============================ Horizontal ============================
+const genDirectionStyle = (token, horizontal) => {
+  const {
+    componentCls,
+    railSize,
+    handleSize,
+    dotSize,
+    marginFull,
+    calc
+  } = token;
+  const railPadding = horizontal ? 'paddingBlock' : 'paddingInline';
+  const full = horizontal ? 'width' : 'height';
+  const part = horizontal ? 'height' : 'width';
+  const handlePos = horizontal ? 'insetBlockStart' : 'insetInlineStart';
+  const markInset = horizontal ? 'top' : 'insetInlineStart';
+  const handlePosSize = calc(railSize).mul(3).sub(handleSize).div(2).equal();
+  const draggableBorderSize = calc(handleSize).sub(railSize).div(2).equal();
+  const draggableBorder = horizontal ? {
+    borderWidth: `${unit(draggableBorderSize)} 0`,
+    transform: `translateY(${unit(calc(draggableBorderSize).mul(-1).equal())})`
+  } : {
+    borderWidth: `0 ${unit(draggableBorderSize)}`,
+    transform: `translateX(${unit(token.calc(draggableBorderSize).mul(-1).equal())})`
+  };
+  return {
+    [railPadding]: railSize,
+    [part]: calc(railSize).mul(3).equal(),
+    [`${componentCls}-rail`]: {
+      [full]: '100%',
+      [part]: railSize
+    },
+    [`${componentCls}-track,${componentCls}-tracks`]: {
+      [part]: railSize
+    },
+    [`${componentCls}-track-draggable`]: Object.assign({}, draggableBorder),
+    [`${componentCls}-handle`]: {
+      [handlePos]: handlePosSize
+    },
+    [`${componentCls}-mark`]: {
+      // Reset all
+      insetInlineStart: 0,
+      top: 0,
+      // https://github.com/ant-design/ant-design/issues/43731
+      [markInset]: calc(railSize).mul(3).add(horizontal ? 0 : marginFull).equal(),
+      [full]: '100%'
+    },
+    [`${componentCls}-step`]: {
+      // Reset all
+      insetInlineStart: 0,
+      top: 0,
+      [markInset]: railSize,
+      [full]: '100%',
+      [part]: railSize
+    },
+    [`${componentCls}-dot`]: {
+      position: 'absolute',
+      [handlePos]: calc(railSize).sub(dotSize).div(2).equal()
+    }
+  };
+};
+// ============================ Horizontal ============================
+const genHorizontalStyle = token => {
+  const {
+    componentCls,
+    marginPartWithMark
+  } = token;
+  return {
+    [`${componentCls}-horizontal`]: Object.assign(Object.assign({}, genDirectionStyle(token, true)), {
+      [`&${componentCls}-with-marks`]: {
+        marginBottom: marginPartWithMark
+      }
+    })
+  };
+};
+// ============================= Vertical =============================
+const genVerticalStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [`${componentCls}-vertical`]: Object.assign(Object.assign({}, genDirectionStyle(token, false)), {
+      height: '100%'
+    })
+  };
+};
+// ============================== Export ==============================
+export const prepareComponentToken = token => {
+  // Handle line width is always width-er 1px
+  const increaseHandleWidth = 1;
+  const controlSize = token.controlHeightLG / 4;
+  const controlSizeHover = token.controlHeightSM / 2;
+  const handleLineWidth = token.lineWidth + increaseHandleWidth;
+  const handleLineWidthHover = token.lineWidth + increaseHandleWidth * 1.5;
+  const handleActiveColor = token.colorPrimary;
+  const handleActiveOutlineColor = new FastColor(handleActiveColor).setA(0.2).toRgbString();
+  return {
+    controlSize,
+    railSize: 4,
+    handleSize: controlSize,
+    handleSizeHover: controlSizeHover,
+    dotSize: 8,
+    handleLineWidth,
+    handleLineWidthHover,
+    railBg: token.colorFillTertiary,
+    railHoverBg: token.colorFillSecondary,
+    trackBg: token.colorPrimaryBorder,
+    trackHoverBg: token.colorPrimaryBorderHover,
+    handleColor: token.colorPrimaryBorder,
+    handleActiveColor,
+    handleActiveOutlineColor,
+    handleColorDisabled: new FastColor(token.colorTextDisabled).onBackground(token.colorBgContainer).toHexString(),
+    dotBorderColor: token.colorBorderSecondary,
+    dotActiveBorderColor: token.colorPrimaryBorder,
+    trackBgDisabled: token.colorBgContainerDisabled
+  };
+};
+export default genStyleHooks('Slider', token => {
+  const sliderToken = mergeToken(token, {
+    marginPart: token.calc(token.controlHeight).sub(token.controlSize).div(2).equal(),
+    marginFull: token.calc(token.controlSize).div(2).equal(),
+    marginPartWithMark: token.calc(token.controlHeightLG).sub(token.controlSize).equal()
+  });
+  return [genBaseStyle(sliderToken), genHorizontalStyle(sliderToken), genVerticalStyle(sliderToken)];
+}, prepareComponentToken);

node_modules/antd/es/slider/useRafLock.d.ts

@@ -0,0 +1 @@
+export default function useRafLock(): [state: boolean, setState: (nextState: boolean) => void];

node_modules/antd/es/slider/useRafLock.js

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import raf from "rc-util/es/raf";
+export default function useRafLock() {
+  const [state, setState] = React.useState(false);
+  const rafRef = React.useRef(null);
+  const cleanup = () => {
+    raf.cancel(rafRef.current);
+  };
+  const setDelayState = nextState => {
+    cleanup();
+    if (nextState) {
+      setState(nextState);
+    } else {
+      rafRef.current = raf(() => {
+        setState(nextState);
+      });
+    }
+  };
+  React.useEffect(() => cleanup, []);
+  return [state, setDelayState];
+}