@xtctwins/tctwins-bimx-engine 0.2.55 → 0.3.1

package/dist/el-slider-CBVU9_og.mjs

@@ -0,0 +1,1040 @@
+import { a9 as te, a8 as M, j as ge, aj as ue, a7 as xe, b as Ee, aa as Le, f as ee, ab as Ye, x as Oe, u as Be, af as Ue, i as Ve, q as me, a as We, ac as je, E as Ae, ao as $e, F as De, am as Ge, l as Te, N as we, t as qe, ap as et, v as _, w as He, g as he, aq as Je, s as Ne, ar as Fe, as as tt, at, ag as lt } from "./index-CwRGVhoT.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 q, withModifiers as Ze, normalizeClass as H, 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 Se, 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: ee([
+      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
+  },
+  ...Ye(["ariaLabel"]),
+  /**
+  * @description native input mode for virtual keyboards
+  */
+  inputmode: {
+    type: ee(String),
+    default: void 0
+  },
+  /**
+  * @description alignment for the inner input text
+  */
+  align: {
+    type: ee(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 l = e, o = f, { t: i } = Oe(), s = Be("input-number"), p = ie(), d = ze({
+      currentValue: l.modelValue,
+      userInput: null
+    }), { formItem: r } = Ue(), S = y(() => M(l.modelValue) && l.modelValue <= l.min), I = y(() => M(l.modelValue) && l.modelValue >= l.max), E = y(() => {
+      const n = U(l.step);
+      return Ve(l.precision) ? Math.max(U(l.modelValue), n) : (n > l.precision && me("InputNumber", "precision should not be less than the decimal places of step"), l.precision);
+    }), W = y(() => l.controls && l.controlsPosition === "right"), J = We(), k = je(), F = y(() => {
+      if (d.userInput !== null) return d.userInput;
+      let n = d.currentValue;
+      if (ge(n)) return "";
+      if (M(n)) {
+        if (Number.isNaN(n)) return "";
+        Ve(l.precision) || (n = n.toFixed(l.precision));
+      }
+      return n;
+    }), L = (n, u) => {
+      if (Ve(u) && (u = E.value), u === 0) return Math.round(n);
+      let m = String(n);
+      const g = m.indexOf(".");
+      if (g === -1 || !m.replace(".", "").split("")[g + u]) return n;
+      const $ = m.length;
+      return m.charAt($ - 1) === "5" && (m = `${m.slice(0, Math.max(0, $ - 1))}6`), Number.parseFloat(Number(m).toFixed(u));
+    }, U = (n) => {
+      if (ge(n)) return 0;
+      const u = n.toString(), m = u.indexOf(".");
+      let g = 0;
+      return m !== -1 && (g = u.length - m - 1), g;
+    }, R = (n, u = 1) => M(n) ? n >= Number.MAX_SAFE_INTEGER && u === 1 ? (me("InputNumber", "The value has reached the maximum safe integer limit."), n) : n <= Number.MIN_SAFE_INTEGER && u === -1 ? (me("InputNumber", "The value has reached the minimum safe integer limit."), n) : L(n + l.step * u) : d.currentValue, Q = (n) => {
+      const u = qe(n), m = et(n);
+      if (l.disabledScientific && ["e", "E"].includes(m)) {
+        n.preventDefault();
+        return;
+      }
+      switch (u) {
+        case _.up:
+          n.preventDefault(), B();
+          break;
+        case _.down:
+          n.preventDefault(), z();
+          break;
+      }
+    }, B = () => {
+      l.readonly || k.value || I.value || (N(R(Number(F.value) || 0)), o(ue, d.currentValue), G());
+    }, z = () => {
+      l.readonly || k.value || S.value || (N(R(Number(F.value) || 0, -1)), o(ue, d.currentValue), G());
+    }, j = (n, u) => {
+      const { max: m, min: g, step: $, precision: X, stepStrictly: ne, valueOnClear: Y } = l;
+      m < g && Ge("InputNumber", "min should not be greater than max.");
+      let w = n ? Number.parseFloat(String(n)) : Number(n);
+      if (ge(n) || Number.isNaN(w)) return null;
+      if (n === "") {
+        if (Y === null) return null;
+        w = Te(Y) ? {
+          min: g,
+          max: m
+        }[Y] : Y;
+      }
+      return ne && (w = L(Math.round(L(w / $)) * $, X), w !== n && u && o("update:modelValue", w)), Ve(X) || (w = L(w, X)), (w > m || w < g) && (w = w > m ? m : g, u && o("update:modelValue", w)), w;
+    }, N = (n, u = !0) => {
+      var $;
+      const m = d.currentValue, g = j(n);
+      if (!u) {
+        o(te, g);
+        return;
+      }
+      d.userInput = null, !(m === g && n) && (o(te, g), m !== g && o(xe, g, m), l.validateEvent && (($ = r == null ? void 0 : r.validate) == null || $.call(r, "change").catch(we)), d.currentValue = g);
+    }, T = (n) => {
+      d.userInput = n;
+      let u = n === "" ? null : Number.parseFloat(n);
+      Number.isNaN(u) && (u = null), o(ue, u), N(u, !1);
+    }, ae = (n) => {
+      const u = n !== "" ? Number.parseFloat(n) : "";
+      (M(u) && !Number.isNaN(u) || l.formatter && Number.isNaN(u) || u === "") && N(u), G(), d.userInput = null;
+    }, b = () => {
+      var n, u;
+      (u = (n = p.value) == null ? void 0 : n.focus) == null || u.call(n);
+    }, V = () => {
+      var n, u;
+      (u = (n = p.value) == null ? void 0 : n.blur) == null || u.call(n);
+    }, P = (n) => {
+      o("focus", n);
+    }, le = (n) => {
+      var u, m, g;
+      d.userInput = null, d.currentValue === null && ((u = p.value) != null && u.input) && (p.value.input.value = ((m = l.formatter) == null ? void 0 : m.call(l, "")) ?? ""), o("blur", n), l.validateEvent && ((g = r == null ? void 0 : r.validate) == null || g.call(r, "blur").catch(we));
+    }, G = () => {
+      d.currentValue !== l.modelValue && (d.currentValue = l.modelValue);
+    }, D = (n) => {
+      document.activeElement === n.target && n.preventDefault();
+    };
+    return ve(() => l.modelValue, (n, u) => {
+      const m = j(n, !0);
+      d.userInput === null && m !== u && (d.currentValue = m);
+    }, { immediate: !0 }), ve(() => l.precision, () => {
+      d.currentValue = j(l.modelValue);
+    }), Qe(() => {
+      var $;
+      const { min: n, max: u, modelValue: m } = l, g = ($ = p.value) == null ? void 0 : $.input;
+      if (g.setAttribute("role", "spinbutton"), Number.isFinite(u) ? g.setAttribute("aria-valuemax", String(u)) : g.removeAttribute("aria-valuemax"), Number.isFinite(n) ? g.setAttribute("aria-valuemin", String(n)) : 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", D, { passive: !1 });
+    }), st(() => {
+      var n, u;
+      (u = (n = p.value) == null ? void 0 : n.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
+    }), (n, u) => (C(), q("div", {
+      class: H([
+        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(), q("span", {
+        key: 0,
+        role: "button",
+        "aria-label": t(i)("el.inputNumber.decrease"),
+        class: H([t(s).e("decrease"), t(s).is("disabled", S.value)]),
+        onKeydown: Ke(z, ["enter"])
+      }, [pe(n.$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(), q("span", {
+        key: 1,
+        role: "button",
+        "aria-label": t(i)("el.inputNumber.increase"),
+        class: H([t(s).e("increase"), t(s).is("disabled", I.value)]),
+        onKeydown: Ke(B, ["enter"])
+      }, [pe(n.$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": F.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 }, [n.$slots.prefix ? {
+        name: "prefix",
+        fn: oe(() => [pe(n.$slots, "prefix")]),
+        key: "0"
+      } : void 0, n.$slots.suffix ? {
+        name: "suffix",
+        fn: oe(() => [pe(n.$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));
+  }
+}), St = pt;
+const wt = He(St), _e = Symbol("sliderContextKey"), Nt = Ee({
+  /**
+  * @description binding value
+  */
+  modelValue: {
+    type: ee([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: ee([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: ee(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: ee(Function),
+    default: void 0
+  },
+  /**
+  * @description custom class name for the tooltip
+  */
+  tooltipClass: {
+    type: String,
+    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: ee(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
+  },
+  ...Ye(["ariaLabel"])
+}), Ce = (e) => M(e) || he(e) && e.every(M), kt = {
+  [te]: Ce,
+  [ue]: Ce,
+  [xe]: Ce
+}, xt = (e, a, f) => {
+  const l = 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: l };
+}, Et = (e) => {
+  const a = y(() => e.marks ? Object.keys(e.marks).map(Number.parseFloat).sort((f, l) => f - l).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), l = a.value.map((i) => i.point), o = f.filter((i) => {
+        const s = Number.parseFloat(i);
+        return Number.isNaN(s) || !l.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: l } = Ue(), o = ct(), i = ie(), s = ie(), p = {
+    firstButton: i,
+    secondButton: s
+  }, d = je(), r = y(() => Math.min(a.firstValue, a.secondValue)), S = y(() => Math.max(a.firstValue, a.secondValue)), I = y(() => e.range ? `${100 * (S.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"]);
+  }, F = (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(S.value - V) ? P = a.firstValue < a.secondValue ? "firstButton" : "secondButton" : P = a.firstValue > a.secondValue ? "firstButton" : "secondButton", p[P];
+  }, L = (b) => {
+    const V = F(b);
+    return V.value.setPosition(b), V;
+  }, U = (b) => {
+    a.firstValue = b ?? e.min, Q(e.range ? [r.value, S.value] : b ?? e.min);
+  }, R = (b) => {
+    a.secondValue = b, e.range && Q([r.value, S.value]);
+  }, Q = (b) => {
+    f(te, b), f(ue, b);
+  }, B = async () => {
+    await ke(), f(xe, e.range ? [r.value, S.value] : e.modelValue);
+  }, z = (b) => {
+    var P, le, G, D;
+    if (d.value || a.dragging) return;
+    k();
+    let V = 0;
+    if (e.vertical) {
+      const n = ((le = (P = b.touches) == null ? void 0 : P.item(0)) == null ? void 0 : le.clientY) ?? b.clientY;
+      V = (o.value.getBoundingClientRect().bottom - n) / a.sliderSize * 100;
+    } else V = ((((D = (G = b.touches) == null ? void 0 : G.item(0)) == null ? void 0 : D.clientX) ?? b.clientX) - o.value.getBoundingClientRect().left) / a.sliderSize * 100;
+    if (!(V < 0 || V > 100))
+      return L(V);
+  };
+  return {
+    elFormItem: l,
+    slider: o,
+    firstButton: i,
+    secondButton: s,
+    sliderDisabled: d,
+    minValue: r,
+    maxValue: S,
+    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: R
+  };
+}, Mt = (e, a, f, l) => ({
+  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, S) => (S + 1) * p);
+    return e.range ? d.filter((r) => r < 100 * (f.value - e.min) / (e.max - e.min) || r > 100 * (l.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, l, o, i) => {
+  const s = (r) => {
+    o(te, r), o(ue, r);
+  }, p = () => e.range ? ![f.value, l.value].every((r, S) => r === a.oldValue[S]) : e.modelValue !== a.oldValue, d = () => {
+    var S, 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 && ((S = i == null ? void 0 : i.validate) == null || S.call(i, "change").catch(we)), 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(we)), a.oldValue = r)));
+  };
+  d(), ve(() => a.dragging, (r) => {
+    r || d();
+  }), ve(() => e.modelValue, (r, S) => {
+    a.dragging || he(r) && he(S) && r.every((I, E) => I === S[E]) && a.firstValue === r[0] && a.secondValue === r[1] || d();
+  }, { deep: !0 }), ve(() => [e.min, e.max], () => {
+    d();
+  });
+}, Ct = (e, a, f) => {
+  const l = ie(), o = ie(!1), i = y(() => a.value instanceof Function);
+  return {
+    tooltip: l,
+    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: l, min: o, max: i, step: s, showTooltip: p, persistent: d, precision: r, sliderSize: S, formatTooltip: I, emitChange: E, resetSize: W, updateDragging: J, markList: k } = mt(_e), { tooltip: F, tooltipVisible: L, formatValue: U, displayTooltip: R, 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, R();
+  }, ae = () => {
+    a.hovering = !1, a.dragging || Q();
+  }, b = (c) => {
+    l.value || (c.preventDefault(), X(c), window.addEventListener("mousemove", ne), window.addEventListener("touchmove", ne), window.addEventListener("mouseup", Y), window.addEventListener("touchend", Y), window.addEventListener("contextmenu", Y), B.value.focus());
+  }, V = (c) => {
+    l.value || (a.newPosition = Number.parseFloat(z.value) + c / (i.value - o.value) * 100, w(a.newPosition), E());
+  }, P = (c) => {
+    if (l.value || !k.value.length) return;
+    const h = e.modelValue, x = Number.EPSILON, O = Math.abs(c);
+    let v;
+    if (c > 0) {
+      const K = k.value.findIndex((A) => A.point > h + x);
+      if (K !== -1) {
+        const A = Math.min(K + O - 1, k.value.length - 1);
+        v = k.value[A].point;
+      }
+    } else {
+      let K = -1;
+      for (let A = k.value.length - 1; A >= 0; A--) if (k.value[A].point < h - x) {
+        K = A;
+        break;
+      }
+      if (K !== -1) {
+        const A = Math.max(K - (O - 1), 0);
+        v = k.value[A].point;
+      }
+    }
+    v !== void 0 && v !== h && (w((v - o.value) / (i.value - o.value) * 100), E());
+  }, le = () => {
+    N.value ? P(-1) : M(s.value) && V(-s.value);
+  }, G = () => {
+    N.value ? P(1) : M(s.value) && V(s.value);
+  }, D = () => {
+    N.value ? P(-4) : M(s.value) && V(-s.value * 4);
+  }, n = () => {
+    N.value ? P(4) : M(s.value) && V(s.value * 4);
+  }, u = () => {
+    l.value || (w(0), E());
+  }, m = () => {
+    l.value || (w(100), E());
+  }, g = (c) => {
+    const h = qe(c);
+    let x = !0;
+    switch (h) {
+      case _.left:
+      case _.down:
+        le();
+        break;
+      case _.right:
+      case _.up:
+        G();
+        break;
+      case _.home:
+        u();
+        break;
+      case _.end:
+        m();
+        break;
+      case _.pageDown:
+        D();
+        break;
+      case _.pageUp:
+        n();
+        break;
+      default:
+        x = !1;
+        break;
+    }
+    x && c.preventDefault();
+  }, $ = (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 } = $(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, R(), W();
+      let h;
+      const { clientX: x, clientY: O } = $(c);
+      e.vertical ? (a.currentY = O, h = (a.startY - a.currentY) / S.value * 100) : (a.currentX = x, h = (a.currentX - a.startX) / S.value * 100), a.newPosition = a.startPosition + h, w(a.newPosition);
+    }
+  }, Y = () => {
+    a.dragging && (setTimeout(() => {
+      a.dragging = !1, a.hovering || Q(), a.isClick || w(a.newPosition), E();
+    }, 0), window.removeEventListener("mousemove", ne), window.removeEventListener("touchmove", ne), window.removeEventListener("mouseup", Y), window.removeEventListener("touchend", Y), window.removeEventListener("contextmenu", Y));
+  }, w = 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, O) => Math.abs(O.position - c) < Math.abs(x.position - c) ? O : x).point;
+    else {
+      const x = Math.floor((i.value - o.value) / s.value), O = x * s.value / (i.value - o.value) * 100, v = O + (100 - O) / 2;
+      if (c < O) {
+        const K = O / x, A = Math.round(c / K);
+        h = o.value + A * 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 && R(), F.value.updatePopper();
+  };
+  return ve(() => a.dragging, (c) => {
+    J(c);
+  }), Ne(B, "touchstart", b, { passive: !1 }), {
+    disabled: l,
+    button: B,
+    tooltip: F,
+    tooltipVisible: L,
+    showTooltip: p,
+    persistent: d,
+    wrapperStyle: j,
+    formatValue: U,
+    handleMouseEnter: T,
+    handleMouseLeave: ae,
+    onButtonDown: b,
+    onKeyDown: g,
+    setPosition: w
+  };
+}, Tt = Ee({
+  modelValue: {
+    type: Number,
+    default: 0
+  },
+  vertical: Boolean,
+  tooltipClass: String,
+  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 l = 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: l.modelValue
+    }), p = y(() => I.value ? E.value : !1), { disabled: d, button: r, tooltip: S, showTooltip: I, persistent: E, tooltipVisible: W, wrapperStyle: J, formatValue: k, handleMouseEnter: F, handleMouseLeave: L, onButtonDown: U, onKeyDown: R, setPosition: Q } = Lt(l, s, o), { hovering: B, dragging: z } = Ie(s);
+    return a({
+      onButtonDown: U,
+      onKeyDown: R,
+      setPosition: Q,
+      hovering: B,
+      dragging: z
+    }), (j, N) => (C(), q("div", {
+      ref_key: "button",
+      ref: r,
+      class: H([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(F) && t(F)(...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(F) && t(F)(...T)),
+      onBlur: N[4] || (N[4] = (...T) => t(L) && t(L)(...T)),
+      onKeydown: N[5] || (N[5] = (...T) => t(R) && t(R)(...T))
+    }, [ye(t(at), {
+      ref_key: "tooltip",
+      ref: S,
+      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: H([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: ee([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), l = y(() => Te(e.mark) ? void 0 : e.mark.style);
+    return () => ft("div", {
+      class: a.e("marks-text"),
+      style: l.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 l = e, o = f, i = Be("slider"), { t: s } = Oe(), p = ze({
+      firstValue: 0,
+      secondValue: 0,
+      oldValue: 0,
+      dragging: !1,
+      sliderSize: 1
+    }), { elFormItem: d, slider: r, firstButton: S, secondButton: I, sliderDisabled: E, minValue: W, maxValue: J, runwayStyle: k, barStyle: F, resetSize: L, emitChange: U, onSliderWrapperPrevent: R, onSliderClick: Q, onSliderDown: B, onSliderMarkerDown: z, setFirstValue: j, setSecondValue: N } = Bt(l, p, o), { stops: T, getStopStyle: ae } = Mt(l, p, W, J), { inputId: b, isLabeledByFormItem: V } = lt(l, { formItemContext: d }), P = We(), le = y(() => l.inputSize || P.value), G = y(() => l.showInput && !l.range && l.step !== "mark"), D = y(() => l.ariaLabel || s("el.slider.defaultLabel", {
+      min: l.min,
+      max: l.max
+    })), n = y(() => l.range ? l.rangeStartLabel || s("el.slider.defaultRangeStartLabel") : D.value), u = y(() => l.formatValueText ? l.formatValueText(c.value) : `${c.value}`), m = y(() => l.rangeEndLabel || s("el.slider.defaultRangeEndLabel")), g = y(() => l.formatValueText ? l.formatValueText(h.value) : `${h.value}`), $ = y(() => [
+      i.b(),
+      i.m(P.value),
+      i.is("vertical", l.vertical),
+      { [i.m("with-input")]: G.value }
+    ]), X = Et(l);
+    Pt(l, p, W, J, o, d);
+    const ne = y(() => M(l.step) ? l.step : 1), Y = y(() => {
+      const v = M(l.step) ? l.step : 1, K = [
+        l.min,
+        l.max,
+        v
+      ].map((A) => {
+        const fe = `${A}`.split(".")[1];
+        return fe ? fe.length : 0;
+      });
+      return Math.max.apply(null, K);
+    }), { sliderWrapper: w } = xt(l, p, L), { firstValue: c, secondValue: h, sliderSize: x } = Ie(p), O = (v) => {
+      p.dragging = v;
+    };
+    return Ne(w, "touchstart", R, { passive: !1 }), Ne(w, "touchmove", R, { passive: !1 }), bt(_e, {
+      ...Ie(l),
+      sliderSize: x,
+      disabled: E,
+      precision: Y,
+      markList: X,
+      emitChange: U,
+      resetSize: L,
+      updateDragging: O
+    }), a({ onSliderClick: Q }), (v, K) => {
+      var A, fe;
+      return C(), q("div", {
+        id: v.range ? t(b) : void 0,
+        ref_key: "sliderWrapper",
+        ref: w,
+        class: H($.value),
+        role: v.range ? "group" : void 0,
+        "aria-label": v.range && !t(V) ? D.value : void 0,
+        "aria-labelledby": v.range && t(V) ? (A = t(d)) == null ? void 0 : A.labelId : void 0
+      }, [ce("div", {
+        ref_key: "slider",
+        ref: r,
+        class: H([
+          t(i).e("runway"),
+          { "show-input": G.value },
+          t(i).is("disabled", t(E))
+        ]),
+        style: se(t(k)),
+        onMousedown: K[0] || (K[0] = (...Z) => t(B) && t(B)(...Z)),
+        onTouchstartPassive: K[1] || (K[1] = (...Z) => t(B) && t(B)(...Z))
+      }, [
+        ce("div", {
+          class: H(t(i).e("bar")),
+          style: se(t(F))
+        }, null, 6),
+        ye(Xe, {
+          id: v.range ? void 0 : t(b),
+          ref_key: "firstButton",
+          ref: S,
+          "model-value": t(c),
+          vertical: v.vertical,
+          "tooltip-class": v.tooltipClass,
+          placement: v.placement,
+          role: "slider",
+          "aria-label": v.range || !t(V) ? n.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(), q("div", Kt, [(C(!0), q(Se, null, Pe(t(T), (Z, be) => (C(), q("div", {
+          key: be,
+          class: H(t(i).e("stop")),
+          style: se(t(ae)(Z))
+        }, null, 6))), 128))])) : de("v-if", !0),
+        t(X).length > 0 ? (C(), q(Se, { key: 2 }, [ce("div", null, [(C(!0), q(Se, null, Pe(t(X), (Z, be) => (C(), q("div", {
+          key: be,
+          style: se(t(ae)(Z.position)),
+          class: H([t(i).e("stop"), t(i).e("marks-stop")])
+        }, null, 6))), 128))]), ce("div", { class: H(t(i).e("marks")) }, [(C(!0), q(Se, null, Pe(t(X), (Z, be) => (C(), re(t(Ft), {
+          key: be,
+          mark: Z.mark,
+          style: se(t(ae)(Z.position)),
+          onMousedown: Ze((Ot) => t(z)(Z.position), ["stop"])
+        }, null, 8, [
+          "mark",
+          "style",
+          "onMousedown"
+        ]))), 128))], 2)], 64)) : de("v-if", !0)
+      ], 38), G.value ? (C(), re(t(wt), {
+        key: 0,
+        ref: "input",
+        "model-value": t(c),
+        class: H(t(i).e("input")),
+        step: ne.value,
+        disabled: t(E),
+        controls: v.showInputControls,
+        min: v.min,
+        max: v.max,
+        precision: Y.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);
+    };
+  }
+}), Yt = Xt;
+const Gt = He(Yt);
+export {
+  Gt as E
+};