@xtctwins/tctwins-bimx-engine 0.2.49 → 0.2.50

package/dist/el-input-number-CUWk0tiM.mjs

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