Latest updates from IceHrmPro

web/node_modules/antd/lib/slider/SliderTooltip.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { TooltipProps } from '../tooltip';
+export default function SliderTooltip(props: TooltipProps): JSX.Element;

web/node_modules/antd/lib/slider/SliderTooltip.js

@@ -0,0 +1,59 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = SliderTooltip;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _tooltip = _interopRequireDefault(require("../tooltip"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function SliderTooltip(props) {
+  var visible = props.visible;
+  var tooltipRef = React.useRef(null);
+  var rafRef = React.useRef(null);
+
+  function cancelKeepAlign() {
+    window.cancelAnimationFrame(rafRef.current);
+    rafRef.current = null;
+  }
+
+  function keepAlign() {
+    if (rafRef.current !== null) {
+      return;
+    }
+
+    rafRef.current = window.requestAnimationFrame(function () {
+      if (tooltipRef.current && tooltipRef.current.tooltip) {
+        tooltipRef.current.tooltip.forcePopupAlign();
+      }
+
+      rafRef.current = null;
+      keepAlign();
+    });
+  }
+
+  React.useEffect(function () {
+    if (visible) {
+      keepAlign();
+    } else {
+      cancelKeepAlign();
+    }
+
+    return cancelKeepAlign;
+  }, [visible]);
+  return /*#__PURE__*/React.createElement(_tooltip["default"], _extends({
+    ref: tooltipRef
+  }, props));
+}

web/node_modules/antd/lib/slider/index.d.ts

@@ -0,0 +1,66 @@
+import * as React from 'react';
+import { TooltipPlacement } from '../tooltip';
+import { ConfigConsumerProps } from '../config-provider';
+export interface SliderMarks {
+    [key: number]: React.ReactNode | {
+        style: React.CSSProperties;
+        label: React.ReactNode;
+    };
+}
+export declare type SliderValue = number | [number, number];
+interface HandleGeneratorInfo {
+    value: number;
+    dragging: boolean;
+    index: number;
+    rest: any[];
+}
+export declare type HandleGeneratorFn = (config: {
+    tooltipPrefixCls?: string;
+    prefixCls?: string;
+    info: HandleGeneratorInfo;
+}) => React.ReactNode;
+export interface SliderProps {
+    prefixCls?: string;
+    tooltipPrefixCls?: string;
+    range?: boolean;
+    reverse?: boolean;
+    min?: number;
+    max?: number;
+    step?: number | null;
+    marks?: SliderMarks;
+    dots?: boolean;
+    value?: SliderValue;
+    defaultValue?: SliderValue;
+    included?: boolean;
+    disabled?: boolean;
+    vertical?: boolean;
+    onChange?: (value: SliderValue) => void;
+    onAfterChange?: (value: SliderValue) => void;
+    tipFormatter?: null | ((value: number) => React.ReactNode);
+    className?: string;
+    id?: string;
+    style?: React.CSSProperties;
+    tooltipVisible?: boolean;
+    tooltipPlacement?: TooltipPlacement;
+    getTooltipPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+}
+export interface SliderState {
+    visibles: {
+        [index: number]: boolean;
+    };
+}
+export default class Slider extends React.Component<SliderProps, SliderState> {
+    static defaultProps: {
+        tipFormatter(value: number): string;
+    };
+    rcSlider: any;
+    constructor(props: SliderProps);
+    toggleTooltipVisible: (index: number, visible: boolean) => void;
+    handleWithTooltip: HandleGeneratorFn;
+    saveSlider: (node: any) => void;
+    focus(): void;
+    blur(): void;
+    renderSlider: ({ getPrefixCls, direction }: ConfigConsumerProps) => JSX.Element;
+    render(): JSX.Element;
+}
+export {};

web/node_modules/antd/lib/slider/index.js

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Slider = _interopRequireDefault(require("rc-slider/lib/Slider"));
+
+var _Range = _interopRequireDefault(require("rc-slider/lib/Range"));
+
+var _Handle = _interopRequireDefault(require("rc-slider/lib/Handle"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _SliderTooltip = _interopRequireDefault(require("./SliderTooltip"));
+
+var _configProvider = require("../config-provider");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var __rest = void 0 && (void 0).__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;
+};
+
+var Slider = /*#__PURE__*/function (_React$Component) {
+  _inherits(Slider, _React$Component);
+
+  var _super = _createSuper(Slider);
+
+  function Slider(props) {
+    var _this;
+
+    _classCallCheck(this, Slider);
+
+    _this = _super.call(this, props);
+
+    _this.toggleTooltipVisible = function (index, visible) {
+      _this.setState(function (_ref) {
+        var visibles = _ref.visibles;
+        return {
+          visibles: _extends(_extends({}, visibles), _defineProperty({}, index, visible))
+        };
+      });
+    };
+
+    _this.handleWithTooltip = function (_a) {
+      var tooltipPrefixCls = _a.tooltipPrefixCls,
+          prefixCls = _a.prefixCls,
+          _b = _a.info,
+          value = _b.value,
+          dragging = _b.dragging,
+          index = _b.index,
+          restProps = __rest(_b, ["value", "dragging", "index"]);
+
+      var _this$props = _this.props,
+          tipFormatter = _this$props.tipFormatter,
+          tooltipVisible = _this$props.tooltipVisible,
+          tooltipPlacement = _this$props.tooltipPlacement,
+          getTooltipPopupContainer = _this$props.getTooltipPopupContainer,
+          vertical = _this$props.vertical;
+      var visibles = _this.state.visibles;
+      var isTipFormatter = tipFormatter ? visibles[index] || dragging : false;
+      var visible = tooltipVisible || tooltipVisible === undefined && isTipFormatter;
+      return /*#__PURE__*/React.createElement(_SliderTooltip["default"], {
+        prefixCls: tooltipPrefixCls,
+        title: tipFormatter ? tipFormatter(value) : '',
+        visible: visible,
+        placement: tooltipPlacement || (vertical ? 'right' : 'top'),
+        transitionName: "zoom-down",
+        key: index,
+        overlayClassName: "".concat(prefixCls, "-tooltip"),
+        getPopupContainer: getTooltipPopupContainer || function () {
+          return document.body;
+        }
+      }, /*#__PURE__*/React.createElement(_Handle["default"], _extends({}, restProps, {
+        value: value,
+        onMouseEnter: function onMouseEnter() {
+          return _this.toggleTooltipVisible(index, true);
+        },
+        onMouseLeave: function onMouseLeave() {
+          return _this.toggleTooltipVisible(index, false);
+        }
+      })));
+    };
+
+    _this.saveSlider = function (node) {
+      _this.rcSlider = node;
+    };
+
+    _this.renderSlider = function (_ref2) {
+      var getPrefixCls = _ref2.getPrefixCls,
+          direction = _ref2.direction;
+
+      var _a = _this.props,
+          customizePrefixCls = _a.prefixCls,
+          customizeTooltipPrefixCls = _a.tooltipPrefixCls,
+          range = _a.range,
+          className = _a.className,
+          restProps = __rest(_a, ["prefixCls", "tooltipPrefixCls", "range", "className"]);
+
+      var prefixCls = getPrefixCls('slider', customizePrefixCls);
+      var tooltipPrefixCls = getPrefixCls('tooltip', customizeTooltipPrefixCls);
+      var cls = (0, _classnames["default"])(className, _defineProperty({}, "".concat(prefixCls, "-rtl"), direction === 'rtl')); // make reverse default on rtl direction
+
+      if (direction === 'rtl' && !restProps.vertical) {
+        restProps.reverse = !restProps.reverse;
+      }
+
+      if (range) {
+        return /*#__PURE__*/React.createElement(_Range["default"], _extends({}, restProps, {
+          className: cls,
+          ref: _this.saveSlider,
+          handle: function handle(info) {
+            return _this.handleWithTooltip({
+              tooltipPrefixCls: tooltipPrefixCls,
+              prefixCls: prefixCls,
+              info: info
+            });
+          },
+          prefixCls: prefixCls,
+          tooltipPrefixCls: tooltipPrefixCls
+        }));
+      }
+
+      return /*#__PURE__*/React.createElement(_Slider["default"], _extends({}, restProps, {
+        className: cls,
+        ref: _this.saveSlider,
+        handle: function handle(info) {
+          return _this.handleWithTooltip({
+            tooltipPrefixCls: tooltipPrefixCls,
+            prefixCls: prefixCls,
+            info: info
+          });
+        },
+        prefixCls: prefixCls,
+        tooltipPrefixCls: tooltipPrefixCls
+      }));
+    };
+
+    _this.state = {
+      visibles: {}
+    };
+    return _this;
+  }
+
+  _createClass(Slider, [{
+    key: "focus",
+    value: function focus() {
+      this.rcSlider.focus();
+    }
+  }, {
+    key: "blur",
+    value: function blur() {
+      this.rcSlider.blur();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(_configProvider.ConfigConsumer, null, this.renderSlider);
+    }
+  }]);
+
+  return Slider;
+}(React.Component);
+
+exports["default"] = Slider;
+Slider.defaultProps = {
+  tipFormatter: function tipFormatter(value) {
+    return typeof value === 'number' ? value.toString() : '';
+  }
+};

web/node_modules/antd/lib/slider/style/css.js

@@ -0,0 +1,7 @@
+"use strict";
+
+require("../../style/index.css");
+
+require("./index.css");
+
+require("../../tooltip/style/css");

web/node_modules/antd/lib/slider/style/index.css

@@ -0,0 +1,219 @@
+/* stylelint-disable at-rule-empty-line-before,at-rule-name-space-after,at-rule-no-unknown */
+/* stylelint-disable no-duplicate-selectors */
+/* stylelint-disable */
+/* stylelint-disable declaration-bang-space-before,no-duplicate-selectors,string-no-newline */
+.ant-slider {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  position: relative;
+  height: 12px;
+  margin: 10px 6px 10px;
+  padding: 4px 0;
+  cursor: pointer;
+  -ms-touch-action: none;
+      touch-action: none;
+}
+.ant-slider-vertical {
+  width: 12px;
+  height: 100%;
+  margin: 6px 10px;
+  padding: 0 4px;
+}
+.ant-slider-vertical .ant-slider-rail {
+  width: 4px;
+  height: 100%;
+}
+.ant-slider-vertical .ant-slider-track {
+  width: 4px;
+}
+.ant-slider-vertical .ant-slider-handle {
+  margin-top: -6px;
+  margin-left: -5px;
+}
+.ant-slider-vertical .ant-slider-mark {
+  top: 0;
+  left: 12px;
+  width: 18px;
+  height: 100%;
+}
+.ant-slider-vertical .ant-slider-mark-text {
+  left: 4px;
+  white-space: nowrap;
+}
+.ant-slider-vertical .ant-slider-step {
+  width: 4px;
+  height: 100%;
+}
+.ant-slider-vertical .ant-slider-dot {
+  top: auto;
+  left: 2px;
+  margin-bottom: -4px;
+}
+.ant-slider-tooltip .ant-tooltip-inner {
+  min-width: unset;
+}
+.ant-slider-rtl.ant-slider-vertical .ant-slider-handle {
+  margin-right: -5px;
+  margin-left: 0;
+}
+.ant-slider-rtl.ant-slider-vertical .ant-slider-mark {
+  right: 12px;
+  left: auto;
+}
+.ant-slider-rtl.ant-slider-vertical .ant-slider-mark-text {
+  right: 4px;
+  left: auto;
+}
+.ant-slider-rtl.ant-slider-vertical .ant-slider-dot {
+  right: 2px;
+  left: auto;
+}
+.ant-slider-with-marks {
+  margin-bottom: 28px;
+}
+.ant-slider-rail {
+  position: absolute;
+  width: 100%;
+  height: 4px;
+  background-color: #f5f5f5;
+  border-radius: 2px;
+  -webkit-transition: background-color 0.3s;
+  transition: background-color 0.3s;
+}
+.ant-slider-track {
+  position: absolute;
+  height: 4px;
+  background-color: #91d5ff;
+  border-radius: 2px;
+  -webkit-transition: background-color 0.3s;
+  transition: background-color 0.3s;
+}
+.ant-slider-handle {
+  position: absolute;
+  width: 14px;
+  height: 14px;
+  margin-top: -5px;
+  background-color: #fff;
+  border: solid 2px #91d5ff;
+  border-radius: 50%;
+  -webkit-box-shadow: 0;
+          box-shadow: 0;
+  cursor: pointer;
+  -webkit-transition: border-color 0.3s, -webkit-box-shadow 0.6s, -webkit-transform 0.3s cubic-bezier(0.18, 0.89, 0.32, 1.28);
+  transition: border-color 0.3s, -webkit-box-shadow 0.6s, -webkit-transform 0.3s cubic-bezier(0.18, 0.89, 0.32, 1.28);
+  transition: border-color 0.3s, box-shadow 0.6s, transform 0.3s cubic-bezier(0.18, 0.89, 0.32, 1.28);
+  transition: border-color 0.3s, box-shadow 0.6s, transform 0.3s cubic-bezier(0.18, 0.89, 0.32, 1.28), -webkit-box-shadow 0.6s, -webkit-transform 0.3s cubic-bezier(0.18, 0.89, 0.32, 1.28);
+}
+.ant-slider-handle-dragging.ant-slider-handle-dragging.ant-slider-handle-dragging {
+  border-color: #46a6ff;
+  -webkit-box-shadow: 0 0 0 5px rgba(24, 144, 255, 0.12);
+          box-shadow: 0 0 0 5px rgba(24, 144, 255, 0.12);
+}
+.ant-slider-handle:focus {
+  border-color: #46a6ff;
+  outline: none;
+  -webkit-box-shadow: 0 0 0 5px rgba(24, 144, 255, 0.12);
+          box-shadow: 0 0 0 5px rgba(24, 144, 255, 0.12);
+}
+.ant-slider-handle.ant-tooltip-open {
+  border-color: #1890ff;
+}
+.ant-slider:hover .ant-slider-rail {
+  background-color: #e1e1e1;
+}
+.ant-slider:hover .ant-slider-track {
+  background-color: #69c0ff;
+}
+.ant-slider:hover .ant-slider-handle:not(.ant-tooltip-open) {
+  border-color: #69c0ff;
+}
+.ant-slider-mark {
+  position: absolute;
+  top: 14px;
+  left: 0;
+  width: 100%;
+  font-size: 14px;
+}
+.ant-slider-mark-text {
+  position: absolute;
+  display: inline-block;
+  color: rgba(0, 0, 0, 0.45);
+  text-align: center;
+  word-break: keep-all;
+  cursor: pointer;
+}
+.ant-slider-mark-text-active {
+  color: rgba(0, 0, 0, 0.65);
+}
+.ant-slider-step {
+  position: absolute;
+  width: 100%;
+  height: 4px;
+  background: transparent;
+}
+.ant-slider-dot {
+  position: absolute;
+  top: -2px;
+  width: 8px;
+  height: 8px;
+  margin-left: -4px;
+  background-color: #fff;
+  border: 2px solid #f0f0f0;
+  border-radius: 50%;
+  cursor: pointer;
+}
+.ant-slider-dot:first-child {
+  margin-left: -4px;
+}
+.ant-slider-dot:last-child {
+  margin-left: -4px;
+}
+.ant-slider-dot-active {
+  border-color: #8cc8ff;
+}
+.ant-slider-disabled {
+  cursor: not-allowed;
+}
+.ant-slider-disabled .ant-slider-track {
+  background-color: rgba(0, 0, 0, 0.25) !important;
+}
+.ant-slider-disabled .ant-slider-handle,
+.ant-slider-disabled .ant-slider-dot {
+  background-color: #fff;
+  border-color: rgba(0, 0, 0, 0.25) !important;
+  -webkit-box-shadow: none;
+          box-shadow: none;
+  cursor: not-allowed;
+}
+.ant-slider-disabled .ant-slider-mark-text,
+.ant-slider-disabled .ant-slider-dot {
+  cursor: not-allowed !important;
+}
+.ant-slider-rtl {
+  direction: rtl;
+}
+.ant-slider-rtl .ant-slider-mark {
+  right: 0;
+  left: auto;
+}
+.ant-slider-rtl .ant-slider-dot {
+  margin-right: -4px;
+  margin-left: 0;
+}
+.ant-slider-rtl .ant-slider-dot:first-child {
+  margin-right: -4px;
+  margin-left: 0;
+}
+.ant-slider-rtl .ant-slider-dot:last-child {
+  margin-right: -4px;
+  margin-left: 0;
+}

web/node_modules/antd/lib/slider/style/index.d.ts

@@ -0,0 +1,3 @@
+import '../../style/index.less';
+import './index.less';
+import '../../tooltip/style';

web/node_modules/antd/lib/slider/style/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+require("../../style/index.less");
+
+require("./index.less");
+
+require("../../tooltip/style");

web/node_modules/antd/lib/slider/style/index.less

@@ -0,0 +1,205 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@slider-prefix-cls: ~'@{ant-prefix}-slider';
+
+.@{slider-prefix-cls} {
+  .reset-component;
+
+  position: relative;
+  height: 12px;
+  margin: @slider-margin;
+  padding: 4px 0;
+  cursor: pointer;
+  touch-action: none;
+
+  .vertical();
+
+  &-with-marks {
+    margin-bottom: 28px;
+  }
+
+  &-rail {
+    position: absolute;
+    width: 100%;
+    height: 4px;
+    background-color: @slider-rail-background-color;
+    border-radius: @border-radius-base;
+    transition: background-color 0.3s;
+  }
+
+  &-track {
+    position: absolute;
+    height: 4px;
+    background-color: @slider-track-background-color;
+    border-radius: @border-radius-base;
+    transition: background-color 0.3s;
+  }
+
+  &-handle {
+    position: absolute;
+    width: 14px;
+    height: 14px;
+    margin-top: -5px;
+    background-color: @slider-handle-background-color;
+    border: solid @slider-handle-border-width @slider-handle-color;
+    border-radius: 50%;
+    box-shadow: @slider-handle-shadow;
+    cursor: pointer;
+    transition: border-color 0.3s, box-shadow 0.6s,
+      transform 0.3s cubic-bezier(0.18, 0.89, 0.32, 1.28);
+
+    &-dragging&-dragging&-dragging {
+      border-color: @slider-handle-color-focus;
+      box-shadow: 0 0 0 5px @slider-handle-color-focus-shadow;
+    }
+
+    &:focus {
+      border-color: @slider-handle-color-focus;
+      outline: none;
+      box-shadow: 0 0 0 5px @slider-handle-color-focus-shadow;
+    }
+
+    &.@{ant-prefix}-tooltip-open {
+      border-color: @slider-handle-color-tooltip-open;
+    }
+  }
+
+  &:hover {
+    .@{slider-prefix-cls}-rail {
+      background-color: @slider-rail-background-color-hover;
+    }
+    .@{slider-prefix-cls}-track {
+      background-color: @slider-track-background-color-hover;
+    }
+    .@{slider-prefix-cls}-handle:not(.@{ant-prefix}-tooltip-open) {
+      border-color: @slider-handle-color-hover;
+    }
+  }
+
+  &-mark {
+    position: absolute;
+    top: 14px;
+    left: 0;
+    width: 100%;
+    font-size: @font-size-base;
+  }
+
+  &-mark-text {
+    position: absolute;
+    display: inline-block;
+    color: @text-color-secondary;
+    text-align: center;
+    word-break: keep-all;
+    cursor: pointer;
+
+    &-active {
+      color: @text-color;
+    }
+  }
+
+  &-step {
+    position: absolute;
+    width: 100%;
+    height: 4px;
+    background: transparent;
+  }
+
+  &-dot {
+    position: absolute;
+    top: -2px;
+    width: 8px;
+    height: 8px;
+    margin-left: -4px;
+    background-color: @component-background;
+    border: 2px solid @slider-dot-border-color;
+    border-radius: 50%;
+    cursor: pointer;
+
+    &:first-child {
+      margin-left: -4px;
+    }
+    &:last-child {
+      margin-left: -4px;
+    }
+    &-active {
+      border-color: @slider-dot-border-color-active;
+    }
+  }
+
+  &-disabled {
+    cursor: not-allowed;
+
+    .@{slider-prefix-cls}-track {
+      background-color: @slider-disabled-color !important;
+    }
+
+    .@{slider-prefix-cls}-handle,
+    .@{slider-prefix-cls}-dot {
+      background-color: @component-background;
+      border-color: @slider-disabled-color !important;
+      box-shadow: none;
+      cursor: not-allowed;
+    }
+
+    .@{slider-prefix-cls}-mark-text,
+    .@{slider-prefix-cls}-dot {
+      cursor: not-allowed !important;
+    }
+  }
+}
+
+.vertical() {
+  &-vertical {
+    width: 12px;
+    height: 100%;
+    margin: 6px 10px;
+    padding: 0 4px;
+
+    .@{slider-prefix-cls}-rail {
+      width: 4px;
+      height: 100%;
+    }
+
+    .@{slider-prefix-cls}-track {
+      width: 4px;
+    }
+
+    .@{slider-prefix-cls}-handle {
+      margin-top: -6px; // we chould consider border width as well: (10 + 2 ) / 2
+      margin-left: -5px;
+    }
+
+    .@{slider-prefix-cls}-mark {
+      top: 0;
+      left: 12px;
+      width: 18px;
+      height: 100%;
+    }
+
+    .@{slider-prefix-cls}-mark-text {
+      left: 4px;
+      white-space: nowrap;
+    }
+
+    .@{slider-prefix-cls}-step {
+      width: 4px;
+      height: 100%;
+    }
+
+    .@{slider-prefix-cls}-dot {
+      top: auto;
+      left: 2px;
+      margin-bottom: -4px;
+    }
+  }
+
+  &-tooltip {
+    // https://github.com/ant-design/ant-design/issues/20014
+    .@{ant-prefix}-tooltip-inner {
+      min-width: unset;
+    }
+  }
+}
+
+@import './rtl';

web/node_modules/antd/lib/slider/style/rtl.less

@@ -0,0 +1,70 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@slider-prefix-cls: ~'@{ant-prefix}-slider';
+
+.@{slider-prefix-cls} {
+  &-rtl {
+    direction: rtl;
+  }
+
+  &-mark {
+    .@{slider-prefix-cls}-rtl & {
+      right: 0;
+      left: auto;
+    }
+  }
+
+  &-dot {
+    .@{slider-prefix-cls}-rtl & {
+      margin-right: -4px;
+      margin-left: 0;
+    }
+
+    &:first-child {
+      .@{slider-prefix-cls}-rtl & {
+        margin-right: -4px;
+        margin-left: 0;
+      }
+    }
+
+    &:last-child {
+      .@{slider-prefix-cls}-rtl & {
+        margin-right: -4px;
+        margin-left: 0;
+      }
+    }
+  }
+}
+
+.vertical() {
+  &-vertical {
+    .@{slider-prefix-cls}-handle {
+      .@{slider-prefix-cls}-rtl& {
+        margin-right: -5px;
+        margin-left: 0;
+      }
+    }
+
+    .@{slider-prefix-cls}-mark {
+      .@{slider-prefix-cls}-rtl& {
+        right: 12px;
+        left: auto;
+      }
+    }
+
+    .@{slider-prefix-cls}-mark-text {
+      .@{slider-prefix-cls}-rtl& {
+        right: 4px;
+        left: auto;
+      }
+    }
+
+    .@{slider-prefix-cls}-dot {
+      .@{slider-prefix-cls}-rtl& {
+        right: 2px;
+        left: auto;
+      }
+    }
+  }
+}