init

node_modules/element-plus/lib/components/slider/src/composables/index.d.ts

@@ -0,0 +1,6 @@
+export * from './use-lifecycle';
+export * from './use-marks';
+export * from './use-slide';
+export * from './use-slider-button';
+export * from './use-stops';
+export * from './use-watch';

node_modules/element-plus/lib/components/slider/src/composables/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useLifecycle = require('./use-lifecycle.js');
+var useMarks = require('./use-marks.js');
+var useSlide = require('./use-slide.js');
+var useSliderButton = require('./use-slider-button.js');
+var useStops = require('./use-stops.js');
+var useWatch = require('./use-watch.js');
+
+
+
+exports.useLifecycle = useLifecycle.useLifecycle;
+exports.useMarks = useMarks.useMarks;
+exports.useSlide = useSlide.useSlide;
+exports.useSliderButton = useSliderButton.useSliderButton;
+exports.useStops = useStops.useStops;
+exports.useWatch = useWatch.useWatch;
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/slider/src/composables/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;"}

node_modules/element-plus/lib/components/slider/src/composables/use-lifecycle.d.ts

@@ -0,0 +1,4 @@
+import type { SliderInitData, SliderProps } from '../slider';
+export declare const useLifecycle: (props: SliderProps, initData: SliderInitData, resetSize: () => void) => {
+    sliderWrapper: import("vue").Ref<HTMLElement | undefined>;
+};

node_modules/element-plus/lib/components/slider/src/composables/use-lifecycle.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var core = require('@vueuse/core');
+var shared = require('@vue/shared');
+var types = require('../../../../utils/types.js');
+
+const useLifecycle = (props, initData, resetSize) => {
+  const sliderWrapper = vue.ref();
+  vue.onMounted(async () => {
+    if (props.range) {
+      if (shared.isArray(props.modelValue)) {
+        initData.firstValue = Math.max(props.min, props.modelValue[0]);
+        initData.secondValue = Math.min(props.max, props.modelValue[1]);
+      } else {
+        initData.firstValue = props.min;
+        initData.secondValue = props.max;
+      }
+      initData.oldValue = [initData.firstValue, initData.secondValue];
+    } else {
+      if (!types.isNumber(props.modelValue) || Number.isNaN(props.modelValue)) {
+        initData.firstValue = props.min;
+      } else {
+        initData.firstValue = Math.min(props.max, Math.max(props.min, props.modelValue));
+      }
+      initData.oldValue = initData.firstValue;
+    }
+    core.useEventListener(window, "resize", resetSize);
+    await vue.nextTick();
+    resetSize();
+  });
+  return {
+    sliderWrapper
+  };
+};
+
+exports.useLifecycle = useLifecycle;
+//# sourceMappingURL=use-lifecycle.js.map

node_modules/element-plus/lib/components/slider/src/composables/use-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-lifecycle.js","sources":["../../../../../../../packages/components/slider/src/composables/use-lifecycle.ts"],"sourcesContent":["import { nextTick, onMounted, ref } from 'vue'\nimport { useEventListener } from '@vueuse/core'\nimport { isArray, isNumber } from '@element-plus/utils'\n\nimport type { SliderInitData, SliderProps } from '../slider'\n\nexport const useLifecycle = (\n  props: SliderProps,\n  initData: SliderInitData,\n  resetSize: () => void\n) => {\n  const sliderWrapper = ref<HTMLElement>()\n\n  onMounted(async () => {\n    if (props.range) {\n      if (isArray(props.modelValue)) {\n        initData.firstValue = Math.max(props.min, props.modelValue[0])\n        initData.secondValue = Math.min(props.max, props.modelValue[1])\n      } else {\n        initData.firstValue = props.min\n        initData.secondValue = props.max\n      }\n      initData.oldValue = [initData.firstValue, initData.secondValue]\n    } else {\n      if (!isNumber(props.modelValue) || Number.isNaN(props.modelValue)) {\n        initData.firstValue = props.min\n      } else {\n        initData.firstValue = Math.min(\n          props.max,\n          Math.max(props.min, props.modelValue)\n        )\n      }\n      initData.oldValue = initData.firstValue\n    }\n\n    useEventListener(window, 'resize', resetSize)\n\n    await nextTick()\n    resetSize()\n  })\n\n  return {\n    sliderWrapper,\n  }\n}\n"],"names":["ref","onMounted","isArray","isNumber","useEventListener","nextTick"],"mappings":";;;;;;;;;AAGY,MAAC,YAAY,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,KAAK;AAC5D,EAAE,MAAM,aAAa,GAAGA,OAAG,EAAE,CAAC;AAC9B,EAAEC,aAAS,CAAC,YAAY;AACxB,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE;AACrB,MAAM,IAAIC,cAAO,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;AACrC,QAAQ,QAAQ,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AACvE,QAAQ,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,OAAO,MAAM;AACb,QAAQ,QAAQ,CAAC,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC;AACxC,QAAQ,QAAQ,CAAC,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC;AACzC,OAAO;AACP,MAAM,QAAQ,CAAC,QAAQ,GAAG,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;AACtE,KAAK,MAAM;AACX,MAAM,IAAI,CAACC,cAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;AACzE,QAAQ,QAAQ,CAAC,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC;AACxC,OAAO,MAAM;AACb,QAAQ,QAAQ,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;AACzF,OAAO;AACP,MAAM,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC;AAC9C,KAAK;AACL,IAAIC,qBAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;AAClD,IAAI,MAAMC,YAAQ,EAAE,CAAC;AACrB,IAAI,SAAS,EAAE,CAAC;AAChB,GAAG,CAAC,CAAC;AACL,EAAE,OAAO;AACT,IAAI,aAAa;AACjB,GAAG,CAAC;AACJ;;;;"}

node_modules/element-plus/lib/components/slider/src/composables/use-marks.d.ts

@@ -0,0 +1,7 @@
+import type { SliderProps } from '../slider';
+import type { SliderMarkerProps } from '../marker';
+export interface Mark extends SliderMarkerProps {
+    point: number;
+    position: number;
+}
+export declare const useMarks: (props: SliderProps) => import("vue").ComputedRef<Mark[]>;

node_modules/element-plus/lib/components/slider/src/composables/use-marks.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const useMarks = (props) => {
+  return vue.computed(() => {
+    if (!props.marks) {
+      return [];
+    }
+    const marksKeys = Object.keys(props.marks);
+    return marksKeys.map(Number.parseFloat).sort((a, b) => a - b).filter((point) => point <= props.max && point >= props.min).map((point) => ({
+      point,
+      position: (point - props.min) * 100 / (props.max - props.min),
+      mark: props.marks[point]
+    }));
+  });
+};
+
+exports.useMarks = useMarks;
+//# sourceMappingURL=use-marks.js.map

node_modules/element-plus/lib/components/slider/src/composables/use-marks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-marks.js","sources":["../../../../../../../packages/components/slider/src/composables/use-marks.ts"],"sourcesContent":["import { computed } from 'vue'\n\nimport type { SliderProps } from '../slider'\nimport type { SliderMarkerProps } from '../marker'\n\nexport interface Mark extends SliderMarkerProps {\n  point: number\n  position: number\n}\n\nexport const useMarks = (props: SliderProps) => {\n  return computed(() => {\n    if (!props.marks) {\n      return []\n    }\n\n    const marksKeys = Object.keys(props.marks)\n    return marksKeys\n      .map(Number.parseFloat)\n      .sort((a, b) => a - b)\n      .filter((point) => point <= props.max && point >= props.min)\n      .map(\n        (point): Mark => ({\n          point,\n          position: ((point - props.min) * 100) / (props.max - props.min),\n          mark: props.marks![point],\n        })\n      )\n  })\n}\n"],"names":["computed"],"mappings":";;;;;;AACY,MAAC,QAAQ,GAAG,CAAC,KAAK,KAAK;AACnC,EAAE,OAAOA,YAAQ,CAAC,MAAM;AACxB,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE;AACtB,MAAM,OAAO,EAAE,CAAC;AAChB,KAAK;AACL,IAAI,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAC/C,IAAI,OAAO,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,KAAK,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,MAAM;AAC9I,MAAM,KAAK;AACX,MAAM,QAAQ,EAAE,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,IAAI,GAAG,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;AACnE,MAAM,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC;AAC9B,KAAK,CAAC,CAAC,CAAC;AACR,GAAG,CAAC,CAAC;AACL;;;;"}

node_modules/element-plus/lib/components/slider/src/composables/use-slide.d.ts

@@ -0,0 +1,23 @@
+import type { CSSProperties, Ref, SetupContext } from 'vue';
+import type { SliderEmits, SliderInitData, SliderProps } from '../slider';
+import type { SliderButtonInstance } from '../button';
+export declare const useSlide: (props: SliderProps, initData: SliderInitData, emit: SetupContext<SliderEmits>["emit"]) => {
+    elFormItem: import("element-plus/es/components/form").FormItemContext | undefined;
+    slider: import("vue").ShallowRef<HTMLElement | undefined>;
+    firstButton: Ref<SliderButtonInstance | undefined>;
+    secondButton: Ref<SliderButtonInstance | undefined>;
+    sliderDisabled: import("vue").ComputedRef<boolean>;
+    minValue: import("vue").ComputedRef<number>;
+    maxValue: import("vue").ComputedRef<number>;
+    runwayStyle: import("vue").ComputedRef<CSSProperties>;
+    barStyle: import("vue").ComputedRef<CSSProperties>;
+    resetSize: () => void;
+    setPosition: (percent: number) => Ref<SliderButtonInstance | undefined>;
+    emitChange: () => Promise<void>;
+    onSliderWrapperPrevent: (event: TouchEvent) => void;
+    onSliderClick: (event: MouseEvent | TouchEvent) => void;
+    onSliderDown: (event: MouseEvent | TouchEvent) => Promise<void>;
+    onSliderMarkerDown: (position: number) => void;
+    setFirstValue: (firstValue: number | undefined) => void;
+    setSecondValue: (secondValue: number) => void;
+};

node_modules/element-plus/lib/components/slider/src/composables/use-slide.js

@@ -0,0 +1,156 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var useFormItem = require('../../../form/src/hooks/use-form-item.js');
+var event = require('../../../../constants/event.js');
+
+const useSlide = (props, initData, emit) => {
+  const { form: elForm, formItem: elFormItem } = useFormItem.useFormItem();
+  const slider = vue.shallowRef();
+  const firstButton = vue.ref();
+  const secondButton = vue.ref();
+  const buttonRefs = {
+    firstButton,
+    secondButton
+  };
+  const sliderDisabled = vue.computed(() => {
+    return props.disabled || (elForm == null ? void 0 : elForm.disabled) || false;
+  });
+  const minValue = vue.computed(() => {
+    return Math.min(initData.firstValue, initData.secondValue);
+  });
+  const maxValue = vue.computed(() => {
+    return Math.max(initData.firstValue, initData.secondValue);
+  });
+  const barSize = vue.computed(() => {
+    return props.range ? `${100 * (maxValue.value - minValue.value) / (props.max - props.min)}%` : `${100 * (initData.firstValue - props.min) / (props.max - props.min)}%`;
+  });
+  const barStart = vue.computed(() => {
+    return props.range ? `${100 * (minValue.value - props.min) / (props.max - props.min)}%` : "0%";
+  });
+  const runwayStyle = vue.computed(() => {
+    return props.vertical ? { height: props.height } : {};
+  });
+  const barStyle = vue.computed(() => {
+    return props.vertical ? {
+      height: barSize.value,
+      bottom: barStart.value
+    } : {
+      width: barSize.value,
+      left: barStart.value
+    };
+  });
+  const resetSize = () => {
+    if (slider.value) {
+      const rect = slider.value.getBoundingClientRect();
+      initData.sliderSize = rect[props.vertical ? "height" : "width"];
+    }
+  };
+  const getButtonRefByPercent = (percent) => {
+    const targetValue = props.min + percent * (props.max - props.min) / 100;
+    if (!props.range) {
+      return firstButton;
+    }
+    let buttonRefName;
+    if (Math.abs(minValue.value - targetValue) < Math.abs(maxValue.value - targetValue)) {
+      buttonRefName = initData.firstValue < initData.secondValue ? "firstButton" : "secondButton";
+    } else {
+      buttonRefName = initData.firstValue > initData.secondValue ? "firstButton" : "secondButton";
+    }
+    return buttonRefs[buttonRefName];
+  };
+  const setPosition = (percent) => {
+    const buttonRef = getButtonRefByPercent(percent);
+    buttonRef.value.setPosition(percent);
+    return buttonRef;
+  };
+  const setFirstValue = (firstValue) => {
+    initData.firstValue = firstValue != null ? firstValue : props.min;
+    _emit(props.range ? [minValue.value, maxValue.value] : firstValue != null ? firstValue : props.min);
+  };
+  const setSecondValue = (secondValue) => {
+    initData.secondValue = secondValue;
+    if (props.range) {
+      _emit([minValue.value, maxValue.value]);
+    }
+  };
+  const _emit = (val) => {
+    emit(event.UPDATE_MODEL_EVENT, val);
+    emit(event.INPUT_EVENT, val);
+  };
+  const emitChange = async () => {
+    await vue.nextTick();
+    emit(event.CHANGE_EVENT, props.range ? [minValue.value, maxValue.value] : props.modelValue);
+  };
+  const handleSliderPointerEvent = (event) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (sliderDisabled.value || initData.dragging)
+      return;
+    resetSize();
+    let newPercent = 0;
+    if (props.vertical) {
+      const clientY = (_c = (_b = (_a = event.touches) == null ? void 0 : _a.item(0)) == null ? void 0 : _b.clientY) != null ? _c : event.clientY;
+      const sliderOffsetBottom = slider.value.getBoundingClientRect().bottom;
+      newPercent = (sliderOffsetBottom - clientY) / initData.sliderSize * 100;
+    } else {
+      const clientX = (_f = (_e = (_d = event.touches) == null ? void 0 : _d.item(0)) == null ? void 0 : _e.clientX) != null ? _f : event.clientX;
+      const sliderOffsetLeft = slider.value.getBoundingClientRect().left;
+      newPercent = (clientX - sliderOffsetLeft) / initData.sliderSize * 100;
+    }
+    if (newPercent < 0 || newPercent > 100)
+      return;
+    return setPosition(newPercent);
+  };
+  const onSliderWrapperPrevent = (event) => {
+    var _a, _b;
+    if (((_a = buttonRefs["firstButton"].value) == null ? void 0 : _a.dragging) || ((_b = buttonRefs["secondButton"].value) == null ? void 0 : _b.dragging)) {
+      event.preventDefault();
+    }
+  };
+  const onSliderDown = async (event) => {
+    const buttonRef = handleSliderPointerEvent(event);
+    if (buttonRef) {
+      await vue.nextTick();
+      buttonRef.value.onButtonDown(event);
+    }
+  };
+  const onSliderClick = (event) => {
+    const buttonRef = handleSliderPointerEvent(event);
+    if (buttonRef) {
+      emitChange();
+    }
+  };
+  const onSliderMarkerDown = (position) => {
+    if (sliderDisabled.value || initData.dragging)
+      return;
+    const buttonRef = setPosition(position);
+    if (buttonRef) {
+      emitChange();
+    }
+  };
+  return {
+    elFormItem,
+    slider,
+    firstButton,
+    secondButton,
+    sliderDisabled,
+    minValue,
+    maxValue,
+    runwayStyle,
+    barStyle,
+    resetSize,
+    setPosition,
+    emitChange,
+    onSliderWrapperPrevent,
+    onSliderClick,
+    onSliderDown,
+    onSliderMarkerDown,
+    setFirstValue,
+    setSecondValue
+  };
+};
+
+exports.useSlide = useSlide;
+//# sourceMappingURL=use-slide.js.map

node_modules/element-plus/lib/components/slider/src/composables/use-slider-button.d.ts

@@ -0,0 +1,18 @@
+import type { CSSProperties, ComputedRef, Ref, SetupContext } from 'vue';
+import type { SliderButtonEmits, SliderButtonInitData, SliderButtonProps } from '../button';
+import type { TooltipInstance } from 'element-plus/es/components/tooltip';
+export declare const useSliderButton: (props: SliderButtonProps, initData: SliderButtonInitData, emit: SetupContext<SliderButtonEmits>["emit"]) => {
+    disabled: Ref<boolean>;
+    button: Ref<HTMLDivElement | undefined>;
+    tooltip: Ref<TooltipInstance | undefined>;
+    tooltipVisible: Ref<boolean>;
+    showTooltip: Ref<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
+    persistent: Ref<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
+    wrapperStyle: ComputedRef<CSSProperties>;
+    formatValue: ComputedRef<string | number>;
+    handleMouseEnter: () => void;
+    handleMouseLeave: () => void;
+    onButtonDown: (event: MouseEvent | TouchEvent) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    setPosition: (newPosition: number) => Promise<void>;
+};

node_modules/element-plus/lib/components/slider/src/composables/use-slider-button.js

@@ -0,0 +1,248 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var lodashUnified = require('lodash-unified');
+var core = require('@vueuse/core');
+var constants = require('../constants.js');
+var aria = require('../../../../constants/aria.js');
+var event = require('../../../../constants/event.js');
+
+const useTooltip = (props, formatTooltip, showTooltip) => {
+  const tooltip = vue.ref();
+  const tooltipVisible = vue.ref(false);
+  const enableFormat = vue.computed(() => {
+    return formatTooltip.value instanceof Function;
+  });
+  const formatValue = vue.computed(() => {
+    return enableFormat.value && formatTooltip.value(props.modelValue) || props.modelValue;
+  });
+  const displayTooltip = lodashUnified.debounce(() => {
+    showTooltip.value && (tooltipVisible.value = true);
+  }, 50);
+  const hideTooltip = lodashUnified.debounce(() => {
+    showTooltip.value && (tooltipVisible.value = false);
+  }, 50);
+  return {
+    tooltip,
+    tooltipVisible,
+    formatValue,
+    displayTooltip,
+    hideTooltip
+  };
+};
+const useSliderButton = (props, initData, emit) => {
+  const {
+    disabled,
+    min,
+    max,
+    step,
+    showTooltip,
+    persistent,
+    precision,
+    sliderSize,
+    formatTooltip,
+    emitChange,
+    resetSize,
+    updateDragging
+  } = vue.inject(constants.sliderContextKey);
+  const { tooltip, tooltipVisible, formatValue, displayTooltip, hideTooltip } = useTooltip(props, formatTooltip, showTooltip);
+  const button = vue.ref();
+  const currentPosition = vue.computed(() => {
+    return `${(props.modelValue - min.value) / (max.value - min.value) * 100}%`;
+  });
+  const wrapperStyle = vue.computed(() => {
+    return props.vertical ? { bottom: currentPosition.value } : { left: currentPosition.value };
+  });
+  const handleMouseEnter = () => {
+    initData.hovering = true;
+    displayTooltip();
+  };
+  const handleMouseLeave = () => {
+    initData.hovering = false;
+    if (!initData.dragging) {
+      hideTooltip();
+    }
+  };
+  const onButtonDown = (event) => {
+    if (disabled.value)
+      return;
+    event.preventDefault();
+    onDragStart(event);
+    window.addEventListener("mousemove", onDragging);
+    window.addEventListener("touchmove", onDragging);
+    window.addEventListener("mouseup", onDragEnd);
+    window.addEventListener("touchend", onDragEnd);
+    window.addEventListener("contextmenu", onDragEnd);
+    button.value.focus();
+  };
+  const incrementPosition = (amount) => {
+    if (disabled.value)
+      return;
+    initData.newPosition = Number.parseFloat(currentPosition.value) + amount / (max.value - min.value) * 100;
+    setPosition(initData.newPosition);
+    emitChange();
+  };
+  const onLeftKeyDown = () => {
+    incrementPosition(-step.value);
+  };
+  const onRightKeyDown = () => {
+    incrementPosition(step.value);
+  };
+  const onPageDownKeyDown = () => {
+    incrementPosition(-step.value * 4);
+  };
+  const onPageUpKeyDown = () => {
+    incrementPosition(step.value * 4);
+  };
+  const onHomeKeyDown = () => {
+    if (disabled.value)
+      return;
+    setPosition(0);
+    emitChange();
+  };
+  const onEndKeyDown = () => {
+    if (disabled.value)
+      return;
+    setPosition(100);
+    emitChange();
+  };
+  const onKeyDown = (event) => {
+    let isPreventDefault = true;
+    switch (event.code) {
+      case aria.EVENT_CODE.left:
+      case aria.EVENT_CODE.down:
+        onLeftKeyDown();
+        break;
+      case aria.EVENT_CODE.right:
+      case aria.EVENT_CODE.up:
+        onRightKeyDown();
+        break;
+      case aria.EVENT_CODE.home:
+        onHomeKeyDown();
+        break;
+      case aria.EVENT_CODE.end:
+        onEndKeyDown();
+        break;
+      case aria.EVENT_CODE.pageDown:
+        onPageDownKeyDown();
+        break;
+      case aria.EVENT_CODE.pageUp:
+        onPageUpKeyDown();
+        break;
+      default:
+        isPreventDefault = false;
+        break;
+    }
+    isPreventDefault && event.preventDefault();
+  };
+  const getClientXY = (event) => {
+    let clientX;
+    let clientY;
+    if (event.type.startsWith("touch")) {
+      clientY = event.touches[0].clientY;
+      clientX = event.touches[0].clientX;
+    } else {
+      clientY = event.clientY;
+      clientX = event.clientX;
+    }
+    return {
+      clientX,
+      clientY
+    };
+  };
+  const onDragStart = (event) => {
+    initData.dragging = true;
+    initData.isClick = true;
+    const { clientX, clientY } = getClientXY(event);
+    if (props.vertical) {
+      initData.startY = clientY;
+    } else {
+      initData.startX = clientX;
+    }
+    initData.startPosition = Number.parseFloat(currentPosition.value);
+    initData.newPosition = initData.startPosition;
+  };
+  const onDragging = (event) => {
+    if (initData.dragging) {
+      initData.isClick = false;
+      displayTooltip();
+      resetSize();
+      let diff;
+      const { clientX, clientY } = getClientXY(event);
+      if (props.vertical) {
+        initData.currentY = clientY;
+        diff = (initData.startY - initData.currentY) / sliderSize.value * 100;
+      } else {
+        initData.currentX = clientX;
+        diff = (initData.currentX - initData.startX) / sliderSize.value * 100;
+      }
+      initData.newPosition = initData.startPosition + diff;
+      setPosition(initData.newPosition);
+    }
+  };
+  const onDragEnd = () => {
+    if (initData.dragging) {
+      setTimeout(() => {
+        initData.dragging = false;
+        if (!initData.hovering) {
+          hideTooltip();
+        }
+        if (!initData.isClick) {
+          setPosition(initData.newPosition);
+        }
+        emitChange();
+      }, 0);
+      window.removeEventListener("mousemove", onDragging);
+      window.removeEventListener("touchmove", onDragging);
+      window.removeEventListener("mouseup", onDragEnd);
+      window.removeEventListener("touchend", onDragEnd);
+      window.removeEventListener("contextmenu", onDragEnd);
+    }
+  };
+  const setPosition = async (newPosition) => {
+    if (newPosition === null || Number.isNaN(+newPosition))
+      return;
+    if (newPosition < 0) {
+      newPosition = 0;
+    } else if (newPosition > 100) {
+      newPosition = 100;
+    }
+    const lengthPerStep = 100 / ((max.value - min.value) / step.value);
+    const steps = Math.round(newPosition / lengthPerStep);
+    let value = steps * lengthPerStep * (max.value - min.value) * 0.01 + min.value;
+    value = Number.parseFloat(value.toFixed(precision.value));
+    if (value !== props.modelValue) {
+      emit(event.UPDATE_MODEL_EVENT, value);
+    }
+    if (!initData.dragging && props.modelValue !== initData.oldValue) {
+      initData.oldValue = props.modelValue;
+    }
+    await vue.nextTick();
+    initData.dragging && displayTooltip();
+    tooltip.value.updatePopper();
+  };
+  vue.watch(() => initData.dragging, (val) => {
+    updateDragging(val);
+  });
+  core.useEventListener(button, "touchstart", onButtonDown, { passive: false });
+  return {
+    disabled,
+    button,
+    tooltip,
+    tooltipVisible,
+    showTooltip,
+    persistent,
+    wrapperStyle,
+    formatValue,
+    handleMouseEnter,
+    handleMouseLeave,
+    onButtonDown,
+    onKeyDown,
+    setPosition
+  };
+};
+
+exports.useSliderButton = useSliderButton;
+//# sourceMappingURL=use-slider-button.js.map

node_modules/element-plus/lib/components/slider/src/composables/use-stops.d.ts

@@ -0,0 +1,8 @@
+import type { CSSProperties, ComputedRef } from 'vue';
+import type { SliderInitData, SliderProps } from '../slider';
+type Stops = {
+    stops: ComputedRef<number[]>;
+    getStopStyle: (position: number) => CSSProperties;
+};
+export declare const useStops: (props: SliderProps, initData: SliderInitData, minValue: ComputedRef<number>, maxValue: ComputedRef<number>) => Stops;
+export {};

node_modules/element-plus/lib/components/slider/src/composables/use-stops.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const useStops = (props, initData, minValue, maxValue) => {
+  const stops = vue.computed(() => {
+    if (!props.showStops || props.min > props.max)
+      return [];
+    if (props.step === 0) {
+      return [];
+    }
+    const stopCount = (props.max - props.min) / props.step;
+    const stepWidth = 100 * props.step / (props.max - props.min);
+    const result = Array.from({ length: stopCount - 1 }).map((_, index) => (index + 1) * stepWidth);
+    if (props.range) {
+      return result.filter((step) => {
+        return step < 100 * (minValue.value - props.min) / (props.max - props.min) || step > 100 * (maxValue.value - props.min) / (props.max - props.min);
+      });
+    } else {
+      return result.filter((step) => step > 100 * (initData.firstValue - props.min) / (props.max - props.min));
+    }
+  });
+  const getStopStyle = (position) => {
+    return props.vertical ? { bottom: `${position}%` } : { left: `${position}%` };
+  };
+  return {
+    stops,
+    getStopStyle
+  };
+};
+
+exports.useStops = useStops;
+//# sourceMappingURL=use-stops.js.map

node_modules/element-plus/lib/components/slider/src/composables/use-stops.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stops.js","sources":["../../../../../../../packages/components/slider/src/composables/use-stops.ts"],"sourcesContent":["import { computed } from 'vue'\nimport { debugWarn } from '@element-plus/utils'\n\nimport type { CSSProperties, ComputedRef } from 'vue'\nimport type { SliderInitData, SliderProps } from '../slider'\n\ntype Stops = {\n  stops: ComputedRef<number[]>\n  getStopStyle: (position: number) => CSSProperties\n}\n\nexport const useStops = (\n  props: SliderProps,\n  initData: SliderInitData,\n  minValue: ComputedRef<number>,\n  maxValue: ComputedRef<number>\n): Stops => {\n  const stops = computed(() => {\n    if (!props.showStops || props.min > props.max) return []\n    if (props.step === 0) {\n      debugWarn('ElSlider', 'step should not be 0.')\n      return []\n    }\n\n    const stopCount = (props.max - props.min) / props.step\n    const stepWidth = (100 * props.step) / (props.max - props.min)\n    const result = Array.from<number>({ length: stopCount - 1 }).map(\n      (_, index) => (index + 1) * stepWidth\n    )\n\n    if (props.range) {\n      return result.filter((step) => {\n        return (\n          step <\n            (100 * (minValue.value - props.min)) / (props.max - props.min) ||\n          step > (100 * (maxValue.value - props.min)) / (props.max - props.min)\n        )\n      })\n    } else {\n      return result.filter(\n        (step) =>\n          step >\n          (100 * (initData.firstValue - props.min)) / (props.max - props.min)\n      )\n    }\n  })\n\n  const getStopStyle = (position: number): CSSProperties => {\n    return props.vertical\n      ? { bottom: `${position}%` }\n      : { left: `${position}%` }\n  }\n\n  return {\n    stops,\n    getStopStyle,\n  }\n}\n"],"names":["computed"],"mappings":";;;;;;AAEY,MAAC,QAAQ,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,KAAK;AACjE,EAAE,MAAM,KAAK,GAAGA,YAAQ,CAAC,MAAM;AAC/B,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG;AACjD,MAAM,OAAO,EAAE,CAAC;AAChB,IAAI,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC,EAAE;AAE1B,MAAM,OAAO,EAAE,CAAC;AAChB,KAAK;AACL,IAAI,MAAM,SAAS,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC;AAC3D,IAAI,MAAM,SAAS,GAAG,GAAG,GAAG,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AACjE,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,SAAS,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,CAAC,KAAK,GAAG,CAAC,IAAI,SAAS,CAAC,CAAC;AACpG,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE;AACrB,MAAM,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,KAAK;AACrC,QAAQ,OAAO,IAAI,GAAG,GAAG,IAAI,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,IAAI,GAAG,GAAG,IAAI,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AAC1J,OAAO,CAAC,CAAC;AACT,KAAK,MAAM;AACX,MAAM,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,KAAK,IAAI,GAAG,GAAG,IAAI,QAAQ,CAAC,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/G,KAAK;AACL,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,YAAY,GAAG,CAAC,QAAQ,KAAK;AACrC,IAAI,OAAO,KAAK,CAAC,QAAQ,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;AAClF,GAAG,CAAC;AACJ,EAAE,OAAO;AACT,IAAI,KAAK;AACT,IAAI,YAAY;AAChB,GAAG,CAAC;AACJ;;;;"}

node_modules/element-plus/lib/components/slider/src/composables/use-watch.d.ts

@@ -0,0 +1,4 @@
+import type { ComputedRef, SetupContext } from 'vue';
+import type { FormItemContext } from 'element-plus/es/components/form';
+import type { SliderEmits, SliderInitData, SliderProps } from '../slider';
+export declare const useWatch: (props: SliderProps, initData: SliderInitData, minValue: ComputedRef<number>, maxValue: ComputedRef<number>, emit: SetupContext<SliderEmits>["emit"], elFormItem: FormItemContext) => void;

node_modules/element-plus/lib/components/slider/src/composables/use-watch.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var shared = require('@vue/shared');
+var error = require('../../../../utils/error.js');
+var types = require('../../../../utils/types.js');
+var event = require('../../../../constants/event.js');
+
+const useWatch = (props, initData, minValue, maxValue, emit, elFormItem) => {
+  const _emit = (val) => {
+    emit(event.UPDATE_MODEL_EVENT, val);
+    emit(event.INPUT_EVENT, val);
+  };
+  const valueChanged = () => {
+    if (props.range) {
+      return ![minValue.value, maxValue.value].every((item, index) => item === initData.oldValue[index]);
+    } else {
+      return props.modelValue !== initData.oldValue;
+    }
+  };
+  const setValues = () => {
+    var _a, _b;
+    if (props.min > props.max) {
+      error.throwError("Slider", "min should not be greater than max.");
+    }
+    const val = props.modelValue;
+    if (props.range && shared.isArray(val)) {
+      if (val[1] < props.min) {
+        _emit([props.min, props.min]);
+      } else if (val[0] > props.max) {
+        _emit([props.max, props.max]);
+      } else if (val[0] < props.min) {
+        _emit([props.min, val[1]]);
+      } else if (val[1] > props.max) {
+        _emit([val[0], props.max]);
+      } else {
+        initData.firstValue = val[0];
+        initData.secondValue = val[1];
+        if (valueChanged()) {
+          if (props.validateEvent) {
+            (_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "change").catch((err) => error.debugWarn());
+          }
+          initData.oldValue = val.slice();
+        }
+      }
+    } else if (!props.range && types.isNumber(val) && !Number.isNaN(val)) {
+      if (val < props.min) {
+        _emit(props.min);
+      } else if (val > props.max) {
+        _emit(props.max);
+      } else {
+        initData.firstValue = val;
+        if (valueChanged()) {
+          if (props.validateEvent) {
+            (_b = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _b.call(elFormItem, "change").catch((err) => error.debugWarn());
+          }
+          initData.oldValue = val;
+        }
+      }
+    }
+  };
+  setValues();
+  vue.watch(() => initData.dragging, (val) => {
+    if (!val) {
+      setValues();
+    }
+  });
+  vue.watch(() => props.modelValue, (val, oldVal) => {
+    if (initData.dragging || shared.isArray(val) && shared.isArray(oldVal) && val.every((item, index) => item === oldVal[index]) && initData.firstValue === val[0] && initData.secondValue === val[1]) {
+      return;
+    }
+    setValues();
+  }, {
+    deep: true
+  });
+  vue.watch(() => [props.min, props.max], () => {
+    setValues();
+  });
+};
+
+exports.useWatch = useWatch;
+//# sourceMappingURL=use-watch.js.map