@v-c/slider 1.0.3 → 1.0.4

package/dist/hooks/useDrag.js

@@ -1,88 +1,157 @@
-import N from "@v-c/util/dist/hooks/useEvent";
-import { ref as r, inject as Q, onUnmounted as W, computed as Z } from "vue";
-import { UnstableContextKey as $, defaultUnstableContextValue as w } from "../context.js";
-const I = 130;
-function _(h) {
-  const C = "targetTouches" in h ? h.targetTouches[0] : h;
-  return { pageX: C.pageX, pageY: C.pageY };
+import { UnstableContextKey, defaultUnstableContextValue } from "../context.js";
+import { computed, inject, onUnmounted, ref, watch } from "vue";
+import useEvent from "@v-c/util/dist/hooks/useEvent";
+var REMOVE_DIST = 130;
+function getPosition(e) {
+	const obj = "targetTouches" in e ? e.targetTouches[0] : e;
+	return {
+		pageX: obj.pageX,
+		pageY: obj.pageY
+	};
 }
-function ne(h, C, f, T, X, y, B, K, q, R, x) {
-  const Y = r(null), c = r(-1), D = r(!1), i = r(f.value), g = r(f.value), p = r(null), E = r(null), v = r(null), z = Q($, w), { onDragStart: U, onDragChange: O } = z;
-  c.value === -1 && (i.value = f.value), W(() => {
-    document.removeEventListener("mousemove", p.value), document.removeEventListener("mouseup", E.value), v.value && (v.value.removeEventListener("touchmove", p.value), v.value.removeEventListener("touchend", E.value));
-  });
-  const j = (t, n, o) => {
-    n !== void 0 && (Y.value = n), i.value = t;
-    let a = t;
-    o && (a = t.filter((l, e) => e !== c.value)), B(a), O && O({
-      rawValues: t,
-      deleteIndex: o ? c.value : -1,
-      draggingIndex: c.value,
-      draggingValue: n
-    });
-  }, A = N(
-    (t, n, o) => {
-      if (t === -1) {
-        const a = g.value[0], l = g.value[g.value.length - 1], e = T.value - a, s = X.value - l;
-        let u = n * (X.value - T.value);
-        u = Math.max(u, e), u = Math.min(u, s), u = y(a + u) - a;
-        const m = g.value.map((d) => d + u);
-        j(m);
-      } else {
-        const a = (X.value - T.value) * n, l = [...i.value];
-        l[t] = g.value[t];
-        const e = q(l, a, t, "dist");
-        j(e.values, e.value, o);
-      }
-    }
-  ), F = (t, n, o) => {
-    t.stopPropagation();
-    const a = o || f.value, l = a[n];
-    c.value = n, Y.value = l, g.value = a, i.value = a, D.value = !1;
-    const { pageX: e, pageY: s } = _(t);
-    let u = !1;
-    U && U({
-      rawValues: a,
-      draggingIndex: n,
-      draggingValue: l
-    });
-    const V = (d) => {
-      d.preventDefault();
-      const { pageX: H, pageY: J } = _(d), M = H - e, S = J - s, { width: k, height: P } = h.value.getBoundingClientRect();
-      let L, b;
-      switch (C.value) {
-        case "btt":
-          L = -S / P, b = M;
-          break;
-        case "ttb":
-          L = S / P, b = M;
-          break;
-        case "rtl":
-          L = -M / k, b = S;
-          break;
-        default:
-          L = M / k, b = S;
-      }
-      u = R ? Math.abs(b) > I && x < i.value.length : !1, D.value = u, A(n, L, u);
-    }, m = (d) => {
-      d.preventDefault(), document.removeEventListener("mouseup", m), document.removeEventListener("mousemove", V), v.value && (v.value.removeEventListener("touchmove", p.value), v.value.removeEventListener("touchend", E.value)), p.value = null, E.value = null, v.value = null, K(u), c.value = -1, D.value = !1;
-    };
-    document.addEventListener("mouseup", m), document.addEventListener("mousemove", V), t.currentTarget.addEventListener("touchend", m), t.currentTarget.addEventListener("touchmove", V), p.value = V, E.value = m, v.value = t.currentTarget;
-  }, G = Z(() => {
-    const t = [...f.value].sort((e, s) => e - s), n = [...i.value].sort((e, s) => e - s), o = {};
-    n.forEach((e) => {
-      o[e] = (o[e] || 0) + 1;
-    }), t.forEach((e) => {
-      o[e] = (o[e] || 0) - 1;
-    });
-    const a = R ? 1 : 0;
-    return Object.values(o).reduce(
-      (e, s) => e + Math.abs(s),
-      0
-    ) <= a ? i.value : f.value;
-  });
-  return [c, Y, D, G, F];
+function useDrag(containerRef, direction, rawValues, min, max, formatValue, triggerChange, finishChange, offsetValues, editable, minCount) {
+	const draggingValue = ref(null);
+	const draggingIndex = ref(-1);
+	const draggingDelete = ref(false);
+	const cacheValues = ref(rawValues.value);
+	const originValues = ref(rawValues.value);
+	const mouseMoveEventRef = ref(null);
+	const mouseUpEventRef = ref(null);
+	const touchEventTargetRef = ref(null);
+	const { onDragStart, onDragChange } = inject(UnstableContextKey, defaultUnstableContextValue);
+	watch(rawValues, (val) => {
+		if (draggingIndex.value === -1) {
+			cacheValues.value = [...val];
+			originValues.value = [...val];
+		}
+	}, { immediate: true });
+	onUnmounted(() => {
+		document.removeEventListener("mousemove", mouseMoveEventRef.value);
+		document.removeEventListener("mouseup", mouseUpEventRef.value);
+		if (touchEventTargetRef.value) {
+			touchEventTargetRef.value.removeEventListener("touchmove", mouseMoveEventRef.value);
+			touchEventTargetRef.value.removeEventListener("touchend", mouseUpEventRef.value);
+		}
+	});
+	const flushValues = (nextValues, nextValue, deleteMark) => {
+		if (nextValue !== void 0) draggingValue.value = nextValue;
+		cacheValues.value = nextValues;
+		let changeValues = nextValues;
+		if (deleteMark) changeValues = nextValues.filter((_, i) => i !== draggingIndex.value);
+		triggerChange(changeValues);
+		if (onDragChange) onDragChange({
+			rawValues: nextValues,
+			deleteIndex: deleteMark ? draggingIndex.value : -1,
+			draggingIndex: draggingIndex.value,
+			draggingValue: nextValue
+		});
+	};
+	const updateCacheValue = useEvent((valueIndex, offsetPercent, deleteMark) => {
+		if (valueIndex === -1) {
+			const startValue = originValues.value[0];
+			const endValue = originValues.value[originValues.value.length - 1];
+			const maxStartOffset = min.value - startValue;
+			const maxEndOffset = max.value - endValue;
+			let offset = offsetPercent * (max.value - min.value);
+			offset = Math.max(offset, maxStartOffset);
+			offset = Math.min(offset, maxEndOffset);
+			offset = formatValue.value(startValue + offset) - startValue;
+			flushValues(originValues.value.map((val) => val + offset));
+		} else {
+			const offsetDist = (max.value - min.value) * offsetPercent;
+			const cloneValues = [...cacheValues.value];
+			cloneValues[valueIndex] = originValues.value[valueIndex];
+			const next = offsetValues.value(cloneValues, offsetDist, valueIndex, "dist");
+			flushValues(next.values, next.value, deleteMark);
+		}
+	});
+	const onStartMove = (e, valueIndex, startValues) => {
+		e.stopPropagation();
+		const initialValues = startValues || rawValues.value;
+		const originValue = initialValues[valueIndex];
+		draggingIndex.value = valueIndex;
+		draggingValue.value = originValue;
+		originValues.value = initialValues;
+		cacheValues.value = initialValues;
+		draggingDelete.value = false;
+		const { pageX: startX, pageY: startY } = getPosition(e);
+		let deleteMark = false;
+		if (onDragStart) onDragStart({
+			rawValues: initialValues,
+			draggingIndex: valueIndex,
+			draggingValue: originValue
+		});
+		const onMouseMove = (event) => {
+			event.preventDefault();
+			const { pageX: moveX, pageY: moveY } = getPosition(event);
+			const offsetX = moveX - startX;
+			const offsetY = moveY - startY;
+			const { width, height } = containerRef.value.getBoundingClientRect();
+			let offSetPercent;
+			let removeDist;
+			switch (direction.value) {
+				case "btt":
+					offSetPercent = -offsetY / height;
+					removeDist = offsetX;
+					break;
+				case "ttb":
+					offSetPercent = offsetY / height;
+					removeDist = offsetX;
+					break;
+				case "rtl":
+					offSetPercent = -offsetX / width;
+					removeDist = offsetY;
+					break;
+				default:
+					offSetPercent = offsetX / width;
+					removeDist = offsetY;
+			}
+			deleteMark = editable.value ? Math.abs(removeDist) > REMOVE_DIST && minCount.value < cacheValues.value.length : false;
+			draggingDelete.value = deleteMark;
+			updateCacheValue(valueIndex, offSetPercent, deleteMark);
+		};
+		const onMouseUp = (event) => {
+			event.preventDefault();
+			document.removeEventListener("mouseup", onMouseUp);
+			document.removeEventListener("mousemove", onMouseMove);
+			if (touchEventTargetRef.value) {
+				touchEventTargetRef.value.removeEventListener("touchmove", mouseMoveEventRef.value);
+				touchEventTargetRef.value.removeEventListener("touchend", mouseUpEventRef.value);
+			}
+			mouseMoveEventRef.value = null;
+			mouseUpEventRef.value = null;
+			touchEventTargetRef.value = null;
+			finishChange(deleteMark);
+			draggingIndex.value = -1;
+			draggingDelete.value = false;
+		};
+		document.addEventListener("mouseup", onMouseUp);
+		document.addEventListener("mousemove", onMouseMove);
+		e.currentTarget.addEventListener("touchend", onMouseUp);
+		e.currentTarget.addEventListener("touchmove", onMouseMove);
+		mouseMoveEventRef.value = onMouseMove;
+		mouseUpEventRef.value = onMouseUp;
+		touchEventTargetRef.value = e.currentTarget;
+	};
+	return [
+		draggingIndex,
+		draggingValue,
+		draggingDelete,
+		computed(() => {
+			const sourceValues = [...rawValues.value].sort((a, b) => a - b);
+			const targetValues = [...cacheValues.value].sort((a, b) => a - b);
+			const counts = {};
+			targetValues.forEach((val) => {
+				counts[val] = (counts[val] || 0) + 1;
+			});
+			sourceValues.forEach((val) => {
+				counts[val] = (counts[val] || 0) - 1;
+			});
+			const maxDiffCount = editable.value ? 1 : 0;
+			return Object.values(counts).reduce((prev, next) => prev + Math.abs(next), 0) <= maxDiffCount ? cacheValues.value : rawValues.value;
+		}),
+		onStartMove
+	];
 }
-export {
-  ne as default
-};
+var useDrag_default = useDrag;
+export { useDrag_default as default };

package/dist/hooks/useOffset.cjs

@@ -1 +1,124 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const P=require("vue");function _(c,a,h,b,O,V){const D=P.computed(()=>r=>Math.max(c,Math.min(a,r))).value,g=r=>{if(h!==null){const i=c+Math.round((D(r)-c)/h)*h,l=u=>(String(u).split(".")[1]||"").length,s=Math.max(l(h),l(a),l(c)),t=Number(i.toFixed(s));return c<=t&&t<=a?t:null}return null},w=r=>{const i=D(r),l=b.map(u=>u&&u.value);if(h!==null){const u=g(r);u!==null&&l.push(u)}l.push(c,a);let s=l[0],t=a-c;return l.forEach(u=>{const f=Math.abs(i-u);f<=t&&(s=u,t=f)}),s},S=(r,i,l,s="unit")=>{if(typeof i=="number"){let t;const u=r[l],f=u+i;let e=[];b.forEach(n=>{e.push(n.value)}),e.push(c,a);const o=g(u);o!==null&&e.push(o);const y=i>0?1:-1;if(s==="unit"){const n=g(u+y*h);n!==null&&e.push(n)}else{const n=g(f);n!==null&&e.push(n)}e=e.filter(n=>n!==null).filter(n=>i<0?n<=u:n>=u),s==="unit"&&(e=e.filter(n=>n!==u));const E=s==="unit"?u:f;t=e[0];let N=Math.abs(t-E);if(e.forEach(n=>{const m=Math.abs(n-E);m<N&&(t=n,N=m)}),t===void 0)return i<0?c:a;if(s==="dist")return t;if(Math.abs(i)>1){const n=[...r];return n[l]=t,S(n,i-y,l,s)}return t}else{if(i==="min")return c;if(i==="max")return a}},p=(r,i,l,s="unit")=>{const t=r[l],u=S(r,i,l,s);return{value:u,changed:u!==t}},M=r=>V===null&&r===0||typeof V=="number"&&r<V;return[w,(r,i,l,s="unit")=>{const t=r.map(w),u=t[l],f=S(t,i,l,s);if(t[l]=f,O){if(typeof V=="number"||V===null){for(let e=l+1;e<t.length;e+=1){let o=!0;for(;M(t[e]-t[e-1])&&o;)({value:t[e],changed:o}=p(t,1,e))}for(let e=l;e>0;e-=1){let o=!0;for(;M(t[e]-t[e-1])&&o;)({value:t[e-1],changed:o}=p(t,-1,e-1))}for(let e=t.length-1;e>0;e-=1){let o=!0;for(;M(t[e]-t[e-1])&&o;)({value:t[e-1],changed:o}=p(t,-1,e-1))}for(let e=0;e<t.length-1;e+=1){let o=!0;for(;M(t[e+1]-t[e])&&o;)({value:t[e+1],changed:o}=p(t,1,e+1))}}}else{const e=V||0;l>0&&t[l-1]!==u&&(t[l]=Math.max(t[l],t[l-1]+e)),l<t.length-1&&t[l+1]!==u&&(t[l]=Math.min(t[l],t[l+1]-e))}return{value:t[l],values:t}}]}exports.default=_;
+Object.defineProperty(exports, "__esModule", { value: true });
+function useOffset(min, max, step, markList, allowCross, pushable) {
+	const formatRangeValue = (val) => Math.max(min.value, Math.min(max.value, val));
+	const formatStepValue = (val) => {
+		if (step.value !== null) {
+			const stepValue = min.value + Math.round((formatRangeValue(val) - min.value) / step.value) * step.value;
+			const getDecimal = (num) => (String(num).split(".")[1] || "").length;
+			const maxDecimal = Math.max(getDecimal(step.value), getDecimal(max.value), getDecimal(min.value));
+			const fixedValue = Number(stepValue.toFixed(maxDecimal));
+			return min.value <= fixedValue && fixedValue <= max.value ? fixedValue : null;
+		}
+		return null;
+	};
+	const formatValue = (val) => {
+		const formatNextValue = formatRangeValue(val);
+		const alignValues = markList.value.map((mark) => mark && mark.value);
+		if (step.value !== null) {
+			const stepValue = formatStepValue(val);
+			if (stepValue !== null) alignValues.push(stepValue);
+		}
+		alignValues.push(min.value, max.value);
+		let closeValue = alignValues[0];
+		let closeDist = max.value - min.value;
+		alignValues.forEach((alignValue) => {
+			const dist = Math.abs(formatNextValue - alignValue);
+			if (dist <= closeDist) {
+				closeValue = alignValue;
+				closeDist = dist;
+			}
+		});
+		return closeValue;
+	};
+	const offsetValue = (values, offset, valueIndex, mode = "unit") => {
+		if (typeof offset === "number") {
+			let nextValue;
+			const originValue = values[valueIndex];
+			const targetDistValue = originValue + offset;
+			let potentialValues = [];
+			markList.value.forEach((mark) => {
+				potentialValues.push(mark.value);
+			});
+			potentialValues.push(min.value, max.value);
+			const originStepValue = formatStepValue(originValue);
+			if (originStepValue !== null) potentialValues.push(originStepValue);
+			const sign = offset > 0 ? 1 : -1;
+			if (mode === "unit") {
+				if (step.value !== null) {
+					const allStepValues = formatStepValue(originValue + sign * step.value);
+					if (allStepValues !== null) potentialValues.push(allStepValues);
+				}
+			} else if (step.value !== null) {
+				const targetStepValue = formatStepValue(targetDistValue);
+				if (targetStepValue !== null) potentialValues.push(targetStepValue);
+			}
+			potentialValues = potentialValues.filter((val) => val !== null).filter((val) => offset < 0 ? val <= originValue : val >= originValue);
+			if (mode === "unit") potentialValues = potentialValues.filter((val) => val !== originValue);
+			const compareValue = mode === "unit" ? originValue : targetDistValue;
+			nextValue = potentialValues[0];
+			let valueDist = Math.abs(nextValue - compareValue);
+			potentialValues.forEach((potentialValue) => {
+				const dist = Math.abs(potentialValue - compareValue);
+				if (dist < valueDist) {
+					nextValue = potentialValue;
+					valueDist = dist;
+				}
+			});
+			if (nextValue === void 0) return offset < 0 ? min.value : max.value;
+			if (mode === "dist") return nextValue;
+			if (Math.abs(offset) > 1) {
+				const cloneValues = [...values];
+				cloneValues[valueIndex] = nextValue;
+				return offsetValue(cloneValues, offset - sign, valueIndex, mode);
+			}
+			return nextValue;
+		}
+		if (offset === "min") return min.value;
+		if (offset === "max") return max.value;
+		return values[valueIndex];
+	};
+	const offsetChangedValue = (values, offset, valueIndex, mode = "unit") => {
+		const originValue = values[valueIndex];
+		const nextValue = offsetValue(values, offset, valueIndex, mode);
+		return {
+			value: nextValue,
+			changed: nextValue !== originValue
+		};
+	};
+	const needPush = (dist) => {
+		return pushable.value === null && dist === 0 || typeof pushable.value === "number" && dist < pushable.value;
+	};
+	const offsetValues = (values, offset, valueIndex, mode = "unit") => {
+		const nextValues = values.map(formatValue);
+		const originValue = nextValues[valueIndex];
+		nextValues[valueIndex] = offsetValue(nextValues, offset, valueIndex, mode);
+		if (!allowCross.value) {
+			const pushNum = pushable.value || 0;
+			if (valueIndex > 0 && nextValues[valueIndex - 1] !== originValue) nextValues[valueIndex] = Math.max(nextValues[valueIndex], nextValues[valueIndex - 1] + pushNum);
+			if (valueIndex < nextValues.length - 1 && nextValues[valueIndex + 1] !== originValue) nextValues[valueIndex] = Math.min(nextValues[valueIndex], nextValues[valueIndex + 1] - pushNum);
+		} else if (typeof pushable.value === "number" || pushable.value === null) {
+			for (let i = valueIndex + 1; i < nextValues.length; i += 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i], changed} = offsetChangedValue(nextValues, 1, i));
+			}
+			for (let i = valueIndex; i > 0; i -= 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i - 1], changed} = offsetChangedValue(nextValues, -1, i - 1));
+			}
+			for (let i = nextValues.length - 1; i > 0; i -= 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i - 1], changed} = offsetChangedValue(nextValues, -1, i - 1));
+			}
+			for (let i = 0; i < nextValues.length - 1; i += 1) {
+				let changed = true;
+				while (needPush(nextValues[i + 1] - nextValues[i]) && changed) ({value: nextValues[i + 1], changed} = offsetChangedValue(nextValues, 1, i + 1));
+			}
+		}
+		return {
+			value: nextValues[valueIndex],
+			values: nextValues
+		};
+	};
+	return [formatValue, offsetValues];
+}
+exports.default = useOffset;

package/dist/hooks/useOffset.d.ts

@@ -1,3 +1,4 @@
+import { Ref } from 'vue';
 import { InternalMarkObj } from '../Marks';
 /** Format value align with step & marks */
 type FormatValue = (value: number) => number;
@@ -6,5 +7,5 @@ export type OffsetValues = (values: number[], offset: number | 'min' | 'max', va
     value: number;
     values: number[];
 };
-export default function useOffset(min: number, max: number, step: number | null, markList: InternalMarkObj[], allowCross: boolean, pushable: false | number | null): [FormatValue, OffsetValues];
+export default function useOffset(min: Ref<number>, max: Ref<number>, step: Ref<number | null>, markList: Ref<InternalMarkObj[]>, allowCross: Ref<boolean>, pushable: Ref<false | number | null>): [FormatValue, OffsetValues];
 export {};

package/dist/hooks/useOffset.js

@@ -1,111 +1,123 @@
-import { computed as F } from "vue";
-function R(c, a, h, S, C, V) {
-  const w = F(() => (r) => Math.max(c, Math.min(a, r))).value, g = (r) => {
-    if (h !== null) {
-      const i = c + Math.round((w(r) - c) / h) * h, l = (n) => (String(n).split(".")[1] || "").length, o = Math.max(l(h), l(a), l(c)), t = Number(i.toFixed(o));
-      return c <= t && t <= a ? t : null;
-    }
-    return null;
-  }, b = (r) => {
-    const i = w(r), l = S.map((n) => n && n.value);
-    if (h !== null) {
-      const n = g(r);
-      n !== null && l.push(n);
-    }
-    l.push(c, a);
-    let o = l[0], t = a - c;
-    return l.forEach((n) => {
-      const f = Math.abs(i - n);
-      f <= t && (o = n, t = f);
-    }), o;
-  }, D = (r, i, l, o = "unit") => {
-    if (typeof i == "number") {
-      let t;
-      const n = r[l], f = n + i;
-      let e = [];
-      S.forEach((u) => {
-        e.push(u.value);
-      }), e.push(c, a);
-      const s = g(n);
-      s !== null && e.push(s);
-      const m = i > 0 ? 1 : -1;
-      if (o === "unit") {
-        const u = g(n + m * h);
-        u !== null && e.push(u);
-      } else {
-        const u = g(f);
-        u !== null && e.push(u);
-      }
-      e = e.filter((u) => u !== null).filter((u) => i < 0 ? u <= n : u >= n), o === "unit" && (e = e.filter((u) => u !== n));
-      const y = o === "unit" ? n : f;
-      t = e[0];
-      let E = Math.abs(t - y);
-      if (e.forEach((u) => {
-        const N = Math.abs(u - y);
-        N < E && (t = u, E = N);
-      }), t === void 0)
-        return i < 0 ? c : a;
-      if (o === "dist")
-        return t;
-      if (Math.abs(i) > 1) {
-        const u = [...r];
-        return u[l] = t, D(u, i - m, l, o);
-      }
-      return t;
-    } else {
-      if (i === "min")
-        return c;
-      if (i === "max")
-        return a;
-    }
-  }, p = (r, i, l, o = "unit") => {
-    const t = r[l], n = D(r, i, l, o);
-    return {
-      value: n,
-      changed: n !== t
-    };
-  }, M = (r) => V === null && r === 0 || typeof V == "number" && r < V;
-  return [b, (r, i, l, o = "unit") => {
-    const t = r.map(b), n = t[l], f = D(t, i, l, o);
-    if (t[l] = f, C) {
-      if (typeof V == "number" || V === null) {
-        for (let e = l + 1; e < t.length; e += 1) {
-          let s = !0;
-          for (; M(t[e] - t[e - 1]) && s; )
-            ({ value: t[e], changed: s } = p(t, 1, e));
-        }
-        for (let e = l; e > 0; e -= 1) {
-          let s = !0;
-          for (; M(t[e] - t[e - 1]) && s; )
-            ({ value: t[e - 1], changed: s } = p(t, -1, e - 1));
-        }
-        for (let e = t.length - 1; e > 0; e -= 1) {
-          let s = !0;
-          for (; M(t[e] - t[e - 1]) && s; )
-            ({ value: t[e - 1], changed: s } = p(t, -1, e - 1));
-        }
-        for (let e = 0; e < t.length - 1; e += 1) {
-          let s = !0;
-          for (; M(t[e + 1] - t[e]) && s; )
-            ({ value: t[e + 1], changed: s } = p(t, 1, e + 1));
-        }
-      }
-    } else {
-      const e = V || 0;
-      l > 0 && t[l - 1] !== n && (t[l] = Math.max(
-        t[l],
-        t[l - 1] + e
-      )), l < t.length - 1 && t[l + 1] !== n && (t[l] = Math.min(
-        t[l],
-        t[l + 1] - e
-      ));
-    }
-    return {
-      value: t[l],
-      values: t
-    };
-  }];
+function useOffset(min, max, step, markList, allowCross, pushable) {
+	const formatRangeValue = (val) => Math.max(min.value, Math.min(max.value, val));
+	const formatStepValue = (val) => {
+		if (step.value !== null) {
+			const stepValue = min.value + Math.round((formatRangeValue(val) - min.value) / step.value) * step.value;
+			const getDecimal = (num) => (String(num).split(".")[1] || "").length;
+			const maxDecimal = Math.max(getDecimal(step.value), getDecimal(max.value), getDecimal(min.value));
+			const fixedValue = Number(stepValue.toFixed(maxDecimal));
+			return min.value <= fixedValue && fixedValue <= max.value ? fixedValue : null;
+		}
+		return null;
+	};
+	const formatValue = (val) => {
+		const formatNextValue = formatRangeValue(val);
+		const alignValues = markList.value.map((mark) => mark && mark.value);
+		if (step.value !== null) {
+			const stepValue = formatStepValue(val);
+			if (stepValue !== null) alignValues.push(stepValue);
+		}
+		alignValues.push(min.value, max.value);
+		let closeValue = alignValues[0];
+		let closeDist = max.value - min.value;
+		alignValues.forEach((alignValue) => {
+			const dist = Math.abs(formatNextValue - alignValue);
+			if (dist <= closeDist) {
+				closeValue = alignValue;
+				closeDist = dist;
+			}
+		});
+		return closeValue;
+	};
+	const offsetValue = (values, offset, valueIndex, mode = "unit") => {
+		if (typeof offset === "number") {
+			let nextValue;
+			const originValue = values[valueIndex];
+			const targetDistValue = originValue + offset;
+			let potentialValues = [];
+			markList.value.forEach((mark) => {
+				potentialValues.push(mark.value);
+			});
+			potentialValues.push(min.value, max.value);
+			const originStepValue = formatStepValue(originValue);
+			if (originStepValue !== null) potentialValues.push(originStepValue);
+			const sign = offset > 0 ? 1 : -1;
+			if (mode === "unit") {
+				if (step.value !== null) {
+					const allStepValues = formatStepValue(originValue + sign * step.value);
+					if (allStepValues !== null) potentialValues.push(allStepValues);
+				}
+			} else if (step.value !== null) {
+				const targetStepValue = formatStepValue(targetDistValue);
+				if (targetStepValue !== null) potentialValues.push(targetStepValue);
+			}
+			potentialValues = potentialValues.filter((val) => val !== null).filter((val) => offset < 0 ? val <= originValue : val >= originValue);
+			if (mode === "unit") potentialValues = potentialValues.filter((val) => val !== originValue);
+			const compareValue = mode === "unit" ? originValue : targetDistValue;
+			nextValue = potentialValues[0];
+			let valueDist = Math.abs(nextValue - compareValue);
+			potentialValues.forEach((potentialValue) => {
+				const dist = Math.abs(potentialValue - compareValue);
+				if (dist < valueDist) {
+					nextValue = potentialValue;
+					valueDist = dist;
+				}
+			});
+			if (nextValue === void 0) return offset < 0 ? min.value : max.value;
+			if (mode === "dist") return nextValue;
+			if (Math.abs(offset) > 1) {
+				const cloneValues = [...values];
+				cloneValues[valueIndex] = nextValue;
+				return offsetValue(cloneValues, offset - sign, valueIndex, mode);
+			}
+			return nextValue;
+		}
+		if (offset === "min") return min.value;
+		if (offset === "max") return max.value;
+		return values[valueIndex];
+	};
+	const offsetChangedValue = (values, offset, valueIndex, mode = "unit") => {
+		const originValue = values[valueIndex];
+		const nextValue = offsetValue(values, offset, valueIndex, mode);
+		return {
+			value: nextValue,
+			changed: nextValue !== originValue
+		};
+	};
+	const needPush = (dist) => {
+		return pushable.value === null && dist === 0 || typeof pushable.value === "number" && dist < pushable.value;
+	};
+	const offsetValues = (values, offset, valueIndex, mode = "unit") => {
+		const nextValues = values.map(formatValue);
+		const originValue = nextValues[valueIndex];
+		nextValues[valueIndex] = offsetValue(nextValues, offset, valueIndex, mode);
+		if (!allowCross.value) {
+			const pushNum = pushable.value || 0;
+			if (valueIndex > 0 && nextValues[valueIndex - 1] !== originValue) nextValues[valueIndex] = Math.max(nextValues[valueIndex], nextValues[valueIndex - 1] + pushNum);
+			if (valueIndex < nextValues.length - 1 && nextValues[valueIndex + 1] !== originValue) nextValues[valueIndex] = Math.min(nextValues[valueIndex], nextValues[valueIndex + 1] - pushNum);
+		} else if (typeof pushable.value === "number" || pushable.value === null) {
+			for (let i = valueIndex + 1; i < nextValues.length; i += 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i], changed} = offsetChangedValue(nextValues, 1, i));
+			}
+			for (let i = valueIndex; i > 0; i -= 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i - 1], changed} = offsetChangedValue(nextValues, -1, i - 1));
+			}
+			for (let i = nextValues.length - 1; i > 0; i -= 1) {
+				let changed = true;
+				while (needPush(nextValues[i] - nextValues[i - 1]) && changed) ({value: nextValues[i - 1], changed} = offsetChangedValue(nextValues, -1, i - 1));
+			}
+			for (let i = 0; i < nextValues.length - 1; i += 1) {
+				let changed = true;
+				while (needPush(nextValues[i + 1] - nextValues[i]) && changed) ({value: nextValues[i + 1], changed} = offsetChangedValue(nextValues, 1, i + 1));
+			}
+		}
+		return {
+			value: nextValues[valueIndex],
+			values: nextValues
+		};
+	};
+	return [formatValue, offsetValues];
 }
-export {
-  R as default
-};
+export { useOffset as default };