@v-c/slider 1.0.0

package/dist/Slider.d.ts

@@ -0,0 +1,253 @@
+import { ExtractPropTypes, PropType } from 'vue';
+import { AriaValueFormat, SliderClassNames, SliderStyles } from './interface';
+import { MarkObj } from './Marks';
+export interface RangeConfig {
+    editable?: boolean;
+    draggableTrack?: boolean;
+    /** Set min count when `editable` */
+    minCount?: number;
+    /** Set max count when `editable` */
+    maxCount?: number;
+}
+declare function sliderProps(): {
+    prefixCls: {
+        type: StringConstructor;
+        default: string;
+    };
+    className: StringConstructor;
+    classNames: PropType<SliderClassNames>;
+    styles: PropType<SliderStyles>;
+    id: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoFocus: BooleanConstructor;
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    value: PropType<number | number[]>;
+    defaultValue: PropType<number | number[]>;
+    range: PropType<boolean | RangeConfig>;
+    count: NumberConstructor;
+    allowCross: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pushable: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    reverse: BooleanConstructor;
+    vertical: BooleanConstructor;
+    included: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    startPoint: NumberConstructor;
+    trackStyle: PropType<Record<string, any> | Record<string, any>[]>;
+    handleStyle: PropType<Record<string, any> | Record<string, any>[]>;
+    railStyle: PropType<Record<string, any>>;
+    dotStyle: PropType<Record<string, any> | ((dotValue: number) => Record<string, any>)>;
+    activeDotStyle: PropType<Record<string, any> | ((dotValue: number) => Record<string, any>)>;
+    marks: PropType<Record<string | number, any | MarkObj>>;
+    dots: BooleanConstructor;
+    handleRender: FunctionConstructor;
+    activeHandleRender: FunctionConstructor;
+    track: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tabIndex: {
+        type: PropType<number | number[]>;
+        default: number;
+    };
+    ariaLabelForHandle: PropType<string | string[]>;
+    ariaLabelledByForHandle: PropType<string | string[]>;
+    ariaRequired: BooleanConstructor;
+    ariaValueTextFormatterForHandle: PropType<AriaValueFormat | AriaValueFormat[]>;
+};
+export type SliderProps = Partial<ExtractPropTypes<ReturnType<typeof sliderProps>>>;
+export interface SliderRef {
+    focus: () => void;
+    blur: () => void;
+}
+declare const _default: import('vue').DefineComponent<ExtractPropTypes<{
+    prefixCls: {
+        type: StringConstructor;
+        default: string;
+    };
+    className: StringConstructor;
+    classNames: PropType<SliderClassNames>;
+    styles: PropType<SliderStyles>;
+    id: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoFocus: BooleanConstructor;
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    value: PropType<number | number[]>;
+    defaultValue: PropType<number | number[]>;
+    range: PropType<boolean | RangeConfig>;
+    count: NumberConstructor;
+    allowCross: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pushable: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    reverse: BooleanConstructor;
+    vertical: BooleanConstructor;
+    included: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    startPoint: NumberConstructor;
+    trackStyle: PropType<Record<string, any> | Record<string, any>[]>;
+    handleStyle: PropType<Record<string, any> | Record<string, any>[]>;
+    railStyle: PropType<Record<string, any>>;
+    dotStyle: PropType<Record<string, any> | ((dotValue: number) => Record<string, any>)>;
+    activeDotStyle: PropType<Record<string, any> | ((dotValue: number) => Record<string, any>)>;
+    marks: PropType<Record<string | number, any | MarkObj>>;
+    dots: BooleanConstructor;
+    handleRender: FunctionConstructor;
+    activeHandleRender: FunctionConstructor;
+    track: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tabIndex: {
+        type: PropType<number | number[]>;
+        default: number;
+    };
+    ariaLabelForHandle: PropType<string | string[]>;
+    ariaLabelledByForHandle: PropType<string | string[]>;
+    ariaRequired: BooleanConstructor;
+    ariaValueTextFormatterForHandle: PropType<AriaValueFormat | AriaValueFormat[]>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("focus" | "changeComplete" | "blur" | "change" | "beforeChange" | "afterChange")[], "focus" | "changeComplete" | "blur" | "change" | "beforeChange" | "afterChange", import('vue').PublicProps, Readonly<ExtractPropTypes<{
+    prefixCls: {
+        type: StringConstructor;
+        default: string;
+    };
+    className: StringConstructor;
+    classNames: PropType<SliderClassNames>;
+    styles: PropType<SliderStyles>;
+    id: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoFocus: BooleanConstructor;
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    value: PropType<number | number[]>;
+    defaultValue: PropType<number | number[]>;
+    range: PropType<boolean | RangeConfig>;
+    count: NumberConstructor;
+    allowCross: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pushable: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    reverse: BooleanConstructor;
+    vertical: BooleanConstructor;
+    included: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    startPoint: NumberConstructor;
+    trackStyle: PropType<Record<string, any> | Record<string, any>[]>;
+    handleStyle: PropType<Record<string, any> | Record<string, any>[]>;
+    railStyle: PropType<Record<string, any>>;
+    dotStyle: PropType<Record<string, any> | ((dotValue: number) => Record<string, any>)>;
+    activeDotStyle: PropType<Record<string, any> | ((dotValue: number) => Record<string, any>)>;
+    marks: PropType<Record<string | number, any | MarkObj>>;
+    dots: BooleanConstructor;
+    handleRender: FunctionConstructor;
+    activeHandleRender: FunctionConstructor;
+    track: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tabIndex: {
+        type: PropType<number | number[]>;
+        default: number;
+    };
+    ariaLabelForHandle: PropType<string | string[]>;
+    ariaLabelledByForHandle: PropType<string | string[]>;
+    ariaRequired: BooleanConstructor;
+    ariaValueTextFormatterForHandle: PropType<AriaValueFormat | AriaValueFormat[]>;
+}>> & Readonly<{
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onChangeComplete?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+    onBeforeChange?: ((...args: any[]) => any) | undefined;
+    onAfterChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    track: boolean;
+    min: number;
+    max: number;
+    prefixCls: string;
+    reverse: boolean;
+    disabled: boolean;
+    keyboard: boolean;
+    tabIndex: number | number[];
+    ariaRequired: boolean;
+    vertical: boolean;
+    included: boolean;
+    autoFocus: boolean;
+    step: number;
+    allowCross: boolean;
+    pushable: number | boolean;
+    dots: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/Slider.js

@@ -0,0 +1,343 @@
+import { defineComponent as de, ref as S, shallowRef as T, watch as ve, watchEffect as w, computed as k, isVNode as fe, createVNode as E } from "vue";
+import ge from "@v-c/util/dist/isEqual";
+import X from "@v-c/util/dist/warning";
+import W from "classnames";
+import { useProviderSliderContext as be } from "./context.js";
+import me from "./Handles/index.js";
+import he from "./hooks/useDrag.js";
+import ye from "./hooks/useOffset.js";
+import Ce from "./hooks/useRange.js";
+import xe from "./Marks/index.js";
+import Se from "./Steps/index.js";
+import ke from "./Tracks/index.js";
+function pe() {
+  return {
+    prefixCls: {
+      type: String,
+      default: "vc-slider"
+    },
+    className: String,
+    classNames: Object,
+    styles: Object,
+    id: String,
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    keyboard: {
+      type: Boolean,
+      default: !0
+    },
+    autoFocus: Boolean,
+    min: {
+      type: Number,
+      default: 0
+    },
+    max: {
+      type: Number,
+      default: 100
+    },
+    step: {
+      type: Number,
+      default: 1
+    },
+    value: [Number, Array],
+    defaultValue: [Number, Array],
+    range: [Boolean, Object],
+    count: Number,
+    allowCross: {
+      type: Boolean,
+      default: !0
+    },
+    pushable: {
+      type: [Boolean, Number],
+      default: !1
+    },
+    reverse: Boolean,
+    vertical: Boolean,
+    included: {
+      type: Boolean,
+      default: !0
+    },
+    startPoint: Number,
+    trackStyle: [Object, Array],
+    handleStyle: [Object, Array],
+    railStyle: Object,
+    dotStyle: [Object, Function],
+    activeDotStyle: [Object, Function],
+    marks: Object,
+    dots: Boolean,
+    handleRender: Function,
+    activeHandleRender: Function,
+    track: {
+      type: Boolean,
+      default: !0
+    },
+    tabIndex: {
+      type: [Number, Array],
+      default: 0
+    },
+    ariaLabelForHandle: [String, Array],
+    ariaLabelledByForHandle: [String, Array],
+    ariaRequired: Boolean,
+    ariaValueTextFormatterForHandle: [Function, Array]
+  };
+}
+const Me = /* @__PURE__ */ de({
+  name: "Slider",
+  props: {
+    ...pe()
+  },
+  emits: ["focus", "blur", "change", "beforeChange", "afterChange", "changeComplete"],
+  setup(l, {
+    attrs: Y,
+    emit: d,
+    expose: Z
+  }) {
+    const y = S(), R = S(), B = T("ltr");
+    ve([() => l.reverse, () => l.vertical], ([e, a]) => {
+      a ? B.value = e ? "ttb" : "btt" : B.value = e ? "rtl" : "ltr";
+    }, {
+      immediate: !0
+    });
+    const g = T(0), p = T(100), O = T(1), D = S([]), C = S(l.defaultValue || l.value), n = S([]), r = S(), V = S();
+    w(() => {
+      const {
+        range: e,
+        min: a,
+        max: t,
+        step: o,
+        pushable: i,
+        marks: b,
+        allowCross: x,
+        value: v,
+        count: f
+      } = l, [s, m, L, P, $] = Ce(e);
+      r.value = {
+        rangeEnabled: s,
+        rangeEditable: m,
+        rangeDraggableTrack: L,
+        minCount: P,
+        maxCount: $
+      }, g.value = isFinite(a) ? a : 0, p.value = isFinite(t) ? t : 100, O.value = o !== null && o <= 0 ? 1 : o;
+      const q = k(() => typeof i == "boolean" ? i ? O.value : !1 : i >= 0 ? i : !1);
+      D.value = Object.keys(b || {}).map((h) => {
+        const c = b?.[h], u = {
+          value: Number(h)
+        };
+        return c && typeof c == "object" && !fe(c) && ("label" in c || "style" in c) ? (u.style = c.style, u.label = c.label) : u.label = c, u;
+      }).filter(({
+        label: h
+      }) => h || typeof h == "number").sort((h, c) => h.value - c.value);
+      const [M, H] = ye(g.value, p.value, O.value, D.value, x, q.value);
+      V.value = {
+        formatValue: M,
+        offsetValues: H
+      }, v !== void 0 && (C.value = v);
+      const ce = k(() => {
+        const h = C.value === null || C.value === void 0 ? [] : Array.isArray(C.value) ? C.value : [C.value], [c = g.value] = h;
+        let u = C.value === null ? [] : [c];
+        if (s) {
+          if (u = [...h], f || C.value === void 0) {
+            const N = f >= 0 ? f + 1 : 2;
+            for (u = u.slice(0, N); u.length < N; )
+              u.push(u[u.length - 1] ?? g.value);
+          }
+          u.sort((N, z) => N - z);
+        }
+        return u.forEach((N, z) => {
+          u[z] = M(N);
+        }), u;
+      });
+      n.value = ce.value;
+    });
+    const F = (e) => r.value.rangeEnabled ? e : e[0], A = (e) => {
+      const a = [...e].sort((t, o) => t - o);
+      ge(a, n.value, !0) || d("change", F(a)), C.value = a;
+    }, _ = (e) => {
+      e && y.value?.hideHelp();
+      const a = F(n.value);
+      l.onAfterChange && (d("afterChange", a), X(!1, "[vc-slider] `onAfterChange` is deprecated. Please use `onChangeComplete` instead.")), d("changeComplete", a);
+    }, ee = (e) => {
+      if (l.disabled || !r.value.rangeEditable || n.value.length <= r.value.minCount)
+        return;
+      const a = [...n.value];
+      a.splice(e, 1), d("beforeChange", F(a)), A(a);
+      const t = Math.max(0, e - 1);
+      y.value?.hideHelp(), y.value?.focus(t);
+    }, [G, ae, le, J, K] = he(R, B, n, g, p, V.value.formatValue, A, _, V.value.offsetValues, r.value.rangeEditable, r.value.minCount), Q = (e, a) => {
+      if (!l.disabled) {
+        const t = [...n.value];
+        let o = 0, i = 0, b = p.value - g.value;
+        n.value.forEach((f, s) => {
+          const m = Math.abs(e - f);
+          m <= b && (b = m, o = s), f < e && (i = s);
+        });
+        let x = o;
+        r.value.rangeEditable && b !== 0 && (!r.value.maxCount || n.value.length < r.value.maxCount) ? (t.splice(i + 1, 0, e), x = i + 1) : t[o] = e, r.value.rangeEnabled && !n.value.length && l.count === void 0 && t.push(e);
+        const v = F(t);
+        d("beforeChange", v), A(t), a ? (document.activeElement?.blur?.(), y.value?.focus(x), K(a, x, t)) : (l.onAfterChange && (d("afterChange", v), X(!1, "[vc-slider] `onAfterChange` is deprecated. Please use `onChangeComplete` instead.")), d("changeComplete", v));
+      }
+    }, te = (e) => {
+      e.preventDefault();
+      const {
+        width: a,
+        height: t,
+        left: o,
+        top: i,
+        bottom: b,
+        right: x
+      } = R.value.getBoundingClientRect(), {
+        clientX: v,
+        clientY: f
+      } = e;
+      let s;
+      switch (B.value) {
+        case "btt":
+          s = (b - f) / t;
+          break;
+        case "ttb":
+          s = (f - i) / t;
+          break;
+        case "rtl":
+          s = (x - v) / a;
+          break;
+        default:
+          s = (v - o) / a;
+      }
+      const m = g.value + s * (p.value - g.value);
+      console.log("click", m, V.value.formatValue(m)), Q(V.value.formatValue(m), e);
+    }, j = S(null), ne = (e, a) => {
+      if (!l.disabled) {
+        const t = V.value.offsetValues(n.value, e, a);
+        d("beforeChange", F(n.value)), A(t.values), j.value = t.value;
+      }
+    };
+    w(() => {
+      if (j.value !== null) {
+        const e = n.value.indexOf(j.value);
+        e >= 0 && y.value?.focus(e);
+      }
+      j.value = null;
+    });
+    const ue = k(() => r.value.rangeDraggableTrack && O.value === null ? (process.env.NODE_ENV !== "production" && X(!1, "`draggableTrack` is not supported when `step` is `null`."), !1) : r.value.rangeDraggableTrack), U = (e, a) => {
+      console.log("onStartMove-valueIndex", a), K(e, a), d("beforeChange", F(n.value));
+    }, re = k(() => G.value !== -1);
+    w(() => {
+      if (!re.value) {
+        const e = n.value.lastIndexOf(ae.value);
+        y.value?.focus(e);
+      }
+    });
+    const I = k(() => [...J.value].sort((e, a) => e - a)), [oe, se] = k(() => r.value.rangeEnabled ? [I.value[0], I.value[I.value.length - 1]] : [g.value, I.value[0]]).value;
+    Z({
+      focus: () => {
+        y.value?.focus(0);
+      },
+      blur: () => {
+        const {
+          activeElement: e
+        } = document;
+        R.value?.contains(e) && e?.blur();
+      }
+    }), w(() => {
+      l.autoFocus && y.value?.focus(0);
+    });
+    const ie = k(() => ({
+      min: g,
+      max: p,
+      direction: B,
+      disabled: l.disabled,
+      keyboard: l.keyboard,
+      step: O,
+      included: l.included,
+      includedStart: oe,
+      includedEnd: se,
+      range: r.value.rangeEnabled,
+      tabIndex: l.tabIndex,
+      ariaLabelForHandle: l.ariaLabelForHandle,
+      ariaLabelledByForHandle: l.ariaLabelledByForHandle,
+      ariaRequired: l.ariaRequired,
+      ariaValueTextFormatterForHandle: l.ariaValueTextFormatterForHandle,
+      styles: l.styles || {},
+      classNames: l.classNames || {}
+    }));
+    return be(ie.value), () => {
+      const {
+        prefixCls: e = "vc-slider",
+        id: a,
+        // Status
+        disabled: t = !1,
+        vertical: o,
+        // Style
+        startPoint: i,
+        trackStyle: b,
+        handleStyle: x,
+        railStyle: v,
+        dotStyle: f,
+        activeDotStyle: s,
+        // Decorations
+        dots: m,
+        handleRender: L,
+        activeHandleRender: P,
+        // Components
+        track: $,
+        classNames: q,
+        styles: M
+      } = l;
+      return E("div", {
+        ref: R,
+        class: W(e, [Y.class], {
+          [`${e}-disabled`]: t,
+          [`${e}-vertical`]: o,
+          [`${e}-horizontal`]: !o,
+          [`${e}-with-marks`]: D.value.length
+        }),
+        style: Y.style,
+        onMousedown: te,
+        id: a
+      }, [E("div", {
+        class: W(`${e}-rail`, q?.rail),
+        style: {
+          ...v,
+          ...M?.rail
+        }
+      }, null), $ && E(ke, {
+        prefixCls: e,
+        trackStyle: b,
+        values: n.value,
+        startPoint: i,
+        onStartMove: ue.value ? U : void 0
+      }, null), E(Se, {
+        prefixCls: e,
+        marks: D.value,
+        dots: m,
+        style: f,
+        activeStyle: s
+      }, null), E(me, {
+        ref: y,
+        prefixCls: e,
+        handleStyle: x,
+        values: J.value,
+        draggingIndex: G.value,
+        draggingDelete: le.value,
+        onStartMove: U,
+        onOffsetChange: ne,
+        onFocus: (H) => d("focus", H),
+        onBlur: (H) => d("blur", H),
+        handleRender: L,
+        activeHandleRender: P,
+        onChangeComplete: _,
+        onDelete: r.value.rangeEditable ? ee : () => {
+        }
+      }, null), E(xe, {
+        prefixCls: e,
+        marks: D.value,
+        onClick: Q
+      }, null)]);
+    };
+  }
+});
+export {
+  Me as default
+};

package/dist/Steps/Dot.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const S=require("vue"),f=require("classnames"),m=require("../context.cjs"),g=require("../util.cjs"),p=(i,{attrs:u})=>{const{prefixCls:o,value:e,activeStyle:t}=i,{min:s,max:r,direction:a,included:d,includedStart:v,includedEnd:y}=m.useInjectSlider(),c=`${o}-dot`,n=d&&v<=e&&e<=y;let l={...g.getDirectionStyle(a.value,e,s.value,r.value)};return n&&(l={...l,...typeof t=="function"?t(e):t}),S.createVNode("span",{class:f(c,{[`${c}-active`]:n}),style:{...l,...u.style}},null)};exports.default=p;

package/dist/Steps/Dot.d.ts

@@ -0,0 +1,9 @@
+import { CSSProperties, FunctionalComponent } from 'vue';
+export interface DotProps {
+    prefixCls: string;
+    value: number;
+    style?: CSSProperties | ((dotValue: number) => CSSProperties);
+    activeStyle?: CSSProperties | ((dotValue: number) => CSSProperties);
+}
+declare const Dot: FunctionalComponent<DotProps>;
+export default Dot;

package/dist/Steps/Dot.js

@@ -0,0 +1,38 @@
+import { createVNode as p } from "vue";
+import v from "classnames";
+import { useInjectSlider as y } from "../context.js";
+import { getDirectionStyle as S } from "../util.js";
+const N = (c, {
+  attrs: n
+}) => {
+  const {
+    prefixCls: r,
+    value: e,
+    activeStyle: t
+  } = c, {
+    min: a,
+    max: s,
+    direction: d,
+    included: m,
+    includedStart: u,
+    includedEnd: f
+  } = y(), l = `${r}-dot`, i = m && u <= e && e <= f;
+  let o = {
+    ...S(d.value, e, a.value, s.value)
+  };
+  return i && (o = {
+    ...o,
+    ...typeof t == "function" ? t(e) : t
+  }), p("span", {
+    class: v(l, {
+      [`${l}-active`]: i
+    }),
+    style: {
+      ...o,
+      ...n.style
+    }
+  }, null);
+};
+export {
+  N as default
+};

package/dist/Steps/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const r=require("vue"),p=require("../context.cjs"),f=require("./Dot.cjs"),S=(u,{attrs:a})=>{const{prefixCls:l,marks:o,dots:c,activeStyle:n}=u,{min:i,max:d,step:s}=p.useInjectSlider(),v=r.computed(()=>{const e=new Set;if(o.forEach(t=>{e.add(t.value)}),c&&s!==null){let t=i.value;for(;t<=d.value;)e.add(t),t+=s.value}return Array.from(e)});return r.createVNode("div",{class:`${l}-step`},[v.value.map(e=>r.createVNode(f.default,{prefixCls:l,key:e,value:e,style:{...a.style},activeStyle:n},null))])};exports.default=S;

package/dist/Steps/index.d.ts

@@ -0,0 +1,11 @@
+import { CSSProperties, FunctionalComponent } from 'vue';
+import { InternalMarkObj } from '../Marks';
+export interface StepsProps {
+    prefixCls: string;
+    marks: InternalMarkObj[];
+    dots?: boolean;
+    style?: CSSProperties | ((dotValue: number) => CSSProperties);
+    activeStyle?: CSSProperties | ((dotValue: number) => CSSProperties);
+}
+declare const Steps: FunctionalComponent<StepsProps>;
+export default Steps;

package/dist/Steps/index.js

@@ -0,0 +1,41 @@
+import { computed as d, createVNode as s } from "vue";
+import { useInjectSlider as f } from "../context.js";
+import v from "./Dot.js";
+const h = (o, {
+  attrs: a
+}) => {
+  const {
+    prefixCls: r,
+    marks: c,
+    dots: n,
+    activeStyle: u
+  } = o, {
+    min: i,
+    max: m,
+    step: l
+  } = f(), p = d(() => {
+    const e = /* @__PURE__ */ new Set();
+    if (c.forEach((t) => {
+      e.add(t.value);
+    }), n && l !== null) {
+      let t = i.value;
+      for (; t <= m.value; )
+        e.add(t), t += l.value;
+    }
+    return Array.from(e);
+  });
+  return s("div", {
+    class: `${r}-step`
+  }, [p.value.map((e) => s(v, {
+    prefixCls: r,
+    key: e,
+    value: e,
+    style: {
+      ...a.style
+    },
+    activeStyle: u
+  }, null))]);
+};
+export {
+  h as default
+};