pangu-vchart-config 1.0.16

package/dist/es/3CIt7twC.js

@@ -0,0 +1,862 @@
+import { defineComponent as te, ref as ee, reactive as Pe, computed as y, watch as ie, onMounted as Ke, onUpdated as Ge, createElementBlock as R, openBlock as E, withModifiers as Ve, normalizeClass as Y, unref as t, withDirectives as Te, createCommentVNode as ne, createVNode as de, withKeys as fe, renderSlot as ve, withCtx as ae, createBlock as Z, createSlots as Qe, inject as qe, nextTick as he, toRefs as Be, normalizeStyle as le, createElementVNode as re, toDisplayString as Je, h as Ze, shallowRef as De, provide as et, Fragment as be, renderList as ke } from "vue";
+import { F, q as ce, H as pe, J as Ae, O as xe, t as Ce, a7 as Re, j as Se, S as Ye, a9 as ge, Q as Oe, R as tt, $ as _e, af as lt, aO as nt, aP as at, aQ as rt, aM as Xe, G as Ie, U as ye, w as Ue, l as me, M as se, a4 as we, ac as Fe, ad as G, T as ot } from "./CZX0y1vH.js";
+import { E as ut } from "./B2ZPB63x.js";
+import { U as X, I as D, C as Ne } from "./Xd-jNBs0.js";
+import { v as ze } from "./SP-QkSWp.js";
+import { i as st } from "./DqKUQMLq.js";
+import { E as We, a as it } from "./ISPVPzp5.js";
+const dt = pe({
+  id: {
+    type: String,
+    default: void 0
+  },
+  step: {
+    type: Number,
+    default: 1
+  },
+  stepStrictly: Boolean,
+  max: {
+    type: Number,
+    default: Number.POSITIVE_INFINITY
+  },
+  min: {
+    type: Number,
+    default: Number.NEGATIVE_INFINITY
+  },
+  modelValue: Number,
+  readonly: Boolean,
+  disabled: Boolean,
+  size: xe,
+  controls: {
+    type: Boolean,
+    default: !0
+  },
+  controlsPosition: {
+    type: String,
+    default: "",
+    values: ["", "right"]
+  },
+  valueOnClear: {
+    type: [String, Number, null],
+    validator: (e) => e === null || F(e) || ["min", "max"].includes(e),
+    default: null
+  },
+  name: String,
+  placeholder: String,
+  precision: {
+    type: Number,
+    validator: (e) => e >= 0 && e === Number.parseInt(`${e}`, 10)
+  },
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  ...Ae(["ariaLabel"])
+}), ct = {
+  [Ne]: (e, l) => l !== e,
+  blur: (e) => e instanceof FocusEvent,
+  focus: (e) => e instanceof FocusEvent,
+  [D]: (e) => F(e) || ce(e),
+  [X]: (e) => F(e) || ce(e)
+}, mt = te({
+  name: "ElInputNumber"
+}), ft = /* @__PURE__ */ te({
+  ...mt,
+  props: dt,
+  emits: ct,
+  setup(e, { expose: l, emit: o }) {
+    const a = e, { t: v } = Re(), c = Se("input-number"), s = ee(), u = Pe({
+      currentValue: a.modelValue,
+      userInput: null
+    }), { formItem: w } = Ye(), b = y(() => F(a.modelValue) && a.modelValue <= a.min), p = y(() => F(a.modelValue) && a.modelValue >= a.max), i = y(() => {
+      const n = $(a.step);
+      return ge(a.precision) ? Math.max($(a.modelValue), n) : (n > a.precision, a.precision);
+    }), B = y(() => a.controls && a.controlsPosition === "right"), z = Oe(), M = tt(), K = y(() => {
+      if (u.userInput !== null)
+        return u.userInput;
+      let n = u.currentValue;
+      if (ce(n))
+        return "";
+      if (F(n)) {
+        if (Number.isNaN(n))
+          return "";
+        ge(a.precision) || (n = n.toFixed(a.precision));
+      }
+      return n;
+    }), T = (n, r) => {
+      if (ge(r) && (r = i.value), r === 0)
+        return Math.round(n);
+      let d = String(n);
+      const S = d.indexOf(".");
+      if (S === -1 || !d.replace(".", "").split("")[S + r])
+        return n;
+      const x = d.length;
+      return d.charAt(x - 1) === "5" && (d = `${d.slice(0, Math.max(0, x - 1))}6`), Number.parseFloat(Number(d).toFixed(r));
+    }, $ = (n) => {
+      if (ce(n))
+        return 0;
+      const r = n.toString(), d = r.indexOf(".");
+      let S = 0;
+      return d !== -1 && (S = r.length - d - 1), S;
+    }, I = (n, r = 1) => F(n) ? T(n + a.step * r) : u.currentValue, L = () => {
+      if (a.readonly || M.value || p.value)
+        return;
+      const n = Number(K.value) || 0, r = I(n);
+      A(r), o(D, u.currentValue), k();
+    }, P = () => {
+      if (a.readonly || M.value || b.value)
+        return;
+      const n = Number(K.value) || 0, r = I(n, -1);
+      A(r), o(D, u.currentValue), k();
+    }, U = (n, r) => {
+      const { max: d, min: S, step: h, precision: N, stepStrictly: x, valueOnClear: f } = a;
+      d < S && Xe("InputNumber", "min should not be greater than max.");
+      let m = Number(n);
+      if (ce(n) || Number.isNaN(m))
+        return null;
+      if (n === "") {
+        if (f === null)
+          return null;
+        m = Ie(f) ? { min: S, max: d }[f] : f;
+      }
+      return x && (m = T(Math.round(m / h) * h, N), m !== n && r && o(X, m)), ge(N) || (m = T(m, N)), (m > d || m < S) && (m = m > d ? d : S, r && o(X, m)), m;
+    }, A = (n, r = !0) => {
+      var d;
+      const S = u.currentValue, h = U(n);
+      if (!r) {
+        o(X, h);
+        return;
+      }
+      S === h && n || (u.userInput = null, o(X, h), S !== h && o(Ne, h, S), a.validateEvent && ((d = w?.validate) == null || d.call(w, "change").catch((N) => ye())), u.currentValue = h);
+    }, j = (n) => {
+      u.userInput = n;
+      const r = n === "" ? null : Number(n);
+      o(D, r), A(r, !1);
+    }, Q = (n) => {
+      const r = n !== "" ? Number(n) : "";
+      (F(r) && !Number.isNaN(r) || n === "") && A(r), k(), u.userInput = null;
+    }, O = () => {
+      var n, r;
+      (r = (n = s.value) == null ? void 0 : n.focus) == null || r.call(n);
+    }, q = () => {
+      var n, r;
+      (r = (n = s.value) == null ? void 0 : n.blur) == null || r.call(n);
+    }, W = (n) => {
+      o("focus", n);
+    }, g = (n) => {
+      var r, d;
+      u.userInput = null, st() && u.currentValue === null && ((r = s.value) != null && r.input) && (s.value.input.value = ""), o("blur", n), a.validateEvent && ((d = w?.validate) == null || d.call(w, "blur").catch((S) => ye()));
+    }, k = () => {
+      u.currentValue !== a.modelValue && (u.currentValue = a.modelValue);
+    }, C = (n) => {
+      document.activeElement === n.target && n.preventDefault();
+    };
+    return ie(() => a.modelValue, (n, r) => {
+      const d = U(n, !0);
+      u.userInput === null && d !== r && (u.currentValue = d);
+    }, { immediate: !0 }), Ke(() => {
+      var n;
+      const { min: r, max: d, modelValue: S } = a, h = (n = s.value) == null ? void 0 : n.input;
+      if (h.setAttribute("role", "spinbutton"), Number.isFinite(d) ? h.setAttribute("aria-valuemax", String(d)) : h.removeAttribute("aria-valuemax"), Number.isFinite(r) ? h.setAttribute("aria-valuemin", String(r)) : h.removeAttribute("aria-valuemin"), h.setAttribute("aria-valuenow", u.currentValue || u.currentValue === 0 ? String(u.currentValue) : ""), h.setAttribute("aria-disabled", String(M.value)), !F(S) && S != null) {
+        let N = Number(S);
+        Number.isNaN(N) && (N = null), o(X, N);
+      }
+      h.addEventListener("wheel", C, { passive: !1 });
+    }), Ge(() => {
+      var n, r;
+      const d = (n = s.value) == null ? void 0 : n.input;
+      d?.setAttribute("aria-valuenow", `${(r = u.currentValue) != null ? r : ""}`);
+    }), l({
+      focus: O,
+      blur: q
+    }), (n, r) => (E(), R("div", {
+      class: Y([
+        t(c).b(),
+        t(c).m(t(z)),
+        t(c).is("disabled", t(M)),
+        t(c).is("without-controls", !n.controls),
+        t(c).is("controls-right", t(B))
+      ]),
+      onDragstart: Ve(() => {
+      }, ["prevent"])
+    }, [
+      n.controls ? Te((E(), R("span", {
+        key: 0,
+        role: "button",
+        "aria-label": t(v)("el.inputNumber.decrease"),
+        class: Y([t(c).e("decrease"), t(c).is("disabled", t(b))]),
+        onKeydown: fe(P, ["enter"])
+      }, [
+        ve(n.$slots, "decrease-icon", {}, () => [
+          de(t(_e), null, {
+            default: ae(() => [
+              t(B) ? (E(), Z(t(lt), { key: 0 })) : (E(), Z(t(nt), { key: 1 }))
+            ]),
+            _: 1
+          })
+        ])
+      ], 42, ["aria-label", "onKeydown"])), [
+        [t(ze), P]
+      ]) : ne("v-if", !0),
+      n.controls ? Te((E(), R("span", {
+        key: 1,
+        role: "button",
+        "aria-label": t(v)("el.inputNumber.increase"),
+        class: Y([t(c).e("increase"), t(c).is("disabled", t(p))]),
+        onKeydown: fe(L, ["enter"])
+      }, [
+        ve(n.$slots, "increase-icon", {}, () => [
+          de(t(_e), null, {
+            default: ae(() => [
+              t(B) ? (E(), Z(t(at), { key: 0 })) : (E(), Z(t(rt), { key: 1 }))
+            ]),
+            _: 1
+          })
+        ])
+      ], 42, ["aria-label", "onKeydown"])), [
+        [t(ze), L]
+      ]) : ne("v-if", !0),
+      de(t(ut), {
+        id: n.id,
+        ref_key: "input",
+        ref: s,
+        type: "number",
+        step: n.step,
+        "model-value": t(K),
+        placeholder: n.placeholder,
+        readonly: n.readonly,
+        disabled: t(M),
+        size: t(z),
+        max: n.max,
+        min: n.min,
+        name: n.name,
+        "aria-label": n.ariaLabel,
+        "validate-event": !1,
+        onKeydown: [
+          fe(Ve(L, ["prevent"]), ["up"]),
+          fe(Ve(P, ["prevent"]), ["down"])
+        ],
+        onBlur: g,
+        onFocus: W,
+        onInput: j,
+        onChange: Q
+      }, Qe({
+        _: 2
+      }, [
+        n.$slots.prefix ? {
+          name: "prefix",
+          fn: ae(() => [
+            ve(n.$slots, "prefix")
+          ])
+        } : void 0,
+        n.$slots.suffix ? {
+          name: "suffix",
+          fn: ae(() => [
+            ve(n.$slots, "suffix")
+          ])
+        } : void 0
+      ]), 1032, ["id", "step", "model-value", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "aria-label", "onKeydown"])
+    ], 42, ["onDragstart"]));
+  }
+});
+var vt = /* @__PURE__ */ Ce(ft, [["__file", "input-number.vue"]]);
+const bt = Ue(vt), je = Symbol("sliderContextKey"), gt = pe({
+  modelValue: {
+    type: se([Number, Array]),
+    default: 0
+  },
+  id: {
+    type: String,
+    default: void 0
+  },
+  min: {
+    type: Number,
+    default: 0
+  },
+  max: {
+    type: Number,
+    default: 100
+  },
+  step: {
+    type: Number,
+    default: 1
+  },
+  showInput: Boolean,
+  showInputControls: {
+    type: Boolean,
+    default: !0
+  },
+  size: xe,
+  inputSize: xe,
+  showStops: Boolean,
+  showTooltip: {
+    type: Boolean,
+    default: !0
+  },
+  formatTooltip: {
+    type: se(Function),
+    default: void 0
+  },
+  disabled: Boolean,
+  range: Boolean,
+  vertical: Boolean,
+  height: String,
+  debounce: {
+    type: Number,
+    default: 300
+  },
+  rangeStartLabel: {
+    type: String,
+    default: void 0
+  },
+  rangeEndLabel: {
+    type: String,
+    default: void 0
+  },
+  formatValueText: {
+    type: se(Function),
+    default: void 0
+  },
+  tooltipClass: {
+    type: String,
+    default: void 0
+  },
+  placement: {
+    type: String,
+    values: We,
+    default: "top"
+  },
+  marks: {
+    type: se(Object)
+  },
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  ...Ae(["ariaLabel"])
+}), Ee = (e) => F(e) || me(e) && e.every(F), Vt = {
+  [X]: Ee,
+  [D]: Ee,
+  [Ne]: Ee
+}, ht = pe({
+  modelValue: {
+    type: Number,
+    default: 0
+  },
+  vertical: Boolean,
+  tooltipClass: String,
+  placement: {
+    type: String,
+    values: We,
+    default: "top"
+  }
+}), yt = {
+  [X]: (e) => F(e)
+}, wt = (e, l, o) => {
+  const a = ee(), v = ee(!1), c = y(() => l.value instanceof Function), s = y(() => c.value && l.value(e.modelValue) || e.modelValue), u = Fe(() => {
+    o.value && (v.value = !0);
+  }, 50), w = Fe(() => {
+    o.value && (v.value = !1);
+  }, 50);
+  return {
+    tooltip: a,
+    tooltipVisible: v,
+    formatValue: s,
+    displayTooltip: u,
+    hideTooltip: w
+  };
+}, pt = (e, l, o) => {
+  const {
+    disabled: a,
+    min: v,
+    max: c,
+    step: s,
+    showTooltip: u,
+    precision: w,
+    sliderSize: b,
+    formatTooltip: p,
+    emitChange: i,
+    resetSize: B,
+    updateDragging: z
+  } = qe(je), { tooltip: M, tooltipVisible: K, formatValue: T, displayTooltip: $, hideTooltip: I } = wt(e, p, u), L = ee(), P = y(() => `${(e.modelValue - v.value) / (c.value - v.value) * 100}%`), U = y(() => e.vertical ? { bottom: P.value } : { left: P.value }), A = () => {
+    l.hovering = !0, $();
+  }, j = () => {
+    l.hovering = !1, l.dragging || I();
+  }, Q = (f) => {
+    a.value || (f.preventDefault(), S(f), window.addEventListener("mousemove", h), window.addEventListener("touchmove", h), window.addEventListener("mouseup", N), window.addEventListener("touchend", N), window.addEventListener("contextmenu", N), L.value.focus());
+  }, O = (f) => {
+    a.value || (l.newPosition = Number.parseFloat(P.value) + f / (c.value - v.value) * 100, x(l.newPosition), i());
+  }, q = () => {
+    O(-s.value);
+  }, W = () => {
+    O(s.value);
+  }, g = () => {
+    O(-s.value * 4);
+  }, k = () => {
+    O(s.value * 4);
+  }, C = () => {
+    a.value || (x(0), i());
+  }, n = () => {
+    a.value || (x(100), i());
+  }, r = (f) => {
+    let m = !0;
+    switch (f.code) {
+      case G.left:
+      case G.down:
+        q();
+        break;
+      case G.right:
+      case G.up:
+        W();
+        break;
+      case G.home:
+        C();
+        break;
+      case G.end:
+        n();
+        break;
+      case G.pageDown:
+        g();
+        break;
+      case G.pageUp:
+        k();
+        break;
+      default:
+        m = !1;
+        break;
+    }
+    m && f.preventDefault();
+  }, d = (f) => {
+    let m, _;
+    return f.type.startsWith("touch") ? (_ = f.touches[0].clientY, m = f.touches[0].clientX) : (_ = f.clientY, m = f.clientX), {
+      clientX: m,
+      clientY: _
+    };
+  }, S = (f) => {
+    l.dragging = !0, l.isClick = !0;
+    const { clientX: m, clientY: _ } = d(f);
+    e.vertical ? l.startY = _ : l.startX = m, l.startPosition = Number.parseFloat(P.value), l.newPosition = l.startPosition;
+  }, h = (f) => {
+    if (l.dragging) {
+      l.isClick = !1, $(), B();
+      let m;
+      const { clientX: _, clientY: H } = d(f);
+      e.vertical ? (l.currentY = H, m = (l.startY - l.currentY) / b.value * 100) : (l.currentX = _, m = (l.currentX - l.startX) / b.value * 100), l.newPosition = l.startPosition + m, x(l.newPosition);
+    }
+  }, N = () => {
+    l.dragging && (setTimeout(() => {
+      l.dragging = !1, l.hovering || I(), l.isClick || x(l.newPosition), i();
+    }, 0), window.removeEventListener("mousemove", h), window.removeEventListener("touchmove", h), window.removeEventListener("mouseup", N), window.removeEventListener("touchend", N), window.removeEventListener("contextmenu", N));
+  }, x = async (f) => {
+    if (f === null || Number.isNaN(+f))
+      return;
+    f < 0 ? f = 0 : f > 100 && (f = 100);
+    const m = 100 / ((c.value - v.value) / s.value);
+    let H = Math.round(f / m) * m * (c.value - v.value) * 0.01 + v.value;
+    H = Number.parseFloat(H.toFixed(w.value)), H !== e.modelValue && o(X, H), !l.dragging && e.modelValue !== l.oldValue && (l.oldValue = e.modelValue), await he(), l.dragging && $(), M.value.updatePopper();
+  };
+  return ie(() => l.dragging, (f) => {
+    z(f);
+  }), we(L, "touchstart", Q, { passive: !1 }), {
+    disabled: a,
+    button: L,
+    tooltip: M,
+    tooltipVisible: K,
+    showTooltip: u,
+    wrapperStyle: U,
+    formatValue: T,
+    handleMouseEnter: A,
+    handleMouseLeave: j,
+    onButtonDown: Q,
+    onKeyDown: r,
+    setPosition: x
+  };
+}, St = te({
+  name: "ElSliderButton"
+}), Nt = /* @__PURE__ */ te({
+  ...St,
+  props: ht,
+  emits: yt,
+  setup(e, { expose: l, emit: o }) {
+    const a = e, v = Se("slider"), c = Pe({
+      hovering: !1,
+      dragging: !1,
+      isClick: !1,
+      startX: 0,
+      currentX: 0,
+      startY: 0,
+      currentY: 0,
+      startPosition: 0,
+      newPosition: 0,
+      oldValue: a.modelValue
+    }), {
+      disabled: s,
+      button: u,
+      tooltip: w,
+      showTooltip: b,
+      tooltipVisible: p,
+      wrapperStyle: i,
+      formatValue: B,
+      handleMouseEnter: z,
+      handleMouseLeave: M,
+      onButtonDown: K,
+      onKeyDown: T,
+      setPosition: $
+    } = pt(a, c, o), { hovering: I, dragging: L } = Be(c);
+    return l({
+      onButtonDown: K,
+      onKeyDown: T,
+      setPosition: $,
+      hovering: I,
+      dragging: L
+    }), (P, U) => (E(), R("div", {
+      ref_key: "button",
+      ref: u,
+      class: Y([t(v).e("button-wrapper"), { hover: t(I), dragging: t(L) }]),
+      style: le(t(i)),
+      tabindex: t(s) ? -1 : 0,
+      onMouseenter: t(z),
+      onMouseleave: t(M),
+      onMousedown: t(K),
+      onFocus: t(z),
+      onBlur: t(M),
+      onKeydown: t(T)
+    }, [
+      de(t(it), {
+        ref_key: "tooltip",
+        ref: w,
+        visible: t(p),
+        placement: P.placement,
+        "fallback-placements": ["top", "bottom", "right", "left"],
+        "stop-popper-mouse-event": !1,
+        "popper-class": P.tooltipClass,
+        disabled: !t(b),
+        persistent: t(b)
+      }, {
+        content: ae(() => [
+          re("span", null, Je(t(B)), 1)
+        ]),
+        default: ae(() => [
+          re("div", {
+            class: Y([t(v).e("button"), { hover: t(I), dragging: t(L) }])
+          }, null, 2)
+        ]),
+        _: 1
+      }, 8, ["visible", "placement", "popper-class", "disabled", "persistent"])
+    ], 46, ["tabindex", "onMouseenter", "onMouseleave", "onMousedown", "onFocus", "onBlur", "onKeydown"]));
+  }
+});
+var $e = /* @__PURE__ */ Ce(Nt, [["__file", "button.vue"]]);
+const kt = pe({
+  mark: {
+    type: se([String, Object]),
+    default: void 0
+  }
+});
+var Et = te({
+  name: "ElSliderMarker",
+  props: kt,
+  setup(e) {
+    const l = Se("slider"), o = y(() => Ie(e.mark) ? e.mark : e.mark.label), a = y(() => Ie(e.mark) ? void 0 : e.mark.style);
+    return () => Ze("div", {
+      class: l.e("marks-text"),
+      style: a.value
+    }, o.value);
+  }
+});
+const Bt = (e, l, o) => {
+  const { form: a, formItem: v } = Ye(), c = De(), s = ee(), u = ee(), w = {
+    firstButton: s,
+    secondButton: u
+  }, b = y(() => e.disabled || a?.disabled || !1), p = y(() => Math.min(l.firstValue, l.secondValue)), i = y(() => Math.max(l.firstValue, l.secondValue)), B = y(() => e.range ? `${100 * (i.value - p.value) / (e.max - e.min)}%` : `${100 * (l.firstValue - e.min) / (e.max - e.min)}%`), z = y(() => e.range ? `${100 * (p.value - e.min) / (e.max - e.min)}%` : "0%"), M = y(() => e.vertical ? { height: e.height } : {}), K = y(() => e.vertical ? {
+    height: B.value,
+    bottom: z.value
+  } : {
+    width: B.value,
+    left: z.value
+  }), T = () => {
+    c.value && (l.sliderSize = c.value[`client${e.vertical ? "Height" : "Width"}`]);
+  }, $ = (g) => {
+    const k = e.min + g * (e.max - e.min) / 100;
+    if (!e.range)
+      return s;
+    let C;
+    return Math.abs(p.value - k) < Math.abs(i.value - k) ? C = l.firstValue < l.secondValue ? "firstButton" : "secondButton" : C = l.firstValue > l.secondValue ? "firstButton" : "secondButton", w[C];
+  }, I = (g) => {
+    const k = $(g);
+    return k.value.setPosition(g), k;
+  }, L = (g) => {
+    l.firstValue = g ?? e.min, U(e.range ? [p.value, i.value] : g ?? e.min);
+  }, P = (g) => {
+    l.secondValue = g, e.range && U([p.value, i.value]);
+  }, U = (g) => {
+    o(X, g), o(D, g);
+  }, A = async () => {
+    await he(), o(Ne, e.range ? [p.value, i.value] : e.modelValue);
+  }, j = (g) => {
+    var k, C, n, r, d, S;
+    if (b.value || l.dragging)
+      return;
+    T();
+    let h = 0;
+    if (e.vertical) {
+      const N = (n = (C = (k = g.touches) == null ? void 0 : k.item(0)) == null ? void 0 : C.clientY) != null ? n : g.clientY;
+      h = (c.value.getBoundingClientRect().bottom - N) / l.sliderSize * 100;
+    } else {
+      const N = (S = (d = (r = g.touches) == null ? void 0 : r.item(0)) == null ? void 0 : d.clientX) != null ? S : g.clientX, x = c.value.getBoundingClientRect().left;
+      h = (N - x) / l.sliderSize * 100;
+    }
+    if (!(h < 0 || h > 100))
+      return I(h);
+  };
+  return {
+    elFormItem: v,
+    slider: c,
+    firstButton: s,
+    secondButton: u,
+    sliderDisabled: b,
+    minValue: p,
+    maxValue: i,
+    runwayStyle: M,
+    barStyle: K,
+    resetSize: T,
+    setPosition: I,
+    emitChange: A,
+    onSliderWrapperPrevent: (g) => {
+      var k, C;
+      ((k = w.firstButton.value) != null && k.dragging || (C = w.secondButton.value) != null && C.dragging) && g.preventDefault();
+    },
+    onSliderClick: (g) => {
+      j(g) && A();
+    },
+    onSliderDown: async (g) => {
+      const k = j(g);
+      k && (await he(), k.value.onButtonDown(g));
+    },
+    onSliderMarkerDown: (g) => {
+      b.value || l.dragging || I(g);
+    },
+    setFirstValue: L,
+    setSecondValue: P
+  };
+}, xt = (e, l, o, a) => ({
+  stops: y(() => {
+    if (!e.showStops || e.min > e.max)
+      return [];
+    if (e.step === 0)
+      return [];
+    const s = (e.max - e.min) / e.step, u = 100 * e.step / (e.max - e.min), w = Array.from({ length: s - 1 }).map((b, p) => (p + 1) * u);
+    return e.range ? w.filter((b) => b < 100 * (o.value - e.min) / (e.max - e.min) || b > 100 * (a.value - e.min) / (e.max - e.min)) : w.filter((b) => b > 100 * (l.firstValue - e.min) / (e.max - e.min));
+  }),
+  getStopStyle: (s) => e.vertical ? { bottom: `${s}%` } : { left: `${s}%` }
+}), It = (e) => y(() => e.marks ? Object.keys(e.marks).map(Number.parseFloat).sort((o, a) => o - a).filter((o) => o <= e.max && o >= e.min).map((o) => ({
+  point: o,
+  position: (o - e.min) * 100 / (e.max - e.min),
+  mark: e.marks[o]
+})) : []), Pt = (e, l, o, a, v, c) => {
+  const s = (b) => {
+    v(X, b), v(D, b);
+  }, u = () => e.range ? ![o.value, a.value].every((b, p) => b === l.oldValue[p]) : e.modelValue !== l.oldValue, w = () => {
+    var b, p;
+    e.min > e.max && Xe("Slider", "min should not be greater than max.");
+    const i = e.modelValue;
+    e.range && me(i) ? i[1] < e.min ? s([e.min, e.min]) : i[0] > e.max ? s([e.max, e.max]) : i[0] < e.min ? s([e.min, i[1]]) : i[1] > e.max ? s([i[0], e.max]) : (l.firstValue = i[0], l.secondValue = i[1], u() && (e.validateEvent && ((b = c?.validate) == null || b.call(c, "change").catch((B) => ye())), l.oldValue = i.slice())) : !e.range && F(i) && !Number.isNaN(i) && (i < e.min ? s(e.min) : i > e.max ? s(e.max) : (l.firstValue = i, u() && (e.validateEvent && ((p = c?.validate) == null || p.call(c, "change").catch((B) => ye())), l.oldValue = i)));
+  };
+  w(), ie(() => l.dragging, (b) => {
+    b || w();
+  }), ie(() => e.modelValue, (b, p) => {
+    l.dragging || me(b) && me(p) && b.every((i, B) => i === p[B]) && l.firstValue === b[0] && l.secondValue === b[1] || w();
+  }, {
+    deep: !0
+  }), ie(() => [e.min, e.max], () => {
+    w();
+  });
+}, Ct = (e, l, o) => {
+  const a = ee();
+  return Ke(async () => {
+    e.range ? (me(e.modelValue) ? (l.firstValue = Math.max(e.min, e.modelValue[0]), l.secondValue = Math.min(e.max, e.modelValue[1])) : (l.firstValue = e.min, l.secondValue = e.max), l.oldValue = [l.firstValue, l.secondValue]) : (!F(e.modelValue) || Number.isNaN(e.modelValue) ? l.firstValue = e.min : l.firstValue = Math.min(e.max, Math.max(e.min, e.modelValue)), l.oldValue = l.firstValue), we(window, "resize", o), await he(), o();
+  }), {
+    sliderWrapper: a
+  };
+}, Mt = te({
+  name: "ElSlider"
+}), Lt = /* @__PURE__ */ te({
+  ...Mt,
+  props: gt,
+  emits: Vt,
+  setup(e, { expose: l, emit: o }) {
+    const a = e, v = Se("slider"), { t: c } = Re(), s = Pe({
+      firstValue: 0,
+      secondValue: 0,
+      oldValue: 0,
+      dragging: !1,
+      sliderSize: 1
+    }), {
+      elFormItem: u,
+      slider: w,
+      firstButton: b,
+      secondButton: p,
+      sliderDisabled: i,
+      minValue: B,
+      maxValue: z,
+      runwayStyle: M,
+      barStyle: K,
+      resetSize: T,
+      emitChange: $,
+      onSliderWrapperPrevent: I,
+      onSliderClick: L,
+      onSliderDown: P,
+      onSliderMarkerDown: U,
+      setFirstValue: A,
+      setSecondValue: j
+    } = Bt(a, s, o), { stops: Q, getStopStyle: O } = xt(a, s, B, z), { inputId: q, isLabeledByFormItem: W } = ot(a, {
+      formItemContext: u
+    }), g = Oe(), k = y(() => a.inputSize || g.value), C = y(() => a.ariaLabel || c("el.slider.defaultLabel", {
+      min: a.min,
+      max: a.max
+    })), n = y(() => a.range ? a.rangeStartLabel || c("el.slider.defaultRangeStartLabel") : C.value), r = y(() => a.formatValueText ? a.formatValueText(m.value) : `${m.value}`), d = y(() => a.rangeEndLabel || c("el.slider.defaultRangeEndLabel")), S = y(() => a.formatValueText ? a.formatValueText(_.value) : `${_.value}`), h = y(() => [
+      v.b(),
+      v.m(g.value),
+      v.is("vertical", a.vertical),
+      { [v.m("with-input")]: a.showInput }
+    ]), N = It(a);
+    Pt(a, s, B, z, o, u);
+    const x = y(() => {
+      const V = [a.min, a.max, a.step].map((Me) => {
+        const oe = `${Me}`.split(".")[1];
+        return oe ? oe.length : 0;
+      });
+      return Math.max.apply(null, V);
+    }), { sliderWrapper: f } = Ct(a, s, T), { firstValue: m, secondValue: _, sliderSize: H } = Be(s), He = (V) => {
+      s.dragging = V;
+    };
+    return we(f, "touchstart", I, {
+      passive: !1
+    }), we(f, "touchmove", I, {
+      passive: !1
+    }), et(je, {
+      ...Be(a),
+      sliderSize: H,
+      disabled: i,
+      precision: x,
+      emitChange: $,
+      resetSize: T,
+      updateDragging: He
+    }), l({
+      onSliderClick: L
+    }), (V, Me) => {
+      var oe, Le;
+      return E(), R("div", {
+        id: V.range ? t(q) : void 0,
+        ref_key: "sliderWrapper",
+        ref: f,
+        class: Y(t(h)),
+        role: V.range ? "group" : void 0,
+        "aria-label": V.range && !t(W) ? t(C) : void 0,
+        "aria-labelledby": V.range && t(W) ? (oe = t(u)) == null ? void 0 : oe.labelId : void 0
+      }, [
+        re("div", {
+          ref_key: "slider",
+          ref: w,
+          class: Y([
+            t(v).e("runway"),
+            { "show-input": V.showInput && !V.range },
+            t(v).is("disabled", t(i))
+          ]),
+          style: le(t(M)),
+          onMousedown: t(P),
+          onTouchstartPassive: t(P)
+        }, [
+          re("div", {
+            class: Y(t(v).e("bar")),
+            style: le(t(K))
+          }, null, 6),
+          de($e, {
+            id: V.range ? void 0 : t(q),
+            ref_key: "firstButton",
+            ref: b,
+            "model-value": t(m),
+            vertical: V.vertical,
+            "tooltip-class": V.tooltipClass,
+            placement: V.placement,
+            role: "slider",
+            "aria-label": V.range || !t(W) ? t(n) : void 0,
+            "aria-labelledby": !V.range && t(W) ? (Le = t(u)) == null ? void 0 : Le.labelId : void 0,
+            "aria-valuemin": V.min,
+            "aria-valuemax": V.range ? t(_) : V.max,
+            "aria-valuenow": t(m),
+            "aria-valuetext": t(r),
+            "aria-orientation": V.vertical ? "vertical" : "horizontal",
+            "aria-disabled": t(i),
+            "onUpdate:modelValue": t(A)
+          }, null, 8, ["id", "model-value", "vertical", "tooltip-class", "placement", "aria-label", "aria-labelledby", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-orientation", "aria-disabled", "onUpdate:modelValue"]),
+          V.range ? (E(), Z($e, {
+            key: 0,
+            ref_key: "secondButton",
+            ref: p,
+            "model-value": t(_),
+            vertical: V.vertical,
+            "tooltip-class": V.tooltipClass,
+            placement: V.placement,
+            role: "slider",
+            "aria-label": t(d),
+            "aria-valuemin": t(m),
+            "aria-valuemax": V.max,
+            "aria-valuenow": t(_),
+            "aria-valuetext": t(S),
+            "aria-orientation": V.vertical ? "vertical" : "horizontal",
+            "aria-disabled": t(i),
+            "onUpdate:modelValue": t(j)
+          }, null, 8, ["model-value", "vertical", "tooltip-class", "placement", "aria-label", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-orientation", "aria-disabled", "onUpdate:modelValue"])) : ne("v-if", !0),
+          V.showStops ? (E(), R("div", { key: 1 }, [
+            (E(!0), R(be, null, ke(t(Q), (J, ue) => (E(), R("div", {
+              key: ue,
+              class: Y(t(v).e("stop")),
+              style: le(t(O)(J))
+            }, null, 6))), 128))
+          ])) : ne("v-if", !0),
+          t(N).length > 0 ? (E(), R(be, { key: 2 }, [
+            re("div", null, [
+              (E(!0), R(be, null, ke(t(N), (J, ue) => (E(), R("div", {
+                key: ue,
+                style: le(t(O)(J.position)),
+                class: Y([t(v).e("stop"), t(v).e("marks-stop")])
+              }, null, 6))), 128))
+            ]),
+            re("div", {
+              class: Y(t(v).e("marks"))
+            }, [
+              (E(!0), R(be, null, ke(t(N), (J, ue) => (E(), Z(t(Et), {
+                key: ue,
+                mark: J.mark,
+                style: le(t(O)(J.position)),
+                onMousedown: Ve((_t) => t(U)(J.position), ["stop"])
+              }, null, 8, ["mark", "style", "onMousedown"]))), 128))
+            ], 2)
+          ], 64)) : ne("v-if", !0)
+        ], 46, ["onMousedown", "onTouchstartPassive"]),
+        V.showInput && !V.range ? (E(), Z(t(bt), {
+          key: 0,
+          ref: "input",
+          "model-value": t(m),
+          class: Y(t(v).e("input")),
+          step: V.step,
+          disabled: t(i),
+          controls: V.showInputControls,
+          min: V.min,
+          max: V.max,
+          precision: t(x),
+          debounce: V.debounce,
+          size: t(k),
+          "onUpdate:modelValue": t(A),
+          onChange: t($)
+        }, null, 8, ["model-value", "class", "step", "disabled", "controls", "min", "max", "precision", "debounce", "size", "onUpdate:modelValue", "onChange"])) : ne("v-if", !0)
+      ], 10, ["id", "role", "aria-label", "aria-labelledby"]);
+    };
+  }
+});
+var Tt = /* @__PURE__ */ Ce(Lt, [["__file", "slider.vue"]]);
+const Ot = Ue(Tt);
+export {
+  Ot as E
+};