"use strict";
(self["webpackChunkpj_process"] = self["webpackChunkpj_process"] || []).push([[432],{

/***/ 25403:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(38295);
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(62081);
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27520);
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(83270);
/* harmony import */ var _util_classNames__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(64334);
/* harmony import */ var _util_vue_types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33999);
/* harmony import */ var _vc_util_Dom_addEventListener__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(35209);







/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((0,vue__WEBPACK_IMPORTED_MODULE_0__/* .defineComponent */ .aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'Handle',
  inheritAttrs: false,
  props: {
    prefixCls: String,
    vertical: {
      type: Boolean,
      default: undefined
    },
    offset: Number,
    disabled: {
      type: Boolean,
      default: undefined
    },
    min: Number,
    max: Number,
    value: Number,
    tabindex: _util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].oneOfType */ .Z.oneOfType([_util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].number */ .Z.number, _util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].string */ .Z.string]),
    reverse: {
      type: Boolean,
      default: undefined
    },
    ariaLabel: String,
    ariaLabelledBy: String,
    ariaValueTextFormatter: Function,
    onMouseenter: {
      type: Function
    },
    onMouseleave: {
      type: Function
    },
    onMousedown: {
      type: Function
    }
  },
  setup(props, _ref) {
    let {
      attrs,
      emit,
      expose
    } = _ref;
    const clickFocused = (0,vue__WEBPACK_IMPORTED_MODULE_2__/* .shallowRef */ .XI)(false);
    const handle = (0,vue__WEBPACK_IMPORTED_MODULE_2__/* .shallowRef */ .XI)();
    const handleMouseUp = () => {
      if (document.activeElement === handle.value) {
        clickFocused.value = true;
      }
    };
    const handleBlur = e => {
      clickFocused.value = false;
      emit('blur', e);
    };
    const handleKeyDown = () => {
      clickFocused.value = false;
    };
    const focus = () => {
      var _a;
      (_a = handle.value) === null || _a === void 0 ? void 0 : _a.focus();
    };
    const blur = () => {
      var _a;
      (_a = handle.value) === null || _a === void 0 ? void 0 : _a.blur();
    };
    const clickFocus = () => {
      clickFocused.value = true;
      focus();
    };
    // when click can not focus in vue, use mousedown trigger focus
    const handleMousedown = e => {
      e.preventDefault();
      focus();
      emit('mousedown', e);
    };
    expose({
      focus,
      blur,
      clickFocus,
      ref: handle
    });
    let onMouseUpListener = null;
    (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .onMounted */ .bv)(() => {
      onMouseUpListener = (0,_vc_util_Dom_addEventListener__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)(document, 'mouseup', handleMouseUp);
    });
    (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .onBeforeUnmount */ .Jd)(() => {
      onMouseUpListener === null || onMouseUpListener === void 0 ? void 0 : onMouseUpListener.remove();
    });
    const positionStyle = (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .computed */ .Fl)(() => {
      const {
        vertical,
        offset,
        reverse
      } = props;
      return vertical ? {
        [reverse ? 'top' : 'bottom']: `${offset}%`,
        [reverse ? 'bottom' : 'top']: 'auto',
        transform: reverse ? null : `translateY(+50%)`
      } : {
        [reverse ? 'right' : 'left']: `${offset}%`,
        [reverse ? 'left' : 'right']: 'auto',
        transform: `translateX(${reverse ? '+' : '-'}50%)`
      };
    });
    return () => {
      const {
        prefixCls,
        disabled,
        min,
        max,
        value,
        tabindex,
        ariaLabel,
        ariaLabelledBy,
        ariaValueTextFormatter,
        onMouseenter,
        onMouseleave
      } = props;
      const className = (0,_util_classNames__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)(attrs.class, {
        [`${prefixCls}-handle-click-focused`]: clickFocused.value
      });
      const ariaProps = {
        'aria-valuemin': min,
        'aria-valuemax': max,
        'aria-valuenow': value,
        'aria-disabled': !!disabled
      };
      const elStyle = [attrs.style, positionStyle.value];
      let mergedTabIndex = tabindex || 0;
      if (disabled || tabindex === null) {
        mergedTabIndex = null;
      }
      let ariaValueText;
      if (ariaValueTextFormatter) {
        ariaValueText = ariaValueTextFormatter(value);
      }
      const handleProps = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)({}, attrs), {
        role: 'slider',
        tabindex: mergedTabIndex
      }), ariaProps), {
        class: className,
        onBlur: handleBlur,
        onKeydown: handleKeyDown,
        onMousedown: handleMousedown,
        onMouseenter,
        onMouseleave,
        ref: handle,
        style: elStyle
      });
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .createVNode */ .Wm)("div", (0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z)({}, handleProps), {}, {
        "aria-label": ariaLabel,
        "aria-labelledby": ariaLabelledBy,
        "aria-valuetext": ariaValueText
      }), null);
    };
  }
}));

/***/ }),

/***/ 71619:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(62081);
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(27520);
/* harmony import */ var _util_classNames__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(64334);
/* harmony import */ var _util_vue_types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33999);
/* harmony import */ var _util_BaseMixin__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(39660);
/* harmony import */ var _util_props_util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(9985);
/* harmony import */ var _common_Track__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(23924);
/* harmony import */ var _common_createSlider__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(68201);
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66524);
/* harmony import */ var _util_props_util_initDefaultProps__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(57206);











const trimAlignValue = _ref => {
  let {
    value,
    handle,
    bounds,
    props
  } = _ref;
  const {
    allowCross,
    pushable
  } = props;
  const thershold = Number(pushable);
  const valInRange = _utils__WEBPACK_IMPORTED_MODULE_0__/* .ensureValueInRange */ .Rc(value, props);
  let valNotConflict = valInRange;
  if (!allowCross && handle != null && bounds !== undefined) {
    if (handle > 0 && valInRange <= bounds[handle - 1] + thershold) {
      valNotConflict = bounds[handle - 1] + thershold;
    }
    if (handle < bounds.length - 1 && valInRange >= bounds[handle + 1] - thershold) {
      valNotConflict = bounds[handle + 1] - thershold;
    }
  }
  return _utils__WEBPACK_IMPORTED_MODULE_0__/* .ensureValuePrecision */ .s7(valNotConflict, props);
};
const rangeProps = {
  defaultValue: _util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].arrayOf */ .Z.arrayOf(_util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].number */ .Z.number),
  value: _util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].arrayOf */ .Z.arrayOf(_util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].number */ .Z.number),
  count: Number,
  pushable: (0,_util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* .withUndefined */ .u)(_util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].oneOfType */ .Z.oneOfType([_util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].looseBool */ .Z.looseBool, _util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].number */ .Z.number])),
  allowCross: {
    type: Boolean,
    default: undefined
  },
  disabled: {
    type: Boolean,
    default: undefined
  },
  reverse: {
    type: Boolean,
    default: undefined
  },
  tabindex: _util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].arrayOf */ .Z.arrayOf(_util_vue_types__WEBPACK_IMPORTED_MODULE_1__/* ["default"].number */ .Z.number),
  prefixCls: String,
  min: Number,
  max: Number,
  autofocus: {
    type: Boolean,
    default: undefined
  },
  ariaLabelGroupForHandles: Array,
  ariaLabelledByGroupForHandles: Array,
  ariaValueTextFormatterGroupForHandles: Array,
  draggableTrack: {
    type: Boolean,
    default: undefined
  }
};
const Range = (0,vue__WEBPACK_IMPORTED_MODULE_2__/* .defineComponent */ .aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'Range',
  mixins: [_util_BaseMixin__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z],
  inheritAttrs: false,
  props: (0,_util_props_util_initDefaultProps__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)(rangeProps, {
    count: 1,
    allowCross: true,
    pushable: false,
    tabindex: [],
    draggableTrack: false,
    ariaLabelGroupForHandles: [],
    ariaLabelledByGroupForHandles: [],
    ariaValueTextFormatterGroupForHandles: []
  }),
  emits: ['beforeChange', 'afterChange', 'change'],
  displayName: 'Range',
  data() {
    const {
      count,
      min,
      max
    } = this;
    const initialValue = Array(...Array(count + 1)).map(() => min);
    const defaultValue = (0,_util_props_util__WEBPACK_IMPORTED_MODULE_5__/* .hasProp */ .m2)(this, 'defaultValue') ? this.defaultValue : initialValue;
    let {
      value
    } = this;
    if (value === undefined) {
      value = defaultValue;
    }
    const bounds = value.map((v, i) => trimAlignValue({
      value: v,
      handle: i,
      props: this.$props
    }));
    const recent = bounds[0] === max ? 0 : bounds.length - 1;
    return {
      sHandle: null,
      recent,
      bounds
    };
  },
  watch: {
    value: {
      handler(val) {
        const {
          bounds
        } = this;
        this.setChangeValue(val || bounds);
      },
      deep: true
    },
    min() {
      const {
        value
      } = this;
      this.setChangeValue(value || this.bounds);
    },
    max() {
      const {
        value
      } = this;
      this.setChangeValue(value || this.bounds);
    }
  },
  methods: {
    setChangeValue(value) {
      const {
        bounds
      } = this;
      let nextBounds = value.map((v, i) => trimAlignValue({
        value: v,
        handle: i,
        bounds,
        props: this.$props
      }));
      if (bounds.length === nextBounds.length) {
        if (nextBounds.every((v, i) => v === bounds[i])) {
          return null;
        }
      } else {
        nextBounds = value.map((v, i) => trimAlignValue({
          value: v,
          handle: i,
          props: this.$props
        }));
      }
      this.setState({
        bounds: nextBounds
      });
      if (value.some(v => _utils__WEBPACK_IMPORTED_MODULE_0__/* .isValueOutOfRange */ .KJ(v, this.$props))) {
        const newValues = value.map(v => {
          return _utils__WEBPACK_IMPORTED_MODULE_0__/* .ensureValueInRange */ .Rc(v, this.$props);
        });
        this.$emit('change', newValues);
      }
    },
    onChange(state) {
      const isNotControlled = !(0,_util_props_util__WEBPACK_IMPORTED_MODULE_5__/* .hasProp */ .m2)(this, 'value');
      if (isNotControlled) {
        this.setState(state);
      } else {
        const controlledState = {};
        ['sHandle', 'recent'].forEach(item => {
          if (state[item] !== undefined) {
            controlledState[item] = state[item];
          }
        });
        if (Object.keys(controlledState).length) {
          this.setState(controlledState);
        }
      }
      const data = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z)({}, this.$data), state);
      const changedValue = data.bounds;
      this.$emit('change', changedValue);
    },
    positionGetValue(position) {
      const bounds = this.getValue();
      const value = this.calcValueByPos(position);
      const closestBound = this.getClosestBound(value);
      const index = this.getBoundNeedMoving(value, closestBound);
      const prevValue = bounds[index];
      if (value === prevValue) return null;
      const nextBounds = [...bounds];
      nextBounds[index] = value;
      return nextBounds;
    },
    onStart(position) {
      const {
        bounds
      } = this;
      this.$emit('beforeChange', bounds);
      const value = this.calcValueByPos(position);
      this.startValue = value;
      this.startPosition = position;
      const closestBound = this.getClosestBound(value);
      this.prevMovedHandleIndex = this.getBoundNeedMoving(value, closestBound);
      this.setState({
        sHandle: this.prevMovedHandleIndex,
        recent: this.prevMovedHandleIndex
      });
      const prevValue = bounds[this.prevMovedHandleIndex];
      if (value === prevValue) return;
      const nextBounds = [...bounds];
      nextBounds[this.prevMovedHandleIndex] = value;
      this.onChange({
        bounds: nextBounds
      });
    },
    onEnd(force) {
      const {
        sHandle
      } = this;
      this.removeDocumentEvents();
      if (!sHandle) {
        this.dragTrack = false;
      }
      if (sHandle !== null || force) {
        this.$emit('afterChange', this.bounds);
      }
      this.setState({
        sHandle: null
      });
    },
    onMove(e, position, dragTrack, startBounds) {
      _utils__WEBPACK_IMPORTED_MODULE_0__/* .pauseEvent */ .jh(e);
      const {
        $data: state,
        $props: props
      } = this;
      const maxValue = props.max || 100;
      const minValue = props.min || 0;
      if (dragTrack) {
        let pos = props.vertical ? -position : position;
        pos = props.reverse ? -pos : pos;
        const max = maxValue - Math.max(...startBounds);
        const min = minValue - Math.min(...startBounds);
        const ratio = Math.min(Math.max(pos / (this.getSliderLength() / 100), min), max);
        const nextBounds = startBounds.map(v => Math.floor(Math.max(Math.min(v + ratio, maxValue), minValue)));
        if (state.bounds.map((c, i) => c === nextBounds[i]).some(c => !c)) {
          this.onChange({
            bounds: nextBounds
          });
        }
        return;
      }
      const {
        bounds,
        sHandle
      } = this;
      const value = this.calcValueByPos(position);
      const oldValue = bounds[sHandle];
      if (value === oldValue) return;
      this.moveTo(value);
    },
    onKeyboard(e) {
      const {
        reverse,
        vertical
      } = this.$props;
      const valueMutator = _utils__WEBPACK_IMPORTED_MODULE_0__/* .getKeyboardValueMutator */ .KQ(e, vertical, reverse);
      if (valueMutator) {
        _utils__WEBPACK_IMPORTED_MODULE_0__/* .pauseEvent */ .jh(e);
        const {
          bounds,
          sHandle
        } = this;
        const oldValue = bounds[sHandle === null ? this.recent : sHandle];
        const mutatedValue = valueMutator(oldValue, this.$props);
        const value = trimAlignValue({
          value: mutatedValue,
          handle: sHandle,
          bounds,
          props: this.$props
        });
        if (value === oldValue) return;
        const isFromKeyboardEvent = true;
        this.moveTo(value, isFromKeyboardEvent);
      }
    },
    getClosestBound(value) {
      const {
        bounds
      } = this;
      let closestBound = 0;
      for (let i = 1; i < bounds.length - 1; i += 1) {
        if (value >= bounds[i]) {
          closestBound = i;
        }
      }
      if (Math.abs(bounds[closestBound + 1] - value) < Math.abs(bounds[closestBound] - value)) {
        closestBound += 1;
      }
      return closestBound;
    },
    getBoundNeedMoving(value, closestBound) {
      const {
        bounds,
        recent
      } = this;
      let boundNeedMoving = closestBound;
      const isAtTheSamePoint = bounds[closestBound + 1] === bounds[closestBound];
      if (isAtTheSamePoint && bounds[recent] === bounds[closestBound]) {
        boundNeedMoving = recent;
      }
      if (isAtTheSamePoint && value !== bounds[closestBound + 1]) {
        boundNeedMoving = value < bounds[closestBound + 1] ? closestBound : closestBound + 1;
      }
      return boundNeedMoving;
    },
    getLowerBound() {
      return this.bounds[0];
    },
    getUpperBound() {
      const {
        bounds
      } = this;
      return bounds[bounds.length - 1];
    },
    /**
     * Returns an array of possible slider points, taking into account both
     * `marks` and `step`. The result is cached.
     */
    getPoints() {
      const {
        marks,
        step,
        min,
        max
      } = this;
      const cache = this.internalPointsCache;
      if (!cache || cache.marks !== marks || cache.step !== step) {
        const pointsObject = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z)({}, marks);
        if (step !== null) {
          for (let point = min; point <= max; point += step) {
            pointsObject[point] = point;
          }
        }
        const points = Object.keys(pointsObject).map(parseFloat);
        points.sort((a, b) => a - b);
        this.internalPointsCache = {
          marks,
          step,
          points
        };
      }
      return this.internalPointsCache.points;
    },
    moveTo(value, isFromKeyboardEvent) {
      const nextBounds = [...this.bounds];
      const {
        sHandle,
        recent
      } = this;
      const handle = sHandle === null ? recent : sHandle;
      nextBounds[handle] = value;
      let nextHandle = handle;
      if (this.$props.pushable !== false) {
        this.pushSurroundingHandles(nextBounds, nextHandle);
      } else if (this.$props.allowCross) {
        nextBounds.sort((a, b) => a - b);
        nextHandle = nextBounds.indexOf(value);
      }
      this.onChange({
        recent: nextHandle,
        sHandle: nextHandle,
        bounds: nextBounds
      });
      if (isFromKeyboardEvent) {
        // known problem: because setState is async,
        // so trigger focus will invoke handler's onEnd and another handler's onStart too early,
        // cause onBeforeChange and onAfterChange receive wrong value.
        // here use setState callback to hack，but not elegant
        this.$emit('afterChange', nextBounds);
        this.setState({}, () => {
          this.handlesRefs[nextHandle].focus();
        });
        this.onEnd();
      }
    },
    pushSurroundingHandles(bounds, handle) {
      const value = bounds[handle];
      const {
        pushable
      } = this;
      const threshold = Number(pushable);
      let direction = 0;
      if (bounds[handle + 1] - value < threshold) {
        direction = +1; // push to right
      }
      if (value - bounds[handle - 1] < threshold) {
        direction = -1; // push to left
      }
      if (direction === 0) {
        return;
      }
      const nextHandle = handle + direction;
      const diffToNext = direction * (bounds[nextHandle] - value);
      if (!this.pushHandle(bounds, nextHandle, direction, threshold - diffToNext)) {
        // revert to original value if pushing is impossible
        bounds[handle] = bounds[nextHandle] - direction * threshold;
      }
    },
    pushHandle(bounds, handle, direction, amount) {
      const originalValue = bounds[handle];
      let currentValue = bounds[handle];
      while (direction * (currentValue - originalValue) < amount) {
        if (!this.pushHandleOnePoint(bounds, handle, direction)) {
          // can't push handle enough to create the needed `amount` gap, so we
          // revert its position to the original value
          bounds[handle] = originalValue;
          return false;
        }
        currentValue = bounds[handle];
      }
      // the handle was pushed enough to create the needed `amount` gap
      return true;
    },
    pushHandleOnePoint(bounds, handle, direction) {
      const points = this.getPoints();
      const pointIndex = points.indexOf(bounds[handle]);
      const nextPointIndex = pointIndex + direction;
      if (nextPointIndex >= points.length || nextPointIndex < 0) {
        // reached the minimum or maximum available point, can't push anymore
        return false;
      }
      const nextHandle = handle + direction;
      const nextValue = points[nextPointIndex];
      const {
        pushable
      } = this;
      const threshold = Number(pushable);
      const diffToNext = direction * (bounds[nextHandle] - nextValue);
      if (!this.pushHandle(bounds, nextHandle, direction, threshold - diffToNext)) {
        // couldn't push next handle, so we won't push this one either
        return false;
      }
      // push the handle
      bounds[handle] = nextValue;
      return true;
    },
    trimAlignValue(value) {
      const {
        sHandle,
        bounds
      } = this;
      return trimAlignValue({
        value,
        handle: sHandle,
        bounds,
        props: this.$props
      });
    },
    ensureValueNotConflict(handle, val, _ref2) {
      let {
        allowCross,
        pushable: thershold
      } = _ref2;
      const state = this.$data || {};
      const {
        bounds
      } = state;
      handle = handle === undefined ? state.sHandle : handle;
      thershold = Number(thershold);
      /* eslint-disable eqeqeq */
      if (!allowCross && handle != null && bounds !== undefined) {
        if (handle > 0 && val <= bounds[handle - 1] + thershold) {
          return bounds[handle - 1] + thershold;
        }
        if (handle < bounds.length - 1 && val >= bounds[handle + 1] - thershold) {
          return bounds[handle + 1] - thershold;
        }
      }
      /* eslint-enable eqeqeq */
      return val;
    },
    getTrack(_ref3) {
      let {
        bounds,
        prefixCls,
        reverse,
        vertical,
        included,
        offsets,
        trackStyle
      } = _ref3;
      return bounds.slice(0, -1).map((_, index) => {
        const i = index + 1;
        const trackClassName = (0,_util_classNames__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z)({
          [`${prefixCls}-track`]: true,
          [`${prefixCls}-track-${i}`]: true
        });
        return (0,vue__WEBPACK_IMPORTED_MODULE_2__/* .createVNode */ .Wm)(_common_Track__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .Z, {
          "class": trackClassName,
          "vertical": vertical,
          "reverse": reverse,
          "included": included,
          "offset": offsets[i - 1],
          "length": offsets[i] - offsets[i - 1],
          "style": trackStyle[index],
          "key": i
        }, null);
      });
    },
    renderSlider() {
      const {
        sHandle,
        bounds,
        prefixCls,
        vertical,
        included,
        disabled,
        min,
        max,
        reverse,
        handle,
        defaultHandle,
        trackStyle,
        handleStyle,
        tabindex,
        ariaLabelGroupForHandles,
        ariaLabelledByGroupForHandles,
        ariaValueTextFormatterGroupForHandles
      } = this;
      const handleGenerator = handle || defaultHandle;
      const offsets = bounds.map(v => this.calcOffset(v));
      const handleClassName = `${prefixCls}-handle`;
      const handles = bounds.map((v, i) => {
        let mergedTabIndex = tabindex[i] || 0;
        if (disabled || tabindex[i] === null) {
          mergedTabIndex = null;
        }
        const dragging = sHandle === i;
        return handleGenerator({
          class: (0,_util_classNames__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z)({
            [handleClassName]: true,
            [`${handleClassName}-${i + 1}`]: true,
            [`${handleClassName}-dragging`]: dragging
          }),
          prefixCls,
          vertical,
          dragging,
          offset: offsets[i],
          value: v,
          index: i,
          tabindex: mergedTabIndex,
          min,
          max,
          reverse,
          disabled,
          style: handleStyle[i],
          ref: h => this.saveHandle(i, h),
          onFocus: this.onFocus,
          onBlur: this.onBlur,
          ariaLabel: ariaLabelGroupForHandles[i],
          ariaLabelledBy: ariaLabelledByGroupForHandles[i],
          ariaValueTextFormatter: ariaValueTextFormatterGroupForHandles[i]
        });
      });
      return {
        tracks: this.getTrack({
          bounds,
          prefixCls,
          reverse,
          vertical,
          included,
          offsets,
          trackStyle
        }),
        handles
      };
    }
  }
});
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((0,_common_createSlider__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .Z)(Range));

/***/ }),

/***/ 98685:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(62081);
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27520);
/* harmony import */ var _util_vue_types__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(33999);
/* harmony import */ var _util_BaseMixin__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(39660);
/* harmony import */ var _util_props_util__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(9985);
/* harmony import */ var _common_Track__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(23924);
/* harmony import */ var _common_createSlider__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(68201);
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(66524);









const Slider = (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .defineComponent */ .aZ)({
  compatConfig: {
    MODE: 3
  },
  name: 'Slider',
  mixins: [_util_BaseMixin__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z],
  inheritAttrs: false,
  props: {
    defaultValue: Number,
    value: Number,
    disabled: {
      type: Boolean,
      default: undefined
    },
    autofocus: {
      type: Boolean,
      default: undefined
    },
    tabindex: _util_vue_types__WEBPACK_IMPORTED_MODULE_2__/* ["default"].oneOfType */ .Z.oneOfType([_util_vue_types__WEBPACK_IMPORTED_MODULE_2__/* ["default"].number */ .Z.number, _util_vue_types__WEBPACK_IMPORTED_MODULE_2__/* ["default"].string */ .Z.string]),
    reverse: {
      type: Boolean,
      default: undefined
    },
    min: Number,
    max: Number,
    ariaLabelForHandle: String,
    ariaLabelledByForHandle: String,
    ariaValueTextFormatterForHandle: String,
    startPoint: Number
  },
  emits: ['beforeChange', 'afterChange', 'change'],
  data() {
    const defaultValue = this.defaultValue !== undefined ? this.defaultValue : this.min;
    const value = this.value !== undefined ? this.value : defaultValue;
    return {
      sValue: this.trimAlignValue(value),
      dragging: false
    };
  },
  watch: {
    value: {
      handler(val) {
        this.setChangeValue(val);
      },
      deep: true
    },
    min() {
      const {
        sValue
      } = this;
      this.setChangeValue(sValue);
    },
    max() {
      const {
        sValue
      } = this;
      this.setChangeValue(sValue);
    }
  },
  methods: {
    setChangeValue(value) {
      const newValue = value !== undefined ? value : this.sValue;
      const nextValue = this.trimAlignValue(newValue, this.$props);
      if (nextValue === this.sValue) return;
      this.setState({
        sValue: nextValue
      });
      if (_utils__WEBPACK_IMPORTED_MODULE_3__/* .isValueOutOfRange */ .KJ(newValue, this.$props)) {
        this.$emit('change', nextValue);
      }
    },
    onChange(state) {
      const isNotControlled = !(0,_util_props_util__WEBPACK_IMPORTED_MODULE_4__/* .hasProp */ .m2)(this, 'value');
      const nextState = state.sValue > this.max ? (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)({}, state), {
        sValue: this.max
      }) : state;
      if (isNotControlled) {
        this.setState(nextState);
      }
      const changedValue = nextState.sValue;
      this.$emit('change', changedValue);
    },
    onStart(position) {
      this.setState({
        dragging: true
      });
      const {
        sValue
      } = this;
      this.$emit('beforeChange', sValue);
      const value = this.calcValueByPos(position);
      this.startValue = value;
      this.startPosition = position;
      if (value === sValue) return;
      this.prevMovedHandleIndex = 0;
      this.onChange({
        sValue: value
      });
    },
    onEnd(force) {
      const {
        dragging
      } = this;
      this.removeDocumentEvents();
      if (dragging || force) {
        this.$emit('afterChange', this.sValue);
      }
      this.setState({
        dragging: false
      });
    },
    onMove(e, position) {
      _utils__WEBPACK_IMPORTED_MODULE_3__/* .pauseEvent */ .jh(e);
      const {
        sValue
      } = this;
      const value = this.calcValueByPos(position);
      if (value === sValue) return;
      this.onChange({
        sValue: value
      });
    },
    onKeyboard(e) {
      const {
        reverse,
        vertical
      } = this.$props;
      const valueMutator = _utils__WEBPACK_IMPORTED_MODULE_3__/* .getKeyboardValueMutator */ .KQ(e, vertical, reverse);
      if (valueMutator) {
        _utils__WEBPACK_IMPORTED_MODULE_3__/* .pauseEvent */ .jh(e);
        const {
          sValue
        } = this;
        const mutatedValue = valueMutator(sValue, this.$props);
        const value = this.trimAlignValue(mutatedValue);
        if (value === sValue) return;
        this.onChange({
          sValue: value
        });
        this.$emit('afterChange', value);
        this.onEnd();
      }
    },
    getLowerBound() {
      const minPoint = this.$props.startPoint || this.$props.min;
      return this.$data.sValue > minPoint ? minPoint : this.$data.sValue;
    },
    getUpperBound() {
      if (this.$data.sValue < this.$props.startPoint) {
        return this.$props.startPoint;
      }
      return this.$data.sValue;
    },
    trimAlignValue(v) {
      let nextProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      if (v === null) {
        return null;
      }
      const mergedProps = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)({}, this.$props), nextProps);
      const val = _utils__WEBPACK_IMPORTED_MODULE_3__/* .ensureValueInRange */ .Rc(v, mergedProps);
      return _utils__WEBPACK_IMPORTED_MODULE_3__/* .ensureValuePrecision */ .s7(val, mergedProps);
    },
    getTrack(_ref) {
      let {
        prefixCls,
        reverse,
        vertical,
        included,
        minimumTrackStyle,
        mergedTrackStyle,
        length,
        offset
      } = _ref;
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__/* .createVNode */ .Wm)(_common_Track__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z, {
        "class": `${prefixCls}-track`,
        "vertical": vertical,
        "included": included,
        "offset": offset,
        "reverse": reverse,
        "length": length,
        "style": (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)({}, minimumTrackStyle), mergedTrackStyle)
      }, null);
    },
    renderSlider() {
      const {
        prefixCls,
        vertical,
        included,
        disabled,
        minimumTrackStyle,
        trackStyle,
        handleStyle,
        tabindex,
        ariaLabelForHandle,
        ariaLabelledByForHandle,
        ariaValueTextFormatterForHandle,
        min,
        max,
        startPoint,
        reverse,
        handle,
        defaultHandle
      } = this;
      const handleGenerator = handle || defaultHandle;
      const {
        sValue,
        dragging
      } = this;
      const offset = this.calcOffset(sValue);
      const handles = handleGenerator({
        class: `${prefixCls}-handle`,
        prefixCls,
        vertical,
        offset,
        value: sValue,
        dragging,
        disabled,
        min,
        max,
        reverse,
        index: 0,
        tabindex,
        ariaLabel: ariaLabelForHandle,
        ariaLabelledBy: ariaLabelledByForHandle,
        ariaValueTextFormatter: ariaValueTextFormatterForHandle,
        style: handleStyle[0] || handleStyle,
        ref: h => this.saveHandle(0, h),
        onFocus: this.onFocus,
        onBlur: this.onBlur
      });
      const trackOffset = startPoint !== undefined ? this.calcOffset(startPoint) : 0;
      const mergedTrackStyle = trackStyle[0] || trackStyle;
      return {
        tracks: this.getTrack({
          prefixCls,
          reverse,
          vertical,
          included,
          offset: trackOffset,
          minimumTrackStyle,
          mergedTrackStyle,
          length: offset - trackOffset
        }),
        handles
      };
    }
  }
});
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((0,_common_createSlider__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z)(Slider));

/***/ }),

/***/ 23924:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62081);
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(27520);


/* eslint-disable */
const Track = (_, _ref) => {
  let {
    attrs
  } = _ref;
  const {
    included,
    vertical,
    style,
    class: className
  } = attrs;
  let {
    length,
    offset,
    reverse
  } = attrs;
  if (length < 0) {
    reverse = !reverse;
    length = Math.abs(length);
    offset = 100 - offset;
  }
  const positionStyle = vertical ? {
    [reverse ? 'top' : 'bottom']: `${offset}%`,
    [reverse ? 'bottom' : 'top']: 'auto',
    height: `${length}%`
  } : {
    [reverse ? 'right' : 'left']: `${offset}%`,
    [reverse ? 'left' : 'right']: 'auto',
    width: `${length}%`
  };
  const elStyle = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)({}, style), positionStyle);
  return included ? (0,vue__WEBPACK_IMPORTED_MODULE_1__/* .createVNode */ .Wm)("div", {
    "class": className,
    "style": elStyle
  }, null) : null;
};
Track.inheritAttrs = false;
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Track);

/***/ }),

/***/ 68201:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {


// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  "Z": () => (/* binding */ createSlider)
});

// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/objectSpread2.js + 1 modules
var objectSpread2 = __webpack_require__(38295);
// EXTERNAL MODULE: ./node_modules/.pnpm/@babel+runtime@7.18.9/node_modules/@babel/runtime/helpers/esm/extends.js
var esm_extends = __webpack_require__(62081);
// EXTERNAL MODULE: ./node_modules/.pnpm/@vue+runtime-core@3.3.1/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
var runtime_core_esm_bundler = __webpack_require__(27520);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/classNames.js
var classNames = __webpack_require__(64334);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/vue-types/index.js
var vue_types = __webpack_require__(33999);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-util/Dom/addEventListener.js
var addEventListener = __webpack_require__(35209);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/warning.js
var warning = __webpack_require__(82807);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/props-util/initDefaultProps.js
var initDefaultProps = __webpack_require__(57206);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/props-util/index.js
var props_util = __webpack_require__(9985);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-slider/src/common/Steps.js




const calcPoints = (_vertical, marks, dots, step, min, max) => {
  (0,warning/* default */.ZP)(dots ? step > 0 : true, 'Slider', '`Slider[step]` should be a positive number in order to make Slider[dots] work.');
  const points = Object.keys(marks).map(parseFloat).sort((a, b) => a - b);
  if (dots && step) {
    for (let i = min; i <= max; i += step) {
      if (points.indexOf(i) === -1) {
        points.push(i);
      }
    }
  }
  return points;
};
const Steps = (_, _ref) => {
  let {
    attrs
  } = _ref;
  const {
    prefixCls,
    vertical,
    reverse,
    marks,
    dots,
    step,
    included,
    lowerBound,
    upperBound,
    max,
    min,
    dotStyle,
    activeDotStyle
  } = attrs;
  const range = max - min;
  const elements = calcPoints(vertical, marks, dots, step, min, max).map(point => {
    const offset = `${Math.abs(point - min) / range * 100}%`;
    const isActived = !included && point === upperBound || included && point <= upperBound && point >= lowerBound;
    let style = vertical ? (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, dotStyle), {
      [reverse ? 'top' : 'bottom']: offset
    }) : (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, dotStyle), {
      [reverse ? 'right' : 'left']: offset
    });
    if (isActived) {
      style = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, style), activeDotStyle);
    }
    const pointClassName = (0,classNames/* default */.Z)({
      [`${prefixCls}-dot`]: true,
      [`${prefixCls}-dot-active`]: isActived,
      [`${prefixCls}-dot-reverse`]: reverse
    });
    return (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", {
      "class": pointClassName,
      "style": style,
      "key": point
    }, null);
  });
  return (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
    "class": `${prefixCls}-step`
  }, [elements]);
};
Steps.inheritAttrs = false;
/* harmony default export */ const common_Steps = (Steps);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/supportsPassive.js
var supportsPassive = __webpack_require__(27474);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-slider/src/common/Marks.js






const Marks = (_, _ref) => {
  let {
    attrs,
    slots
  } = _ref;
  const {
    class: className,
    vertical,
    reverse,
    marks,
    included,
    upperBound,
    lowerBound,
    max,
    min,
    onClickLabel
  } = attrs;
  const marksKeys = Object.keys(marks);
  const customMark = slots.mark;
  const range = max - min;
  const elements = marksKeys.map(parseFloat).sort((a, b) => a - b).map(point => {
    const markPoint = typeof marks[point] === 'function' ? marks[point]() : marks[point];
    const markPointIsObject = typeof markPoint === 'object' && !(0,props_util/* isValidElement */.l$)(markPoint);
    let markLabel = markPointIsObject ? markPoint.label : markPoint;
    if (!markLabel && markLabel !== 0) {
      return null;
    }
    if (customMark) {
      markLabel = customMark({
        point,
        label: markLabel
      });
    }
    const isActive = !included && point === upperBound || included && point <= upperBound && point >= lowerBound;
    const markClassName = (0,classNames/* default */.Z)({
      [`${className}-text`]: true,
      [`${className}-text-active`]: isActive
    });
    const bottomStyle = {
      marginBottom: '-50%',
      [reverse ? 'top' : 'bottom']: `${(point - min) / range * 100}%`
    };
    const leftStyle = {
      transform: `translateX(${reverse ? `50%` : `-50%`})`,
      msTransform: `translateX(${reverse ? `50%` : `-50%`})`,
      [reverse ? 'right' : 'left']: `${(point - min) / range * 100}%`
    };
    const style = vertical ? bottomStyle : leftStyle;
    const markStyle = markPointIsObject ? (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, style), markPoint.style) : style;
    const touchEvents = {
      [supportsPassive/* default */.Z ? 'onTouchstartPassive' : 'onTouchstart']: e => onClickLabel(e, point)
    };
    return (0,runtime_core_esm_bundler/* createVNode */.Wm)("span", (0,objectSpread2/* default */.Z)({
      "class": markClassName,
      "style": markStyle,
      "key": point,
      "onMousedown": e => onClickLabel(e, point)
    }, touchEvents), [markLabel]);
  });
  return (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
    "class": className
  }, [elements]);
};
Marks.inheritAttrs = false;
/* harmony default export */ const common_Marks = (Marks);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-slider/src/Handle.js
var Handle = __webpack_require__(25403);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-slider/src/utils.js
var utils = __webpack_require__(66524);
// EXTERNAL MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/_util/BaseMixin.js
var BaseMixin = __webpack_require__(39660);
;// CONCATENATED MODULE: ./node_modules/.pnpm/ant-design-vue@4.2.5_vue@3.3.1/node_modules/ant-design-vue/es/vc-slider/src/common/createSlider.js



var __rest = undefined && undefined.__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;
};












function noop() {}
function createSlider(Component) {
  // const displayName = `ComponentEnhancer(${Component.displayName})`
  const propTypes = {
    id: String,
    min: Number,
    max: Number,
    step: Number,
    marks: vue_types/* default.object */.Z.object,
    included: {
      type: Boolean,
      default: undefined
    },
    prefixCls: String,
    disabled: {
      type: Boolean,
      default: undefined
    },
    handle: Function,
    dots: {
      type: Boolean,
      default: undefined
    },
    vertical: {
      type: Boolean,
      default: undefined
    },
    reverse: {
      type: Boolean,
      default: undefined
    },
    minimumTrackStyle: vue_types/* default.object */.Z.object,
    maximumTrackStyle: vue_types/* default.object */.Z.object,
    handleStyle: vue_types/* default.oneOfType */.Z.oneOfType([vue_types/* default.object */.Z.object, vue_types/* default.arrayOf */.Z.arrayOf(vue_types/* default.object */.Z.object)]),
    trackStyle: vue_types/* default.oneOfType */.Z.oneOfType([vue_types/* default.object */.Z.object, vue_types/* default.arrayOf */.Z.arrayOf(vue_types/* default.object */.Z.object)]),
    railStyle: vue_types/* default.object */.Z.object,
    dotStyle: vue_types/* default.object */.Z.object,
    activeDotStyle: vue_types/* default.object */.Z.object,
    autofocus: {
      type: Boolean,
      default: undefined
    },
    draggableTrack: {
      type: Boolean,
      default: undefined
    }
  };
  return (0,runtime_core_esm_bundler/* defineComponent */.aZ)({
    compatConfig: {
      MODE: 3
    },
    name: 'CreateSlider',
    mixins: [BaseMixin/* default */.Z, Component],
    inheritAttrs: false,
    props: (0,initDefaultProps/* default */.Z)(propTypes, {
      prefixCls: 'rc-slider',
      min: 0,
      max: 100,
      step: 1,
      marks: {},
      included: true,
      disabled: false,
      dots: false,
      vertical: false,
      reverse: false,
      trackStyle: [{}],
      handleStyle: [{}],
      railStyle: {},
      dotStyle: {},
      activeDotStyle: {}
    }),
    emits: ['change', 'blur', 'focus'],
    data() {
      const {
        step,
        max,
        min
      } = this;
      const isPointDiffEven = isFinite(max - min) ? (max - min) % step === 0 : true; // eslint-disable-line
      (0,warning/* default */.ZP)(step && Math.floor(step) === step ? isPointDiffEven : true, `Slider[max] - Slider[min] (${max - min}) should be a multiple of Slider[step] (${step})`);
      this.handlesRefs = {};
      return {};
    },
    mounted() {
      this.$nextTick(() => {
        // Snapshot testing cannot handle refs, so be sure to null-check this.
        this.document = this.sliderRef && this.sliderRef.ownerDocument;
        // this.setHandleRefs()
        const {
          autofocus,
          disabled
        } = this;
        if (autofocus && !disabled) {
          this.focus();
        }
      });
    },
    beforeUnmount() {
      this.$nextTick(() => {
        // if (super.componentWillUnmount) super.componentWillUnmount()
        this.removeDocumentEvents();
      });
    },
    methods: {
      defaultHandle(_a) {
        var {
            index,
            directives,
            className,
            style
          } = _a,
          restProps = __rest(_a, ["index", "directives", "className", "style"]);
        delete restProps.dragging;
        if (restProps.value === null) {
          return null;
        }
        const handleProps = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, restProps), {
          class: className,
          style,
          key: index
        });
        return (0,runtime_core_esm_bundler/* createVNode */.Wm)(Handle/* default */.Z, handleProps, null);
      },
      onDown(e, position) {
        let p = position;
        const {
          draggableTrack,
          vertical: isVertical
        } = this.$props;
        const {
          bounds
        } = this.$data;
        const value = draggableTrack && this.positionGetValue ? this.positionGetValue(p) || [] : [];
        const inPoint = utils/* isEventFromHandle */.s_(e, this.handlesRefs);
        this.dragTrack = draggableTrack && bounds.length >= 2 && !inPoint && !value.map((n, i) => {
          const v = !i ? n >= bounds[i] : true;
          return i === value.length - 1 ? n <= bounds[i] : v;
        }).some(c => !c);
        if (this.dragTrack) {
          this.dragOffset = p;
          this.startBounds = [...bounds];
        } else {
          if (!inPoint) {
            this.dragOffset = 0;
          } else {
            const handlePosition = utils/* getHandleCenterPosition */.BW(isVertical, e.target);
            this.dragOffset = p - handlePosition;
            p = handlePosition;
          }
          this.onStart(p);
        }
      },
      onMouseDown(e) {
        if (e.button !== 0) {
          return;
        }
        this.removeDocumentEvents();
        const isVertical = this.$props.vertical;
        const position = utils/* getMousePosition */.yK(isVertical, e);
        this.onDown(e, position);
        this.addDocumentMouseEvents();
      },
      onTouchStart(e) {
        if (utils/* isNotTouchEvent */.as(e)) return;
        const isVertical = this.vertical;
        const position = utils/* getTouchPosition */.OR(isVertical, e);
        this.onDown(e, position);
        this.addDocumentTouchEvents();
        utils/* pauseEvent */.jh(e);
      },
      onFocus(e) {
        const {
          vertical
        } = this;
        if (utils/* isEventFromHandle */.s_(e, this.handlesRefs) && !this.dragTrack) {
          const handlePosition = utils/* getHandleCenterPosition */.BW(vertical, e.target);
          this.dragOffset = 0;
          this.onStart(handlePosition);
          utils/* pauseEvent */.jh(e);
          this.$emit('focus', e);
        }
      },
      onBlur(e) {
        if (!this.dragTrack) {
          this.onEnd();
        }
        this.$emit('blur', e);
      },
      onMouseUp() {
        if (this.handlesRefs[this.prevMovedHandleIndex]) {
          this.handlesRefs[this.prevMovedHandleIndex].clickFocus();
        }
      },
      onMouseMove(e) {
        if (!this.sliderRef) {
          this.onEnd();
          return;
        }
        const position = utils/* getMousePosition */.yK(this.vertical, e);
        this.onMove(e, position - this.dragOffset, this.dragTrack, this.startBounds);
      },
      onTouchMove(e) {
        if (utils/* isNotTouchEvent */.as(e) || !this.sliderRef) {
          this.onEnd();
          return;
        }
        const position = utils/* getTouchPosition */.OR(this.vertical, e);
        this.onMove(e, position - this.dragOffset, this.dragTrack, this.startBounds);
      },
      onKeyDown(e) {
        if (this.sliderRef && utils/* isEventFromHandle */.s_(e, this.handlesRefs)) {
          this.onKeyboard(e);
        }
      },
      onClickMarkLabel(e, value) {
        e.stopPropagation();
        this.onChange({
          sValue: value
        });
        this.setState({
          sValue: value
        }, () => this.onEnd(true));
      },
      getSliderStart() {
        const slider = this.sliderRef;
        const {
          vertical,
          reverse
        } = this;
        const rect = slider.getBoundingClientRect();
        if (vertical) {
          return reverse ? rect.bottom : rect.top;
        }
        return window.scrollX + (reverse ? rect.right : rect.left);
      },
      getSliderLength() {
        const slider = this.sliderRef;
        if (!slider) {
          return 0;
        }
        const coords = slider.getBoundingClientRect();
        return this.vertical ? coords.height : coords.width;
      },
      addDocumentTouchEvents() {
        // just work for Chrome iOS Safari and Android Browser
        this.onTouchMoveListener = (0,addEventListener/* default */.Z)(this.document, 'touchmove', this.onTouchMove);
        this.onTouchUpListener = (0,addEventListener/* default */.Z)(this.document, 'touchend', this.onEnd);
      },
      addDocumentMouseEvents() {
        this.onMouseMoveListener = (0,addEventListener/* default */.Z)(this.document, 'mousemove', this.onMouseMove);
        this.onMouseUpListener = (0,addEventListener/* default */.Z)(this.document, 'mouseup', this.onEnd);
      },
      removeDocumentEvents() {
        /* eslint-disable no-unused-expressions */
        this.onTouchMoveListener && this.onTouchMoveListener.remove();
        this.onTouchUpListener && this.onTouchUpListener.remove();
        this.onMouseMoveListener && this.onMouseMoveListener.remove();
        this.onMouseUpListener && this.onMouseUpListener.remove();
        /* eslint-enable no-unused-expressions */
      },
      focus() {
        var _a;
        if (this.$props.disabled) {
          return;
        }
        (_a = this.handlesRefs[0]) === null || _a === void 0 ? void 0 : _a.focus();
      },
      blur() {
        if (this.$props.disabled) {
          return;
        }
        Object.keys(this.handlesRefs).forEach(key => {
          var _a, _b;
          (_b = (_a = this.handlesRefs[key]) === null || _a === void 0 ? void 0 : _a.blur) === null || _b === void 0 ? void 0 : _b.call(_a);
        });
      },
      calcValue(offset) {
        const {
          vertical,
          min,
          max
        } = this;
        const ratio = Math.abs(Math.max(offset, 0) / this.getSliderLength());
        const value = vertical ? (1 - ratio) * (max - min) + min : ratio * (max - min) + min;
        return value;
      },
      calcValueByPos(position) {
        const sign = this.reverse ? -1 : +1;
        const pixelOffset = sign * (position - this.getSliderStart());
        const nextValue = this.trimAlignValue(this.calcValue(pixelOffset));
        return nextValue;
      },
      calcOffset(value) {
        const {
          min,
          max
        } = this;
        const ratio = (value - min) / (max - min);
        return Math.max(0, ratio * 100);
      },
      saveSlider(slider) {
        this.sliderRef = slider;
      },
      saveHandle(index, handle) {
        this.handlesRefs[index] = handle;
      }
    },
    render() {
      const {
        prefixCls,
        marks,
        dots,
        step,
        included,
        disabled,
        vertical,
        reverse,
        min,
        max,
        maximumTrackStyle,
        railStyle,
        dotStyle,
        activeDotStyle,
        id
      } = this;
      const {
        class: className,
        style
      } = this.$attrs;
      const {
        tracks,
        handles
      } = this.renderSlider();
      const sliderClassName = (0,classNames/* default */.Z)(prefixCls, className, {
        [`${prefixCls}-with-marks`]: Object.keys(marks).length,
        [`${prefixCls}-disabled`]: disabled,
        [`${prefixCls}-vertical`]: vertical,
        [`${prefixCls}-horizontal`]: !vertical
      });
      const markProps = {
        vertical,
        marks,
        included,
        lowerBound: this.getLowerBound(),
        upperBound: this.getUpperBound(),
        max,
        min,
        reverse,
        class: `${prefixCls}-mark`,
        onClickLabel: disabled ? noop : this.onClickMarkLabel
      };
      const touchEvents = {
        [supportsPassive/* default */.Z ? 'onTouchstartPassive' : 'onTouchstart']: disabled ? noop : this.onTouchStart
      };
      return (0,runtime_core_esm_bundler/* createVNode */.Wm)("div", (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
        "id": id,
        "ref": this.saveSlider,
        "tabindex": "-1",
        "class": sliderClassName
      }, touchEvents), {}, {
        "onMousedown": disabled ? noop : this.onMouseDown,
        "onMouseup": disabled ? noop : this.onMouseUp,
        "onKeydown": disabled ? noop : this.onKeyDown,
        "onFocus": disabled ? noop : this.onFocus,
        "onBlur": disabled ? noop : this.onBlur,
        "style": style
      }), [(0,runtime_core_esm_bundler/* createVNode */.Wm)("div", {
        "class": `${prefixCls}-rail`,
        "style": (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, maximumTrackStyle), railStyle)
      }, null), tracks, (0,runtime_core_esm_bundler/* createVNode */.Wm)(common_Steps, {
        "prefixCls": prefixCls,
        "vertical": vertical,
        "reverse": reverse,
        "marks": marks,
        "dots": dots,
        "step": step,
        "included": included,
        "lowerBound": this.getLowerBound(),
        "upperBound": this.getUpperBound(),
        "max": max,
        "min": min,
        "dotStyle": dotStyle,
        "activeDotStyle": activeDotStyle
      }, null), handles, (0,runtime_core_esm_bundler/* createVNode */.Wm)(common_Marks, markProps, {
        mark: this.$slots.mark
      }), (0,props_util/* getSlot */.z9)(this)]);
    }
  });
}

/***/ }),

/***/ 66524:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "BW": () => (/* binding */ getHandleCenterPosition),
/* harmony export */   "KJ": () => (/* binding */ isValueOutOfRange),
/* harmony export */   "KQ": () => (/* binding */ getKeyboardValueMutator),
/* harmony export */   "OR": () => (/* binding */ getTouchPosition),
/* harmony export */   "Rc": () => (/* binding */ ensureValueInRange),
/* harmony export */   "as": () => (/* binding */ isNotTouchEvent),
/* harmony export */   "jh": () => (/* binding */ pauseEvent),
/* harmony export */   "s7": () => (/* binding */ ensureValuePrecision),
/* harmony export */   "s_": () => (/* binding */ isEventFromHandle),
/* harmony export */   "yK": () => (/* binding */ getMousePosition)
/* harmony export */ });
/* unused harmony exports getClosestPoint, getPrecision, calculateNextValue */
/* harmony import */ var _util_KeyCode__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(64776);

function isEventFromHandle(e, handles) {
  try {
    return Object.keys(handles).some(key => e.target === handles[key].ref);
  } catch (error) {
    return false;
  }
}
function isValueOutOfRange(value, _ref) {
  let {
    min,
    max
  } = _ref;
  return value < min || value > max;
}
function isNotTouchEvent(e) {
  return e.touches.length > 1 || e.type.toLowerCase() === 'touchend' && e.touches.length > 0;
}
function getClosestPoint(val, _ref2) {
  let {
    marks,
    step,
    min,
    max
  } = _ref2;
  const points = Object.keys(marks).map(parseFloat);
  if (step !== null) {
    const baseNum = Math.pow(10, getPrecision(step));
    const maxSteps = Math.floor((max * baseNum - min * baseNum) / (step * baseNum));
    const steps = Math.min((val - min) / step, maxSteps);
    const closestStep = Math.round(steps) * step + min;
    points.push(closestStep);
  }
  const diffs = points.map(point => Math.abs(val - point));
  return points[diffs.indexOf(Math.min(...diffs))];
}
function getPrecision(step) {
  const stepString = step.toString();
  let precision = 0;
  if (stepString.indexOf('.') >= 0) {
    precision = stepString.length - stepString.indexOf('.') - 1;
  }
  return precision;
}
function getMousePosition(vertical, e) {
  let zoom = 1;
  if (window.visualViewport) {
    zoom = +(window.visualViewport.width / document.body.getBoundingClientRect().width).toFixed(2);
  }
  return (vertical ? e.clientY : e.pageX) / zoom;
}
function getTouchPosition(vertical, e) {
  let zoom = 1;
  if (window.visualViewport) {
    zoom = +(window.visualViewport.width / document.body.getBoundingClientRect().width).toFixed(2);
  }
  return (vertical ? e.touches[0].clientY : e.touches[0].pageX) / zoom;
}
function getHandleCenterPosition(vertical, handle) {
  const coords = handle.getBoundingClientRect();
  return vertical ? coords.top + coords.height * 0.5 : window.scrollX + coords.left + coords.width * 0.5;
}
function ensureValueInRange(val, _ref3) {
  let {
    max,
    min
  } = _ref3;
  if (val <= min) {
    return min;
  }
  if (val >= max) {
    return max;
  }
  return val;
}
function ensureValuePrecision(val, props) {
  const {
    step
  } = props;
  const closestPoint = isFinite(getClosestPoint(val, props)) ? getClosestPoint(val, props) : 0; // eslint-disable-line
  return step === null ? closestPoint : parseFloat(closestPoint.toFixed(getPrecision(step)));
}
function pauseEvent(e) {
  e.stopPropagation();
  e.preventDefault();
}
function calculateNextValue(func, value, props) {
  const operations = {
    increase: (a, b) => a + b,
    decrease: (a, b) => a - b
  };
  const indexToGet = operations[func](Object.keys(props.marks).indexOf(JSON.stringify(value)), 1);
  const keyToGet = Object.keys(props.marks)[indexToGet];
  if (props.step) {
    return operations[func](value, props.step);
  }
  if (!!Object.keys(props.marks).length && !!props.marks[keyToGet]) {
    return props.marks[keyToGet];
  }
  return value;
}
function getKeyboardValueMutator(e, vertical, reverse) {
  const increase = 'increase';
  const decrease = 'decrease';
  let method = increase;
  switch (e.keyCode) {
    case _util_KeyCode__WEBPACK_IMPORTED_MODULE_0__/* ["default"].UP */ .Z.UP:
      method = vertical && reverse ? decrease : increase;
      break;
    case _util_KeyCode__WEBPACK_IMPORTED_MODULE_0__/* ["default"].RIGHT */ .Z.RIGHT:
      method = !vertical && reverse ? decrease : increase;
      break;
    case _util_KeyCode__WEBPACK_IMPORTED_MODULE_0__/* ["default"].DOWN */ .Z.DOWN:
      method = vertical && reverse ? increase : decrease;
      break;
    case _util_KeyCode__WEBPACK_IMPORTED_MODULE_0__/* ["default"].LEFT */ .Z.LEFT:
      method = !vertical && reverse ? increase : decrease;
      break;
    case _util_KeyCode__WEBPACK_IMPORTED_MODULE_0__/* ["default"].END */ .Z.END:
      return (_value, props) => props.max;
    case _util_KeyCode__WEBPACK_IMPORTED_MODULE_0__/* ["default"].HOME */ .Z.HOME:
      return (_value, props) => props.min;
    case _util_KeyCode__WEBPACK_IMPORTED_MODULE_0__/* ["default"].PAGE_UP */ .Z.PAGE_UP:
      return (value, props) => value + props.step * 2;
    case _util_KeyCode__WEBPACK_IMPORTED_MODULE_0__/* ["default"].PAGE_DOWN */ .Z.PAGE_DOWN:
      return (value, props) => value - props.step * 2;
    default:
      return undefined;
  }
  return (value, props) => calculateNextValue(method, value, props);
}

/***/ })

}]);