@xtctwins/tctwins-bimx-engine 0.3.7 → 0.3.9

package/dist/el-slider-D_kA0TiT.mjs

@@ -0,0 +1,1059 @@
+import { ad as te, ac as M, m as ge, an as ue, ab as xe, b as Ee, ae as Le, j as _, af as Oe, B as Ye, u as Be, aj as Ue, i as Ve, x as me, a as We, ag as je, E as Ae, as as $e, J as De, aq as Ge, o as Te, N as Se, z as He, at as et, A as D, w as qe, l as he, au as Je, y as Ne, av as Fe, aw as tt, V as at, ak as lt } from "./index-s9bhlFsR.mjs";
+import { ArrowDown as nt, Minus as rt, ArrowUp as ut, Plus as it } from "@element-plus/icons-vue";
+import { defineComponent as Me, ref as ie, reactive as ze, computed as y, watch as ve, onMounted as Qe, onUpdated as st, openBlock as C, createElementBlock as H, withModifiers as Ze, normalizeClass as q, unref as t, withDirectives as Re, withKeys as Ke, renderSlot as pe, createVNode as ye, withCtx as oe, createBlock as re, createCommentVNode as de, createSlots as ot, nextTick as ke, watchEffect as dt, shallowRef as ct, inject as mt, toRefs as Ie, normalizeStyle as se, createElementVNode as ce, toDisplayString as vt, h as ft, provide as bt, Fragment as we, renderList as Pe } from "vue";
+const gt = Ee({
+  /**
+  * @description same as `id` in native input
+  */
+  id: {
+    type: String,
+    default: void 0
+  },
+  /**
+  * @description incremental step
+  */
+  step: {
+    type: Number,
+    default: 1
+  },
+  /**
+  * @description whether input value can only be multiple of step
+  */
+  stepStrictly: Boolean,
+  /**
+  * @description the maximum allowed value
+  */
+  max: {
+    type: Number,
+    default: Number.MAX_SAFE_INTEGER
+  },
+  /**
+  * @description the minimum allowed value
+  */
+  min: {
+    type: Number,
+    default: Number.MIN_SAFE_INTEGER
+  },
+  /**
+  * @description binding value
+  */
+  modelValue: { type: [Number, null] },
+  /**
+  * @description same as `readonly` in native input
+  */
+  readonly: Boolean,
+  /**
+  * @description whether the component is disabled
+  */
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+  * @description size of the component
+  */
+  size: Le,
+  /**
+  * @description whether to enable the control buttons
+  */
+  controls: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description position of the control buttons
+  */
+  controlsPosition: {
+    type: String,
+    default: "",
+    values: ["", "right"]
+  },
+  /**
+  * @description value should be set when input box is cleared
+  */
+  valueOnClear: {
+    type: _([
+      String,
+      Number,
+      null
+    ]),
+    validator: (e) => e === null || M(e) || ["min", "max"].includes(e),
+    default: null
+  },
+  /**
+  * @description same as `name` in native input
+  */
+  name: String,
+  /**
+  * @description same as `placeholder` in native input
+  */
+  placeholder: String,
+  /**
+  * @description precision of input value
+  */
+  precision: {
+    type: Number,
+    validator: (e) => e >= 0 && e === Number.parseInt(`${e}`, 10)
+  },
+  /**
+  * @description whether to trigger form validation
+  */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  ...Oe(["ariaLabel"]),
+  /**
+  * @description native input mode for virtual keyboards
+  */
+  inputmode: {
+    type: _(String),
+    default: void 0
+  },
+  /**
+  * @description alignment for the inner input text
+  */
+  align: {
+    type: _(String),
+    default: "center"
+  },
+  /**
+  * @description whether to disable scientific notation input (e.g. 'e', 'E')
+  */
+  disabledScientific: Boolean,
+  /**
+  * @description specifies the format of the value presented in the input
+  */
+  formatter: { type: Function },
+  /**
+  * @description specifies the value extracted from the formatted input
+  */
+  parser: { type: Function },
+  /**
+  * @description same as `tabindex` in native input
+  */
+  tabindex: {
+    type: [String, Number],
+    default: 0
+  }
+}), ht = {
+  [xe]: (e, a) => a !== e,
+  blur: (e) => e instanceof FocusEvent,
+  focus: (e) => e instanceof FocusEvent,
+  [ue]: (e) => M(e) || ge(e),
+  [te]: (e) => M(e) || ge(e)
+}, yt = ["aria-label"], Vt = ["aria-label"];
+var pt = /* @__PURE__ */ Me({
+  name: "ElInputNumber",
+  __name: "input-number",
+  props: gt,
+  emits: ht,
+  setup(e, { expose: a, emit: f }) {
+    const n = e, o = f, { t: i } = Ye(), s = Be("input-number"), p = ie(), d = ze({
+      currentValue: n.modelValue,
+      userInput: null
+    }), { formItem: r } = Ue(), w = y(() => M(n.modelValue) && n.modelValue <= n.min), I = y(() => M(n.modelValue) && n.modelValue >= n.max), E = y(() => {
+      const l = U(n.step);
+      return Ve(n.precision) ? Math.max(U(n.modelValue), l) : (l > n.precision && me("InputNumber", "precision should not be less than the decimal places of step"), n.precision);
+    }), W = y(() => n.controls && n.controlsPosition === "right"), J = We(), k = je(), R = y(() => {
+      if (d.userInput !== null) return d.userInput;
+      let l = d.currentValue;
+      if (ge(l)) return "";
+      if (M(l)) {
+        if (Number.isNaN(l)) return "";
+        Ve(n.precision) || (l = l.toFixed(n.precision));
+      }
+      return l;
+    }), L = (l, u) => {
+      if (Ve(u) && (u = E.value), u === 0) return Math.round(l);
+      let m = String(l);
+      const g = m.indexOf(".");
+      if (g === -1 || !m.replace(".", "").split("")[g + u]) return l;
+      const F = m.length;
+      return m.charAt(F - 1) === "5" && (m = `${m.slice(0, Math.max(0, F - 1))}6`), Number.parseFloat(Number(m).toFixed(u));
+    }, U = (l) => {
+      if (ge(l)) return 0;
+      const u = l.toString(), m = u.indexOf(".");
+      let g = 0;
+      return m !== -1 && (g = u.length - m - 1), g;
+    }, K = (l, u = 1) => M(l) ? l >= Number.MAX_SAFE_INTEGER && u === 1 ? (me("InputNumber", "The value has reached the maximum safe integer limit."), l) : l <= Number.MIN_SAFE_INTEGER && u === -1 ? (me("InputNumber", "The value has reached the minimum safe integer limit."), l) : L(l + n.step * u) : d.currentValue, Q = (l) => {
+      const u = He(l), m = et(l);
+      if (n.disabledScientific && ["e", "E"].includes(m)) {
+        l.preventDefault();
+        return;
+      }
+      switch (u) {
+        case D.up:
+          l.preventDefault(), B();
+          break;
+        case D.down:
+          l.preventDefault(), z();
+      }
+    }, B = () => {
+      if (n.readonly || k.value || I.value) return;
+      const l = Number(R.value) || 0, u = K(l);
+      N(u), o(ue, d.currentValue), G();
+    }, z = () => {
+      if (n.readonly || k.value || w.value) return;
+      const l = Number(R.value) || 0, u = K(l, -1);
+      N(u), o(ue, d.currentValue), G();
+    }, j = (l, u) => {
+      const { max: m, min: g, step: F, precision: X, stepStrictly: ne, valueOnClear: O } = n;
+      m < g && Ge("InputNumber", "min should not be greater than max.");
+      let S = l ? Number.parseFloat(String(l)) : Number(l);
+      if (ge(l) || Number.isNaN(S)) return null;
+      if (l === "") {
+        if (O === null) return null;
+        S = Te(O) ? {
+          min: g,
+          max: m
+        }[O] : O;
+      }
+      return ne && (S = L(Math.round(L(S / F)) * F, X), S !== l && u && o("update:modelValue", S)), Ve(X) || (S = L(S, X)), (S > m || S < g) && (S = S > m ? m : g, u && o("update:modelValue", S)), S;
+    }, N = (l, u = !0) => {
+      var F;
+      const m = d.currentValue, g = j(l);
+      if (!u) {
+        o(te, g);
+        return;
+      }
+      d.userInput = null, !(m === g && l) && (o(te, g), m !== g && o(xe, g, m), n.validateEvent && ((F = r == null ? void 0 : r.validate) == null || F.call(r, "change").catch(Se)), d.currentValue = g);
+    }, T = (l) => {
+      d.userInput = l;
+      let u = l === "" ? null : Number.parseFloat(l);
+      Number.isNaN(u) && (u = null), o(ue, u), N(u, !1);
+    }, ae = (l) => {
+      const u = l !== "" ? Number.parseFloat(l) : "";
+      (M(u) && !Number.isNaN(u) || n.formatter && Number.isNaN(u) || u === "") && N(u), G(), d.userInput = null;
+    }, b = () => {
+      var l, u;
+      (u = (l = p.value) == null ? void 0 : l.focus) == null || u.call(l);
+    }, V = () => {
+      var l, u;
+      (u = (l = p.value) == null ? void 0 : l.blur) == null || u.call(l);
+    }, P = (l) => {
+      o("focus", l);
+    }, le = (l) => {
+      var u, m, g;
+      d.userInput = null, d.currentValue === null && ((u = p.value) != null && u.input) && (p.value.input.value = ((m = n.formatter) == null ? void 0 : m.call(n, "")) ?? ""), o("blur", l), n.validateEvent && ((g = r == null ? void 0 : r.validate) == null || g.call(r, "blur").catch(Se));
+    }, G = () => {
+      d.currentValue !== n.modelValue && (d.currentValue = n.modelValue);
+    }, ee = (l) => {
+      document.activeElement === l.target && l.preventDefault();
+    };
+    return ve(() => n.modelValue, (l, u) => {
+      const m = j(l, !0);
+      d.userInput === null && m !== u && (d.currentValue = m);
+    }, { immediate: !0 }), ve(() => n.precision, () => {
+      d.currentValue = j(n.modelValue);
+    }), Qe(() => {
+      var F;
+      const { min: l, max: u, modelValue: m } = n, g = (F = p.value) == null ? void 0 : F.input;
+      if (g.setAttribute("role", "spinbutton"), Number.isFinite(u) ? g.setAttribute("aria-valuemax", String(u)) : g.removeAttribute("aria-valuemax"), Number.isFinite(l) ? g.setAttribute("aria-valuemin", String(l)) : g.removeAttribute("aria-valuemin"), g.setAttribute("aria-valuenow", d.currentValue || d.currentValue === 0 ? String(d.currentValue) : ""), g.setAttribute("aria-disabled", String(k.value)), !M(m) && m != null) {
+        let X = Number(m);
+        Number.isNaN(X) && (X = null), o(te, X);
+      }
+      g.addEventListener("wheel", ee, { passive: !1 });
+    }), st(() => {
+      var l, u;
+      (u = (l = p.value) == null ? void 0 : l.input) == null || u.setAttribute("aria-valuenow", `${d.currentValue ?? ""}`);
+    }), a({
+      /** @description get focus the input component */
+      focus: b,
+      /** @description remove focus the input component */
+      blur: V
+    }), (l, u) => (C(), H("div", {
+      class: q([
+        t(s).b(),
+        t(s).m(t(J)),
+        t(s).is("disabled", t(k)),
+        t(s).is("without-controls", !e.controls),
+        t(s).is("controls-right", W.value),
+        t(s).is(e.align, !!e.align)
+      ]),
+      onDragstart: u[0] || (u[0] = Ze(() => {
+      }, ["prevent"]))
+    }, [
+      e.controls ? Re((C(), H("span", {
+        key: 0,
+        role: "button",
+        "aria-label": t(i)("el.inputNumber.decrease"),
+        class: q([t(s).e("decrease"), t(s).is("disabled", w.value)]),
+        onKeydown: Ke(z, ["enter"])
+      }, [pe(l.$slots, "decrease-icon", {}, () => [ye(t(Ae), null, {
+        default: oe(() => [W.value ? (C(), re(t(nt), { key: 0 })) : (C(), re(t(rt), { key: 1 }))]),
+        _: 1
+      })])], 42, yt)), [[t($e), z]]) : de("v-if", !0),
+      e.controls ? Re((C(), H("span", {
+        key: 1,
+        role: "button",
+        "aria-label": t(i)("el.inputNumber.increase"),
+        class: q([t(s).e("increase"), t(s).is("disabled", I.value)]),
+        onKeydown: Ke(B, ["enter"])
+      }, [pe(l.$slots, "increase-icon", {}, () => [ye(t(Ae), null, {
+        default: oe(() => [W.value ? (C(), re(t(ut), { key: 0 })) : (C(), re(t(it), { key: 1 }))]),
+        _: 1
+      })])], 42, Vt)), [[t($e), B]]) : de("v-if", !0),
+      ye(t(De), {
+        id: e.id,
+        ref_key: "input",
+        ref: p,
+        type: e.formatter ? "text" : "number",
+        step: e.step,
+        "model-value": R.value,
+        placeholder: e.placeholder,
+        readonly: e.readonly,
+        disabled: t(k),
+        size: t(J),
+        max: e.max,
+        min: e.min,
+        name: e.name,
+        "aria-label": e.ariaLabel,
+        "validate-event": !1,
+        inputmode: e.inputmode,
+        formatter: e.formatter,
+        parser: e.parser,
+        tabindex: e.tabindex,
+        onKeydown: Q,
+        onBlur: le,
+        onFocus: P,
+        onInput: T,
+        onChange: ae
+      }, ot({ _: 2 }, [l.$slots.prefix ? {
+        name: "prefix",
+        fn: oe(() => [pe(l.$slots, "prefix")]),
+        key: "0"
+      } : void 0, l.$slots.suffix ? {
+        name: "suffix",
+        fn: oe(() => [pe(l.$slots, "suffix")]),
+        key: "1"
+      } : void 0]), 1032, [
+        "id",
+        "type",
+        "step",
+        "model-value",
+        "placeholder",
+        "readonly",
+        "disabled",
+        "size",
+        "max",
+        "min",
+        "name",
+        "aria-label",
+        "inputmode",
+        "formatter",
+        "parser",
+        "tabindex"
+      ])
+    ], 34));
+  }
+}), wt = pt;
+const St = qe(wt), _e = Symbol("sliderContextKey"), Nt = Ee({
+  /**
+  * @description binding value
+  */
+  modelValue: {
+    type: _([Number, Array]),
+    default: 0
+  },
+  id: {
+    type: String,
+    default: void 0
+  },
+  /**
+  * @description minimum value
+  */
+  min: {
+    type: Number,
+    default: 0
+  },
+  /**
+  * @description maximum value
+  */
+  max: {
+    type: Number,
+    default: 100
+  },
+  /**
+  * @description step size, can be a number or `'mark'` to restrict values to marks. When set to `'mark'`, the `marks` attribute must be set
+  */
+  step: {
+    type: _([Number, String]),
+    default: 1
+  },
+  /**
+  * @description whether to display an input box, works when `range` is false and `step` is not `'mark'`
+  */
+  showInput: Boolean,
+  /**
+  * @description whether to display control buttons when `show-input` is true
+  */
+  showInputControls: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description size of the slider wrapper, will not work in vertical mode
+  */
+  size: Le,
+  /**
+  * @description size of the input box, when set `size`, the default is the value of `size`
+  */
+  inputSize: Le,
+  /**
+  * @description whether to display breakpoints
+  */
+  showStops: Boolean,
+  /**
+  * @description whether to display tooltip value
+  */
+  showTooltip: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description format to display tooltip value
+  */
+  formatTooltip: {
+    type: _(Function),
+    default: void 0
+  },
+  /**
+  * @description whether Slider is disabled
+  */
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+  * @description whether to select a range
+  */
+  range: Boolean,
+  /**
+  * @description vertical mode
+  */
+  vertical: Boolean,
+  /**
+  * @description slider height, required in vertical mode
+  */
+  height: String,
+  /**
+  * @description when `range` is true, screen reader label for the start of the range
+  */
+  rangeStartLabel: {
+    type: String,
+    default: void 0
+  },
+  /**
+  * @description when `range` is true, screen reader label for the end of the range
+  */
+  rangeEndLabel: {
+    type: String,
+    default: void 0
+  },
+  /**
+  * @description format to display the `aria-valuenow` attribute for screen readers
+  */
+  formatValueText: {
+    type: _(Function),
+    default: void 0
+  },
+  /**
+  * @description custom class name for the tooltip
+  */
+  tooltipClass: {
+    type: _([
+      String,
+      Array,
+      Object,
+      Boolean
+    ]),
+    default: void 0
+  },
+  /**
+  * @description position of Tooltip
+  */
+  placement: {
+    type: String,
+    values: Je,
+    default: "top"
+  },
+  /**
+  * @description marks, type of key must be `number` and must in closed interval `[min, max]`, each mark can custom style
+  */
+  marks: { type: _(Object) },
+  /**
+  * @description whether to trigger form validation
+  */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description when slider tooltip inactive and `persistent` is `false` , popconfirm will be destroyed. `persistent` always be `false` when `show-tooltip ` is `false`
+  */
+  persistent: {
+    type: Boolean,
+    default: !0
+  },
+  ...Oe(["ariaLabel"])
+}), Ce = (e) => M(e) || he(e) && e.every(M), kt = {
+  [te]: Ce,
+  [ue]: Ce,
+  [xe]: Ce
+}, xt = (e, a, f) => {
+  const n = ie();
+  return Qe(async () => {
+    e.range ? (he(e.modelValue) ? (a.firstValue = Math.max(e.min, e.modelValue[0]), a.secondValue = Math.min(e.max, e.modelValue[1])) : (a.firstValue = e.min, a.secondValue = e.max), a.oldValue = [a.firstValue, a.secondValue]) : (!M(e.modelValue) || Number.isNaN(e.modelValue) ? a.firstValue = e.min : a.firstValue = Math.min(e.max, Math.max(e.min, e.modelValue)), a.oldValue = a.firstValue), Ne(window, "resize", f), await ke(), f();
+  }), { sliderWrapper: n };
+}, Et = (e) => {
+  const a = y(() => e.marks ? Object.keys(e.marks).map(Number.parseFloat).sort((f, n) => f - n).filter((f) => f <= e.max && f >= e.min).map((f) => ({
+    point: f,
+    position: (f - e.min) * 100 / (e.max - e.min),
+    mark: e.marks[f]
+  })) : []);
+  return dt(() => {
+    if (e.step === "mark" && !e.marks && me("ElSlider", "marks prop must be provided when step is mark"), e.marks) {
+      const f = Object.keys(e.marks), n = a.value.map((i) => i.point), o = f.filter((i) => {
+        const s = Number.parseFloat(i);
+        return Number.isNaN(s) || !n.includes(s);
+      });
+      o.length > 0 && me("ElSlider", `Some marks keys are invalid (not a number or out of [min, max]): [${o.map((i) => `'${i}'`).join(", ")}] and will be ignored.`);
+    }
+  }), a;
+}, Bt = (e, a, f) => {
+  const { formItem: n } = Ue(), o = ct(), i = ie(), s = ie(), p = {
+    firstButton: i,
+    secondButton: s
+  }, d = je(), r = y(() => Math.min(a.firstValue, a.secondValue)), w = y(() => Math.max(a.firstValue, a.secondValue)), I = y(() => e.range ? `${100 * (w.value - r.value) / (e.max - e.min)}%` : `${100 * (a.firstValue - e.min) / (e.max - e.min)}%`), E = y(() => e.range ? `${100 * (r.value - e.min) / (e.max - e.min)}%` : "0%"), W = y(() => e.vertical ? { height: e.height } : {}), J = y(() => e.vertical ? {
+    height: I.value,
+    bottom: E.value
+  } : {
+    width: I.value,
+    left: E.value
+  }), k = () => {
+    o.value && (a.sliderSize = o.value.getBoundingClientRect()[e.vertical ? "height" : "width"]);
+  }, R = (b) => {
+    const V = e.min + b * (e.max - e.min) / 100;
+    if (!e.range) return i;
+    let P;
+    return Math.abs(r.value - V) < Math.abs(w.value - V) ? P = a.firstValue < a.secondValue ? "firstButton" : "secondButton" : P = a.firstValue > a.secondValue ? "firstButton" : "secondButton", p[P];
+  }, L = (b) => {
+    const V = R(b);
+    return V.value.setPosition(b), V;
+  }, U = (b) => {
+    a.firstValue = b ?? e.min, Q(e.range ? [r.value, w.value] : b ?? e.min);
+  }, K = (b) => {
+    a.secondValue = b, e.range && Q([r.value, w.value]);
+  }, Q = (b) => {
+    f(te, b), f(ue, b);
+  }, B = async () => {
+    await ke(), f(xe, e.range ? [r.value, w.value] : e.modelValue);
+  }, z = (b) => {
+    var P, le, G, ee;
+    if (d.value || a.dragging) return;
+    k();
+    let V = 0;
+    if (e.vertical) {
+      const l = ((le = (P = b.touches) == null ? void 0 : P.item(0)) == null ? void 0 : le.clientY) ?? b.clientY;
+      V = (o.value.getBoundingClientRect().bottom - l) / a.sliderSize * 100;
+    } else V = ((((ee = (G = b.touches) == null ? void 0 : G.item(0)) == null ? void 0 : ee.clientX) ?? b.clientX) - o.value.getBoundingClientRect().left) / a.sliderSize * 100;
+    if (!(V < 0 || V > 100))
+      return L(V);
+  };
+  return {
+    elFormItem: n,
+    slider: o,
+    firstButton: i,
+    secondButton: s,
+    sliderDisabled: d,
+    minValue: r,
+    maxValue: w,
+    runwayStyle: W,
+    barStyle: J,
+    resetSize: k,
+    setPosition: L,
+    emitChange: B,
+    onSliderWrapperPrevent: (b) => {
+      var V, P;
+      ((V = p.firstButton.value) != null && V.dragging || (P = p.secondButton.value) != null && P.dragging) && b.preventDefault();
+    },
+    onSliderClick: (b) => {
+      z(b) && B();
+    },
+    onSliderDown: async (b) => {
+      const V = z(b);
+      V && (await ke(), V.value.onButtonDown(b));
+    },
+    onSliderMarkerDown: (b) => {
+      d.value || a.dragging || L(b) && B();
+    },
+    setFirstValue: U,
+    setSecondValue: K
+  };
+}, Mt = (e, a, f, n) => ({
+  stops: y(() => {
+    if (!e.showStops || e.min > e.max) return [];
+    if (e.step === "mark" || e.step === 0)
+      return e.step === 0 && me("ElSlider", "step should not be 0."), [];
+    const s = Math.ceil((e.max - e.min) / e.step), p = 100 * e.step / (e.max - e.min), d = Array.from({ length: s - 1 }).map((r, w) => (w + 1) * p);
+    return e.range ? d.filter((r) => r < 100 * (f.value - e.min) / (e.max - e.min) || r > 100 * (n.value - e.min) / (e.max - e.min)) : d.filter((r) => r > 100 * (a.firstValue - e.min) / (e.max - e.min));
+  }),
+  getStopStyle: (s) => e.vertical ? { bottom: `${s}%` } : { left: `${s}%` }
+}), Pt = (e, a, f, n, o, i) => {
+  const s = (r) => {
+    o(te, r), o(ue, r);
+  }, p = () => e.range ? ![f.value, n.value].every((r, w) => r === a.oldValue[w]) : e.modelValue !== a.oldValue, d = () => {
+    var w, I;
+    e.min > e.max && Ge("Slider", "min should not be greater than max.");
+    const r = e.modelValue;
+    e.range && he(r) ? r[1] < e.min ? s([e.min, e.min]) : r[0] > e.max ? s([e.max, e.max]) : r[0] < e.min ? s([e.min, r[1]]) : r[1] > e.max ? s([r[0], e.max]) : (a.firstValue = r[0], a.secondValue = r[1], p() && (e.validateEvent && ((w = i == null ? void 0 : i.validate) == null || w.call(i, "change").catch(Se)), a.oldValue = r.slice())) : !e.range && M(r) && !Number.isNaN(r) && (r < e.min ? s(e.min) : r > e.max ? s(e.max) : (a.firstValue = r, p() && (e.validateEvent && ((I = i == null ? void 0 : i.validate) == null || I.call(i, "change").catch(Se)), a.oldValue = r)));
+  };
+  d(), ve(() => a.dragging, (r) => {
+    r || d();
+  }), ve(() => e.modelValue, (r, w) => {
+    a.dragging || he(r) && he(w) && r.every((I, E) => I === w[E]) && a.firstValue === r[0] && a.secondValue === r[1] || d();
+  }, { deep: !0 }), ve(() => [e.min, e.max], () => {
+    d();
+  });
+}, Ct = (e, a, f) => {
+  const n = ie(), o = ie(!1), i = y(() => a.value instanceof Function);
+  return {
+    tooltip: n,
+    tooltipVisible: o,
+    formatValue: y(() => i.value && a.value(e.modelValue) || e.modelValue),
+    displayTooltip: Fe(() => {
+      f.value && (o.value = !0);
+    }, 50),
+    hideTooltip: Fe(() => {
+      f.value && (o.value = !1);
+    }, 50)
+  };
+}, Lt = (e, a, f) => {
+  const { disabled: n, min: o, max: i, step: s, showTooltip: p, persistent: d, precision: r, sliderSize: w, formatTooltip: I, emitChange: E, resetSize: W, updateDragging: J, markList: k } = mt(_e), { tooltip: R, tooltipVisible: L, formatValue: U, displayTooltip: K, hideTooltip: Q } = Ct(e, I, p), B = ie(), z = y(() => `${(e.modelValue - o.value) / (i.value - o.value) * 100}%`), j = y(() => e.vertical ? { bottom: z.value } : { left: z.value }), N = y(() => s.value === "mark" && k.value.length > 0), T = () => {
+    a.hovering = !0, K();
+  }, ae = () => {
+    a.hovering = !1, a.dragging || Q();
+  }, b = (c) => {
+    n.value || (c.preventDefault(), X(c), window.addEventListener("mousemove", ne), window.addEventListener("touchmove", ne), window.addEventListener("mouseup", O), window.addEventListener("touchend", O), window.addEventListener("contextmenu", O), B.value.focus());
+  }, V = (c) => {
+    n.value || (a.newPosition = Number.parseFloat(z.value) + c / (i.value - o.value) * 100, S(a.newPosition), E());
+  }, P = (c) => {
+    if (n.value || !k.value.length) return;
+    const h = e.modelValue, x = Number.EPSILON, Y = Math.abs(c);
+    let v;
+    if (c > 0) {
+      const A = k.value.findIndex(($) => $.point > h + x);
+      if (A !== -1) {
+        const $ = Math.min(A + Y - 1, k.value.length - 1);
+        v = k.value[$].point;
+      }
+    } else {
+      let A = -1;
+      for (let $ = k.value.length - 1; $ >= 0; $--) if (k.value[$].point < h - x) {
+        A = $;
+        break;
+      }
+      if (A !== -1) {
+        const $ = Math.max(A - (Y - 1), 0);
+        v = k.value[$].point;
+      }
+    }
+    if (v !== void 0 && v !== h) {
+      const A = (v - o.value) / (i.value - o.value) * 100;
+      S(A), E();
+    }
+  }, le = () => {
+    N.value ? P(-1) : M(s.value) && V(-s.value);
+  }, G = () => {
+    N.value ? P(1) : M(s.value) && V(s.value);
+  }, ee = () => {
+    N.value ? P(-4) : M(s.value) && V(-s.value * 4);
+  }, l = () => {
+    N.value ? P(4) : M(s.value) && V(s.value * 4);
+  }, u = () => {
+    n.value || (S(0), E());
+  }, m = () => {
+    n.value || (S(100), E());
+  }, g = (c) => {
+    const h = He(c);
+    let x = !0;
+    switch (h) {
+      case D.left:
+      case D.down:
+        le();
+        break;
+      case D.right:
+      case D.up:
+        G();
+        break;
+      case D.home:
+        u();
+        break;
+      case D.end:
+        m();
+        break;
+      case D.pageDown:
+        ee();
+        break;
+      case D.pageUp:
+        l();
+        break;
+      default:
+        x = !1;
+    }
+    x && c.preventDefault();
+  }, F = (c) => {
+    let h, x;
+    return c.type.startsWith("touch") ? (x = c.touches[0].clientY, h = c.touches[0].clientX) : (x = c.clientY, h = c.clientX), {
+      clientX: h,
+      clientY: x
+    };
+  }, X = (c) => {
+    a.dragging = !0, a.isClick = !0;
+    const { clientX: h, clientY: x } = F(c);
+    e.vertical ? a.startY = x : a.startX = h, a.startPosition = Number.parseFloat(z.value), a.newPosition = a.startPosition;
+  }, ne = (c) => {
+    if (a.dragging) {
+      a.isClick = !1, K(), W();
+      let h;
+      const { clientX: x, clientY: Y } = F(c);
+      e.vertical ? (a.currentY = Y, h = (a.startY - a.currentY) / w.value * 100) : (a.currentX = x, h = (a.currentX - a.startX) / w.value * 100), a.newPosition = a.startPosition + h, S(a.newPosition);
+    }
+  }, O = () => {
+    a.dragging && (setTimeout(() => {
+      a.dragging = !1, a.hovering || Q(), a.isClick || S(a.newPosition), E();
+    }, 0), window.removeEventListener("mousemove", ne), window.removeEventListener("touchmove", ne), window.removeEventListener("mouseup", O), window.removeEventListener("touchend", O), window.removeEventListener("contextmenu", O));
+  }, S = async (c) => {
+    if (c === null || Number.isNaN(+c)) return;
+    c = tt(c, 0, 100);
+    let h;
+    if (s.value === "mark")
+      k.value.length === 0 ? h = c <= 50 ? o.value : i.value : h = k.value.reduce((x, Y) => Math.abs(Y.position - c) < Math.abs(x.position - c) ? Y : x).point;
+    else {
+      const x = Math.floor((i.value - o.value) / s.value), Y = x * s.value / (i.value - o.value) * 100, v = Y + (100 - Y) / 2;
+      if (c < Y) {
+        const A = Y / x, $ = Math.round(c / A);
+        h = o.value + $ * s.value;
+      } else c < v ? h = o.value + x * s.value : h = i.value;
+      h = Number.parseFloat(h.toFixed(r.value));
+    }
+    h !== e.modelValue && f(te, h), !a.dragging && e.modelValue !== a.oldValue && (a.oldValue = e.modelValue), await ke(), a.dragging && K(), R.value.updatePopper();
+  };
+  return ve(() => a.dragging, (c) => {
+    J(c);
+  }), Ne(B, "touchstart", b, { passive: !1 }), {
+    disabled: n,
+    button: B,
+    tooltip: R,
+    tooltipVisible: L,
+    showTooltip: p,
+    persistent: d,
+    wrapperStyle: j,
+    formatValue: U,
+    handleMouseEnter: T,
+    handleMouseLeave: ae,
+    onButtonDown: b,
+    onKeyDown: g,
+    setPosition: S
+  };
+}, Tt = Ee({
+  modelValue: {
+    type: Number,
+    default: 0
+  },
+  vertical: Boolean,
+  tooltipClass: {
+    type: _([
+      String,
+      Array,
+      Object,
+      Boolean
+    ]),
+    default: void 0
+  },
+  placement: {
+    type: String,
+    values: Je,
+    default: "top"
+  }
+}), It = { [te]: (e) => M(e) }, zt = ["tabindex"];
+var At = /* @__PURE__ */ Me({
+  name: "ElSliderButton",
+  __name: "button",
+  props: Tt,
+  emits: It,
+  setup(e, { expose: a, emit: f }) {
+    const n = e, o = f, i = Be("slider"), s = ze({
+      hovering: !1,
+      dragging: !1,
+      isClick: !1,
+      startX: 0,
+      currentX: 0,
+      startY: 0,
+      currentY: 0,
+      startPosition: 0,
+      newPosition: 0,
+      oldValue: n.modelValue
+    }), p = y(() => I.value ? E.value : !1), { disabled: d, button: r, tooltip: w, showTooltip: I, persistent: E, tooltipVisible: W, wrapperStyle: J, formatValue: k, handleMouseEnter: R, handleMouseLeave: L, onButtonDown: U, onKeyDown: K, setPosition: Q } = Lt(n, s, o), { hovering: B, dragging: z } = Ie(s);
+    return a({
+      onButtonDown: U,
+      onKeyDown: K,
+      setPosition: Q,
+      hovering: B,
+      dragging: z
+    }), (j, N) => (C(), H("div", {
+      ref_key: "button",
+      ref: r,
+      class: q([t(i).e("button-wrapper"), {
+        hover: t(B),
+        dragging: t(z)
+      }]),
+      style: se(t(J)),
+      tabindex: t(d) ? void 0 : 0,
+      onMouseenter: N[0] || (N[0] = (...T) => t(R) && t(R)(...T)),
+      onMouseleave: N[1] || (N[1] = (...T) => t(L) && t(L)(...T)),
+      onMousedown: N[2] || (N[2] = (...T) => t(U) && t(U)(...T)),
+      onFocus: N[3] || (N[3] = (...T) => t(R) && t(R)(...T)),
+      onBlur: N[4] || (N[4] = (...T) => t(L) && t(L)(...T)),
+      onKeydown: N[5] || (N[5] = (...T) => t(K) && t(K)(...T))
+    }, [ye(t(at), {
+      ref_key: "tooltip",
+      ref: w,
+      visible: t(W),
+      placement: j.placement,
+      "fallback-placements": [
+        "top",
+        "bottom",
+        "right",
+        "left"
+      ],
+      "stop-popper-mouse-event": !1,
+      "popper-class": j.tooltipClass,
+      disabled: !t(I),
+      persistent: p.value
+    }, {
+      content: oe(() => [ce("span", null, vt(t(k)), 1)]),
+      default: oe(() => [ce("div", { class: q([t(i).e("button"), {
+        hover: t(B),
+        dragging: t(z)
+      }]) }, null, 2)]),
+      _: 1
+    }, 8, [
+      "visible",
+      "placement",
+      "popper-class",
+      "disabled",
+      "persistent"
+    ])], 46, zt));
+  }
+}), Xe = At;
+const $t = Ee({ mark: {
+  type: _([String, Object]),
+  default: void 0
+} });
+var Ft = Me({
+  name: "ElSliderMarker",
+  props: $t,
+  setup(e) {
+    const a = Be("slider"), f = y(() => Te(e.mark) ? e.mark : e.mark.label), n = y(() => Te(e.mark) ? void 0 : e.mark.style);
+    return () => ft("div", {
+      class: a.e("marks-text"),
+      style: n.value
+    }, f.value);
+  }
+});
+const Rt = [
+  "id",
+  "role",
+  "aria-label",
+  "aria-labelledby"
+], Kt = { key: 1 };
+var Xt = /* @__PURE__ */ Me({
+  name: "ElSlider",
+  __name: "slider",
+  props: Nt,
+  emits: kt,
+  setup(e, { expose: a, emit: f }) {
+    const n = e, o = f, i = Be("slider"), { t: s } = Ye(), p = ze({
+      firstValue: 0,
+      secondValue: 0,
+      oldValue: 0,
+      dragging: !1,
+      sliderSize: 1
+    }), { elFormItem: d, slider: r, firstButton: w, secondButton: I, sliderDisabled: E, minValue: W, maxValue: J, runwayStyle: k, barStyle: R, resetSize: L, emitChange: U, onSliderWrapperPrevent: K, onSliderClick: Q, onSliderDown: B, onSliderMarkerDown: z, setFirstValue: j, setSecondValue: N } = Bt(n, p, o), { stops: T, getStopStyle: ae } = Mt(n, p, W, J), { inputId: b, isLabeledByFormItem: V } = lt(n, { formItemContext: d }), P = We(), le = y(() => n.inputSize || P.value), G = y(() => n.showInput && !n.range && n.step !== "mark"), ee = y(() => n.ariaLabel || s("el.slider.defaultLabel", {
+      min: n.min,
+      max: n.max
+    })), l = y(() => n.range ? n.rangeStartLabel || s("el.slider.defaultRangeStartLabel") : ee.value), u = y(() => n.formatValueText ? n.formatValueText(c.value) : `${c.value}`), m = y(() => n.rangeEndLabel || s("el.slider.defaultRangeEndLabel")), g = y(() => n.formatValueText ? n.formatValueText(h.value) : `${h.value}`), F = y(() => [
+      i.b(),
+      i.m(P.value),
+      i.is("vertical", n.vertical),
+      { [i.m("with-input")]: G.value }
+    ]), X = Et(n);
+    Pt(n, p, W, J, o, d);
+    const ne = y(() => M(n.step) ? n.step : 1), O = y(() => {
+      const v = M(n.step) ? n.step : 1, A = [
+        n.min,
+        n.max,
+        v
+      ].map(($) => {
+        const fe = `${$}`.split(".")[1];
+        return fe ? fe.length : 0;
+      });
+      return Math.max.apply(null, A);
+    }), { sliderWrapper: S } = xt(n, p, L), { firstValue: c, secondValue: h, sliderSize: x } = Ie(p), Y = (v) => {
+      p.dragging = v;
+    };
+    return Ne(S, "touchstart", K, { passive: !1 }), Ne(S, "touchmove", K, { passive: !1 }), bt(_e, {
+      ...Ie(n),
+      sliderSize: x,
+      disabled: E,
+      precision: O,
+      markList: X,
+      emitChange: U,
+      resetSize: L,
+      updateDragging: Y
+    }), a({ onSliderClick: Q }), (v, A) => {
+      var $, fe;
+      return C(), H("div", {
+        id: v.range ? t(b) : void 0,
+        ref_key: "sliderWrapper",
+        ref: S,
+        class: q(F.value),
+        role: v.range ? "group" : void 0,
+        "aria-label": v.range && !t(V) ? ee.value : void 0,
+        "aria-labelledby": v.range && t(V) ? ($ = t(d)) == null ? void 0 : $.labelId : void 0
+      }, [ce("div", {
+        ref_key: "slider",
+        ref: r,
+        class: q([
+          t(i).e("runway"),
+          { "show-input": G.value },
+          t(i).is("disabled", t(E))
+        ]),
+        style: se(t(k)),
+        onMousedown: A[0] || (A[0] = (...Z) => t(B) && t(B)(...Z)),
+        onTouchstartPassive: A[1] || (A[1] = (...Z) => t(B) && t(B)(...Z))
+      }, [
+        ce("div", {
+          class: q(t(i).e("bar")),
+          style: se(t(R))
+        }, null, 6),
+        ye(Xe, {
+          id: v.range ? void 0 : t(b),
+          ref_key: "firstButton",
+          ref: w,
+          "model-value": t(c),
+          vertical: v.vertical,
+          "tooltip-class": v.tooltipClass,
+          placement: v.placement,
+          role: "slider",
+          "aria-label": v.range || !t(V) ? l.value : void 0,
+          "aria-labelledby": !v.range && t(V) ? (fe = t(d)) == null ? void 0 : fe.labelId : void 0,
+          "aria-valuemin": v.min,
+          "aria-valuemax": v.range ? t(h) : v.max,
+          "aria-valuenow": t(c),
+          "aria-valuetext": u.value,
+          "aria-orientation": v.vertical ? "vertical" : "horizontal",
+          "aria-disabled": t(E),
+          "onUpdate:modelValue": t(j)
+        }, 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 ? (C(), re(Xe, {
+          key: 0,
+          ref_key: "secondButton",
+          ref: I,
+          "model-value": t(h),
+          vertical: v.vertical,
+          "tooltip-class": v.tooltipClass,
+          placement: v.placement,
+          role: "slider",
+          "aria-label": m.value,
+          "aria-valuemin": t(c),
+          "aria-valuemax": v.max,
+          "aria-valuenow": t(h),
+          "aria-valuetext": g.value,
+          "aria-orientation": v.vertical ? "vertical" : "horizontal",
+          "aria-disabled": t(E),
+          "onUpdate:modelValue": t(N)
+        }, null, 8, [
+          "model-value",
+          "vertical",
+          "tooltip-class",
+          "placement",
+          "aria-label",
+          "aria-valuemin",
+          "aria-valuemax",
+          "aria-valuenow",
+          "aria-valuetext",
+          "aria-orientation",
+          "aria-disabled",
+          "onUpdate:modelValue"
+        ])) : de("v-if", !0),
+        v.showStops ? (C(), H("div", Kt, [(C(!0), H(we, null, Pe(t(T), (Z, be) => (C(), H("div", {
+          key: be,
+          class: q(t(i).e("stop")),
+          style: se(t(ae)(Z))
+        }, null, 6))), 128))])) : de("v-if", !0),
+        t(X).length > 0 ? (C(), H(we, { key: 2 }, [ce("div", null, [(C(!0), H(we, null, Pe(t(X), (Z, be) => (C(), H("div", {
+          key: be,
+          style: se(t(ae)(Z.position)),
+          class: q([t(i).e("stop"), t(i).e("marks-stop")])
+        }, null, 6))), 128))]), ce("div", { class: q(t(i).e("marks")) }, [(C(!0), H(we, null, Pe(t(X), (Z, be) => (C(), re(t(Ft), {
+          key: be,
+          mark: Z.mark,
+          style: se(t(ae)(Z.position)),
+          onMousedown: Ze((Yt) => t(z)(Z.position), ["stop"])
+        }, null, 8, [
+          "mark",
+          "style",
+          "onMousedown"
+        ]))), 128))], 2)], 64)) : de("v-if", !0)
+      ], 38), G.value ? (C(), re(t(St), {
+        key: 0,
+        ref: "input",
+        "model-value": t(c),
+        class: q(t(i).e("input")),
+        step: ne.value,
+        disabled: t(E),
+        controls: v.showInputControls,
+        min: v.min,
+        max: v.max,
+        precision: O.value,
+        size: le.value,
+        "onUpdate:modelValue": t(j),
+        onChange: t(U)
+      }, null, 8, [
+        "model-value",
+        "class",
+        "step",
+        "disabled",
+        "controls",
+        "min",
+        "max",
+        "precision",
+        "size",
+        "onUpdate:modelValue",
+        "onChange"
+      ])) : de("v-if", !0)], 10, Rt);
+    };
+  }
+}), Ot = Xt;
+const Gt = qe(Ot);
+export {
+  Gt as E
+};