@fecp/vue 1.2.2 → 5.2.3

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/timeline/src/timeline-item2.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index$1 = require("../../icon/index.js");
+const timelineItem = require("./timeline-item.js");
+const pluginVue_exportHelper = require("../../../_virtual/plugin-vue_export-helper.js");
+const index = require("../../../hooks/use-namespace/index.js");
+const I = vue.defineComponent({
+  name: "ElTimelineItem"
+}), N = /* @__PURE__ */ vue.defineComponent({
+  ...I,
+  props: timelineItem.timelineItemProps,
+  setup(f) {
+    const n = f, e = index.useNamespace("timeline-item"), u = vue.computed(() => [
+      e.e("node"),
+      e.em("node", n.size || ""),
+      e.em("node", n.type || ""),
+      e.is("hollow", n.hollow)
+    ]);
+    return (o, T) => (vue.openBlock(), vue.createElementBlock("li", {
+      class: vue.normalizeClass([vue.unref(e).b(), { [vue.unref(e).e("center")]: o.center }])
+    }, [
+      vue.createElementVNode("div", {
+        class: vue.normalizeClass(vue.unref(e).e("tail"))
+      }, null, 2),
+      o.$slots.dot ? vue.createCommentVNode("v-if", true) : (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        class: vue.normalizeClass(vue.unref(u)),
+        style: vue.normalizeStyle({
+          backgroundColor: o.color
+        })
+      }, [
+        o.icon ? (vue.openBlock(), vue.createBlock(vue.unref(index$1.ElIcon), {
+          key: 0,
+          class: vue.normalizeClass(vue.unref(e).e("icon"))
+        }, {
+          default: vue.withCtx(() => [
+            (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(o.icon)))
+          ]),
+          _: 1
+        }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
+      ], 6)),
+      o.$slots.dot ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 1,
+        class: vue.normalizeClass(vue.unref(e).e("dot"))
+      }, [
+        vue.renderSlot(o.$slots, "dot")
+      ], 2)) : vue.createCommentVNode("v-if", true),
+      vue.createElementVNode("div", {
+        class: vue.normalizeClass(vue.unref(e).e("wrapper"))
+      }, [
+        !o.hideTimestamp && o.placement === "top" ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: vue.normalizeClass([vue.unref(e).e("timestamp"), vue.unref(e).is("top")])
+        }, vue.toDisplayString(o.timestamp), 3)) : vue.createCommentVNode("v-if", true),
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass(vue.unref(e).e("content"))
+        }, [
+          vue.renderSlot(o.$slots, "default")
+        ], 2),
+        !o.hideTimestamp && o.placement === "bottom" ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 1,
+          class: vue.normalizeClass([vue.unref(e).e("timestamp"), vue.unref(e).is("bottom")])
+        }, vue.toDisplayString(o.timestamp), 3)) : vue.createCommentVNode("v-if", true)
+      ], 2)
+    ], 2));
+  }
+});
+var D = /* @__PURE__ */ pluginVue_exportHelper.default(N, [["__file", "timeline-item.vue"]]);
+exports.default = D;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/timeline/src/timeline.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index = require("../../../hooks/use-namespace/index.js");
+const s = vue.defineComponent({
+  name: "ElTimeline",
+  setup(l, { slots: e }) {
+    const n = index.useNamespace("timeline");
+    return vue.provide("timeline", e), () => vue.h("ul", { class: [n.b()] }, [vue.renderSlot(e, "default")]);
+  }
+});
+exports.default = s;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/tooltip/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tooltip2 = require("./src/tooltip2.js");
+const install = require("../../utils/vue/install.js");
+const p = install.withInstall(tooltip2.default);
+exports.ElTooltip = p;
+exports.default = p;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/tooltip/src/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const o = Symbol("elTooltip");
+exports.TOOLTIP_INJECTION_KEY = o;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/tooltip/src/content.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runtime = require("../../../utils/vue/props/runtime.js");
+const index = require("../../../hooks/use-delayed-toggle/index.js");
+const content2 = require("../../popper/src/content2.js");
+const a = runtime.buildProps({
+  ...index.useDelayedToggleProps,
+  ...content2.popperContentProps,
+  appendTo: {
+    type: runtime.definePropType([String, Object])
+  },
+  content: {
+    type: String,
+    default: ""
+  },
+  rawContent: {
+    type: Boolean,
+    default: false
+  },
+  persistent: Boolean,
+  ariaLabel: String,
+  visible: {
+    type: runtime.definePropType(Boolean),
+    default: null
+  },
+  transition: String,
+  teleported: {
+    type: Boolean,
+    default: true
+  },
+  disabled: Boolean
+});
+exports.useTooltipContentProps = a;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/tooltip/src/content2.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index$2 = require("../../../../../@vueuse/core/index.js");
+const constants = require("./constants.js");
+const content = require("./content.js");
+const pluginVue_exportHelper = require("../../../_virtual/plugin-vue_export-helper.js");
+const index = require("../../../hooks/use-popper-container/index.js");
+const index$1 = require("../../../hooks/use-namespace/index.js");
+const event = require("../../../utils/dom/event.js");
+const content$1 = require("../../popper/src/content.js");
+const se = vue.defineComponent({
+  name: "ElTooltipContent",
+  inheritAttrs: false
+}), ie = /* @__PURE__ */ vue.defineComponent({
+  ...se,
+  props: content.useTooltipContentProps,
+  setup(P, { expose: w }) {
+    const n = P, { selector: B } = index.usePopperContainerId(), S = index$1.useNamespace("tooltip"), l = vue.ref(null), u = vue.ref(false), {
+      controlled: f,
+      id: N,
+      open: a,
+      trigger: i,
+      onClose: s,
+      onOpen: O,
+      onShow: L,
+      onHide: A,
+      onBeforeShow: d,
+      onBeforeHide: c
+    } = vue.inject(constants.TOOLTIP_INJECTION_KEY, void 0), H = vue.computed(() => n.transition || `${S.namespace.value}-fade-in-linear`), I = vue.computed(() => n.persistent);
+    vue.onBeforeUnmount(() => {
+      u.value = true;
+    });
+    const R = vue.computed(() => vue.unref(I) ? true : vue.unref(a)), v = vue.computed(() => n.disabled ? false : vue.unref(a)), _ = vue.computed(() => n.appendTo || B.value), $ = vue.computed(() => {
+      var e;
+      return (e = n.style) != null ? e : {};
+    }), M = vue.computed(() => !vue.unref(a)), z = () => {
+      A();
+    }, m = () => {
+      if (vue.unref(f))
+        return true;
+    }, V = event.composeEventHandlers(m, () => {
+      n.enterable && vue.unref(i) === "hover" && O();
+    }), D = event.composeEventHandlers(m, () => {
+      vue.unref(i) === "hover" && s();
+    }), j = () => {
+      var e, r;
+      (r = (e = l.value) == null ? void 0 : e.updatePopper) == null || r.call(e), d == null || d();
+    }, J = () => {
+      c == null || c();
+    }, K = () => {
+      L(), p = index$2.onClickOutside(vue.computed(() => {
+        var e;
+        return (e = l.value) == null ? void 0 : e.popperContentRef;
+      }), () => {
+        if (vue.unref(f))
+          return;
+        vue.unref(i) !== "hover" && s();
+      });
+    }, U = () => {
+      n.virtualTriggering || s();
+    };
+    let p;
+    return vue.watch(() => vue.unref(a), (e) => {
+      e || p == null || p();
+    }, {
+      flush: "post"
+    }), vue.watch(() => n.content, () => {
+      var e, r;
+      (r = (e = l.value) == null ? void 0 : e.updatePopper) == null || r.call(e);
+    }), w({
+      contentRef: l
+    }), (e, r) => (vue.openBlock(), vue.createBlock(vue.Teleport, {
+      disabled: !e.teleported,
+      to: vue.unref(_)
+    }, [
+      vue.createVNode(vue.Transition, {
+        name: vue.unref(H),
+        onAfterLeave: z,
+        onBeforeEnter: j,
+        onAfterEnter: K,
+        onBeforeLeave: J
+      }, {
+        default: vue.withCtx(() => [
+          vue.unref(R) ? vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(content$1.default), vue.mergeProps({
+            key: 0,
+            id: vue.unref(N),
+            ref_key: "contentRef",
+            ref: l
+          }, e.$attrs, {
+            "aria-label": e.ariaLabel,
+            "aria-hidden": vue.unref(M),
+            "boundaries-padding": e.boundariesPadding,
+            "fallback-placements": e.fallbackPlacements,
+            "gpu-acceleration": e.gpuAcceleration,
+            offset: e.offset,
+            placement: e.placement,
+            "popper-options": e.popperOptions,
+            strategy: e.strategy,
+            effect: e.effect,
+            enterable: e.enterable,
+            pure: e.pure,
+            "popper-class": e.popperClass,
+            "popper-style": [e.popperStyle, vue.unref($)],
+            "reference-el": e.referenceEl,
+            "trigger-target-el": e.triggerTargetEl,
+            visible: vue.unref(v),
+            "z-index": e.zIndex,
+            onMouseenter: vue.unref(V),
+            onMouseleave: vue.unref(D),
+            onBlur: U,
+            onClose: vue.unref(s)
+          }), {
+            default: vue.withCtx(() => [
+              u.value ? vue.createCommentVNode("v-if", true) : vue.renderSlot(e.$slots, "default", { key: 0 })
+            ]),
+            _: 3
+          }, 16, ["id", "aria-label", "aria-hidden", "boundaries-padding", "fallback-placements", "gpu-acceleration", "offset", "placement", "popper-options", "strategy", "effect", "enterable", "pure", "popper-class", "popper-style", "reference-el", "trigger-target-el", "visible", "z-index", "onMouseenter", "onMouseleave", "onClose"])), [
+            [vue.vShow, vue.unref(v)]
+          ]) : vue.createCommentVNode("v-if", true)
+        ]),
+        _: 3
+      }, 8, ["name"])
+    ], 8, ["disabled", "to"]));
+  }
+});
+var he = /* @__PURE__ */ pluginVue_exportHelper.default(ie, [["__file", "content.vue"]]);
+exports.default = he;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/tooltip/src/tooltip.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const content = require("./content.js");
+const trigger = require("./trigger.js");
+const index = require("../../../hooks/use-model-toggle/index.js");
+const runtime = require("../../../utils/vue/props/runtime.js");
+const popper2 = require("../../popper/src/popper2.js");
+const arrow = require("../../popper/src/arrow.js");
+const {
+  useModelToggleProps: t,
+  useModelToggleEmits: i,
+  useModelToggle: P
+} = index.createModelToggleComposable("visible"), n = runtime.buildProps({
+  ...popper2.popperProps,
+  ...t,
+  ...content.useTooltipContentProps,
+  ...trigger.useTooltipTriggerProps,
+  ...arrow.popperArrowProps,
+  showArrow: {
+    type: Boolean,
+    default: true
+  }
+}), M = [
+  ...i,
+  "before-show",
+  "before-hide",
+  "show",
+  "hide",
+  "open",
+  "close"
+];
+exports.tooltipEmits = M;
+exports.useTooltipModelToggle = P;
+exports.useTooltipModelToggleEmits = i;
+exports.useTooltipModelToggleProps = t;
+exports.useTooltipProps = n;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/tooltip/src/tooltip2.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index$3 = require("../../popper/index.js");
+const constants = require("./constants.js");
+const tooltip = require("./tooltip.js");
+const trigger2 = require("./trigger2.js");
+const content2 = require("./content2.js");
+const pluginVue_exportHelper = require("../../../_virtual/plugin-vue_export-helper.js");
+const index = require("../../../hooks/use-popper-container/index.js");
+const index$1 = require("../../../hooks/use-id/index.js");
+const index$2 = require("../../../hooks/use-delayed-toggle/index.js");
+const types = require("../../../utils/types.js");
+const arrow2 = require("../../popper/src/arrow2.js");
+const _ = ["innerHTML"], x = { key: 1 }, ee = vue.defineComponent({
+  name: "ElTooltip"
+}), oe = /* @__PURE__ */ vue.defineComponent({
+  ...ee,
+  props: tooltip.useTooltipProps,
+  emits: tooltip.tooltipEmits,
+  setup(R, { expose: A, emit: a }) {
+    const o = R;
+    index.usePopperContainer();
+    const P = index$1.useId(), f = vue.ref(), d = vue.ref(), v = () => {
+      var e;
+      const t = vue.unref(f);
+      t && ((e = t.popperInstanceRef) == null || e.update());
+    }, r = vue.ref(false), n = vue.ref(), { show: I, hide: g, hasUpdateHandler: O } = tooltip.useTooltipModelToggle({
+      indicator: r,
+      toggleReason: n
+    }), { onOpen: u, onClose: m } = index$2.useDelayedToggle({
+      showAfter: vue.toRef(o, "showAfter"),
+      hideAfter: vue.toRef(o, "hideAfter"),
+      autoClose: vue.toRef(o, "autoClose"),
+      open: I,
+      close: g
+    }), B = vue.computed(() => types.isBoolean(o.visible) && !O.value);
+    vue.provide(constants.TOOLTIP_INJECTION_KEY, {
+      controlled: B,
+      id: P,
+      open: vue.readonly(r),
+      trigger: vue.toRef(o, "trigger"),
+      onOpen: (e) => {
+        u(e);
+      },
+      onClose: (e) => {
+        m(e);
+      },
+      onToggle: (e) => {
+        vue.unref(r) ? m(e) : u(e);
+      },
+      onShow: () => {
+        a("show", n.value);
+      },
+      onHide: () => {
+        a("hide", n.value);
+      },
+      onBeforeShow: () => {
+        a("before-show", n.value);
+      },
+      onBeforeHide: () => {
+        a("before-hide", n.value);
+      },
+      updatePopper: v
+    }), vue.watch(() => o.disabled, (e) => {
+      e && r.value && (r.value = false);
+    });
+    const H = (e) => {
+      var t, h;
+      const b = (h = (t = d.value) == null ? void 0 : t.contentRef) == null ? void 0 : h.popperContentRef, S = (e == null ? void 0 : e.relatedTarget) || document.activeElement;
+      return b && b.contains(S);
+    };
+    return vue.onDeactivated(() => r.value && g()), A({
+      popperRef: f,
+      contentRef: d,
+      isFocusInsideContent: H,
+      updatePopper: v,
+      onOpen: u,
+      onClose: m,
+      hide: g
+    }), (e, t) => (vue.openBlock(), vue.createBlock(vue.unref(index$3.ElPopper), {
+      ref_key: "popperRef",
+      ref: f,
+      role: e.role
+    }, {
+      default: vue.withCtx(() => [
+        vue.createVNode(trigger2.default, {
+          disabled: e.disabled,
+          trigger: e.trigger,
+          "trigger-keys": e.triggerKeys,
+          "virtual-ref": e.virtualRef,
+          "virtual-triggering": e.virtualTriggering
+        }, {
+          default: vue.withCtx(() => [
+            e.$slots.default ? vue.renderSlot(e.$slots, "default", { key: 0 }) : vue.createCommentVNode("v-if", true)
+          ]),
+          _: 3
+        }, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering"]),
+        vue.createVNode(content2.default, {
+          ref_key: "contentRef",
+          ref: d,
+          "aria-label": e.ariaLabel,
+          "boundaries-padding": e.boundariesPadding,
+          content: e.content,
+          disabled: e.disabled,
+          effect: e.effect,
+          enterable: e.enterable,
+          "fallback-placements": e.fallbackPlacements,
+          "hide-after": e.hideAfter,
+          "gpu-acceleration": e.gpuAcceleration,
+          offset: e.offset,
+          persistent: e.persistent,
+          "popper-class": e.popperClass,
+          "popper-style": e.popperStyle,
+          placement: e.placement,
+          "popper-options": e.popperOptions,
+          pure: e.pure,
+          "raw-content": e.rawContent,
+          "reference-el": e.referenceEl,
+          "trigger-target-el": e.triggerTargetEl,
+          "show-after": e.showAfter,
+          strategy: e.strategy,
+          teleported: e.teleported,
+          transition: e.transition,
+          "virtual-triggering": e.virtualTriggering,
+          "z-index": e.zIndex,
+          "append-to": e.appendTo
+        }, {
+          default: vue.withCtx(() => [
+            vue.renderSlot(e.$slots, "content", {}, () => [
+              e.rawContent ? (vue.openBlock(), vue.createElementBlock("span", {
+                key: 0,
+                innerHTML: e.content
+              }, null, 8, _)) : (vue.openBlock(), vue.createElementBlock("span", x, vue.toDisplayString(e.content), 1))
+            ]),
+            e.showArrow ? (vue.openBlock(), vue.createBlock(vue.unref(arrow2.default), {
+              key: 0,
+              "arrow-offset": e.arrowOffset
+            }, null, 8, ["arrow-offset"])) : vue.createCommentVNode("v-if", true)
+          ]),
+          _: 3
+        }, 8, ["aria-label", "boundaries-padding", "content", "disabled", "effect", "enterable", "fallback-placements", "hide-after", "gpu-acceleration", "offset", "persistent", "popper-class", "popper-style", "placement", "popper-options", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to"])
+      ]),
+      _: 3
+    }, 8, ["role"]));
+  }
+});
+var me = /* @__PURE__ */ pluginVue_exportHelper.default(oe, [["__file", "tooltip.vue"]]);
+exports.default = me;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/tooltip/src/trigger.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runtime = require("../../../utils/vue/props/runtime.js");
+const trigger = require("../../popper/src/trigger.js");
+const aria = require("../../../constants/aria.js");
+const s = runtime.buildProps({
+  ...trigger.popperTriggerProps,
+  disabled: Boolean,
+  trigger: {
+    type: runtime.definePropType([String, Array]),
+    default: "hover"
+  },
+  triggerKeys: {
+    type: runtime.definePropType(Array),
+    default: () => [aria.EVENT_CODE.enter, aria.EVENT_CODE.space]
+  }
+});
+exports.useTooltipTriggerProps = s;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/tooltip/src/trigger2.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const constants = require("./constants.js");
+const trigger = require("./trigger.js");
+const utils = require("./utils.js");
+const pluginVue_exportHelper = require("../../../_virtual/plugin-vue_export-helper.js");
+const index = require("../../../hooks/use-namespace/index.js");
+const event = require("../../../utils/dom/event.js");
+const trigger2 = require("../../popper/src/trigger2.js");
+const H = vue.defineComponent({
+  name: "ElTooltipTrigger"
+}), J = /* @__PURE__ */ vue.defineComponent({
+  ...H,
+  props: trigger.useTooltipTriggerProps,
+  setup(a, { expose: f }) {
+    const s = a, m = index.useNamespace("tooltip"), { controlled: d, id: v, open: T, onOpen: u, onClose: c, onToggle: l } = vue.inject(constants.TOOLTIP_INJECTION_KEY, void 0), C = vue.ref(null), n = () => {
+      if (vue.unref(d) || s.disabled)
+        return true;
+    }, t = vue.toRef(s, "trigger"), _ = event.composeEventHandlers(n, utils.whenTrigger(t, "hover", u)), M = event.composeEventHandlers(n, utils.whenTrigger(t, "hover", c)), h = event.composeEventHandlers(n, utils.whenTrigger(t, "click", (o) => {
+      o.button === 0 && l(o);
+    })), k = event.composeEventHandlers(n, utils.whenTrigger(t, "focus", u)), E = event.composeEventHandlers(n, utils.whenTrigger(t, "focus", c)), w = event.composeEventHandlers(n, utils.whenTrigger(t, "contextmenu", (o) => {
+      o.preventDefault(), l(o);
+    })), x = event.composeEventHandlers(n, (o) => {
+      const { code: g } = o;
+      s.triggerKeys.includes(g) && (o.preventDefault(), l(o));
+    });
+    return f({
+      triggerRef: C
+    }), (o, g) => (vue.openBlock(), vue.createBlock(vue.unref(trigger2.default), {
+      id: vue.unref(v),
+      "virtual-ref": o.virtualRef,
+      open: vue.unref(T),
+      "virtual-triggering": o.virtualTriggering,
+      class: vue.normalizeClass(vue.unref(m).e("trigger")),
+      onBlur: vue.unref(E),
+      onClick: vue.unref(h),
+      onContextmenu: vue.unref(w),
+      onFocus: vue.unref(k),
+      onMouseenter: vue.unref(_),
+      onMouseleave: vue.unref(M),
+      onKeydown: vue.unref(x)
+    }, {
+      default: vue.withCtx(() => [
+        vue.renderSlot(o.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]));
+  }
+});
+var Q = /* @__PURE__ */ pluginVue_exportHelper.default(J, [["__file", "trigger.vue"]]);
+exports.default = Q;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/components/tooltip/src/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const shared_esmBundler = require("../../../../../@vue/shared/dist/shared.esm-bundler.js");
+const t = (r, n) => shared_esmBundler.isArray(r) ? r.includes(n) : r === n, m = (r, n, e) => (o) => {
+  t(vue.unref(r), n) && e(o);
+};
+exports.isTriggerType = t;
+exports.whenTrigger = m;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/constants/aria.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const e = {
+  tab: "Tab",
+  enter: "Enter",
+  space: "Space",
+  esc: "Escape"
+};
+exports.EVENT_CODE = e;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/hooks/use-delayed-toggle/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const index = require("../use-timeout/index.js");
+const runtime = require("../../utils/vue/props/runtime.js");
+const types = require("../../utils/types.js");
+const A = runtime.buildProps({
+  showAfter: {
+    type: Number,
+    default: 0
+  },
+  hideAfter: {
+    type: Number,
+    default: 200
+  },
+  autoClose: {
+    type: Number,
+    default: 0
+  }
+}), N = ({
+  showAfter: m,
+  hideAfter: i,
+  autoClose: n,
+  open: l,
+  close: r
+}) => {
+  const { registerTimeout: u } = index.useTimeout(), {
+    registerTimeout: p,
+    cancelTimeout: f
+  } = index.useTimeout();
+  return {
+    onOpen: (e) => {
+      u(() => {
+        l(e);
+        const o = vue.unref(n);
+        types.isNumber(o) && o > 0 && p(() => {
+          r(e);
+        }, o);
+      }, vue.unref(m));
+    },
+    onClose: (e) => {
+      f(), u(() => {
+        r(e);
+      }, vue.unref(i));
+    }
+  };
+};
+exports.useDelayedToggle = N;
+exports.useDelayedToggleProps = A;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/hooks/use-escape-keydown/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const aria = require("../../constants/aria.js");
+const index = require("../../../../@vueuse/shared/index.js");
+let e = [];
+const r = (n) => {
+  const o = n;
+  o.key === aria.EVENT_CODE.esc && e.forEach((i) => i(o));
+}, p = (n) => {
+  vue.onMounted(() => {
+    e.length === 0 && document.addEventListener("keydown", r), index.isClient && e.push(n);
+  }), vue.onBeforeUnmount(() => {
+    e = e.filter((o) => o !== n), e.length === 0 && index.isClient && document.removeEventListener("keydown", r);
+  });
+};
+exports.useEscapeKeydown = p;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/hooks/use-forward-ref/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const n = Symbol("elForwardRef"), d = (e) => {
+  vue.provide(n, {
+    setForwardRef: (r) => {
+      e.value = r;
+    }
+  });
+}, s = (e) => ({
+  mounted(o) {
+    e(o);
+  },
+  updated(o) {
+    e(o);
+  },
+  unmounted() {
+    e(null);
+  }
+});
+exports.FORWARD_REF_INJECTION_KEY = n;
+exports.useForwardRef = d;
+exports.useForwardRefDirective = s;

package/lib/node_modules/.pnpm/h-vue3-flow@1.0.0_typescript@5.7.3/node_modules/h-vue3-flow/es/node_modules/element-plus/es/hooks/use-id/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const index = require("../use-namespace/index.js");
+require("../../../../@vueuse/shared/index.js");
+const r = {
+  prefix: Math.floor(Math.random() * 1e4),
+  current: 0
+}, I = Symbol("elIdInjection"), a = () => vue.getCurrentInstance() ? vue.inject(I, r) : r, b = (n) => {
+  const e = a();
+  const o = index.useGetDerivedNamespace();
+  return vue.computed(() => vue.unref(n) || `${o.value}-id-${e.prefix}-${e.current++}`);
+};
+exports.ID_INJECTION_KEY = I;
+exports.useId = b;
+exports.useIdInjection = a;