ep-craft 0.1.20 → 0.1.21

package/dist/components/popper/src/popper.vue.js

@@ -0,0 +1,38 @@
+import { defineComponent as i, ref as e, computed as m, provide as d, renderSlot as u } from "vue";
+import { POPPER_INJECTION_KEY as _ } from "./constants.js";
+const I = /* @__PURE__ */ i({
+  name: "ElPopper",
+  inheritAttrs: !1,
+  __name: "popper",
+  props: {
+    role: { default: "tooltip" }
+  },
+  setup(t, { expose: r }) {
+    const p = t, n = e(), s = e(), c = e(), f = e(), l = m(() => p.role), o = {
+      /**
+       * @description trigger element
+       */
+      triggerRef: n,
+      /**
+       * @description popperjs instance
+       */
+      popperInstanceRef: s,
+      /**
+       * @description popper content element
+       */
+      contentRef: c,
+      /**
+       * @description popper reference element
+       */
+      referenceRef: f,
+      /**
+       * @description role determines how aria attributes are distributed
+       */
+      role: l
+    };
+    return r(o), d(_, o), (a, P) => u(a.$slots, "default");
+  }
+});
+export {
+  I as default
+};

package/dist/components/popper/src/popper2.vue.js

@@ -0,0 +1,4 @@
+import f from "./popper.vue.js";
+export {
+  f as default
+};

package/dist/components/popper/src/trigger.d.ts

@@ -0,0 +1,130 @@
+import type { Measurable } from './constants';
+import type Trigger from './trigger.vue';
+export interface PopperTriggerProps {
+    /** @description Indicates the reference element to which the popper is attached */
+    virtualRef?: Measurable;
+    /** @description Indicates whether virtual triggering is enabled */
+    virtualTriggering?: boolean;
+    onMouseenter?: (e: MouseEvent) => void;
+    onMouseleave?: (e: MouseEvent) => void;
+    onClick?: (e: PointerEvent) => void;
+    onKeydown?: (e: KeyboardEvent) => void;
+    onFocus?: (e: FocusEvent) => void;
+    onBlur?: (e: FocusEvent) => void;
+    onContextmenu?: (e: PointerEvent) => void;
+    id?: string;
+    open?: boolean;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperTriggerProps` instead.
+ */
+export declare const popperTriggerProps: {
+    readonly virtualRef: {
+        readonly type: import("vue").PropType<Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly virtualTriggering: BooleanConstructor;
+    readonly onMouseenter: {
+        readonly type: import("vue").PropType<(e: MouseEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onMouseleave: {
+        readonly type: import("vue").PropType<(e: MouseEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onClick: {
+        readonly type: import("vue").PropType<(e: PointerEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onFocus: {
+        readonly type: import("vue").PropType<(e: FocusEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onBlur: {
+        readonly type: import("vue").PropType<(e: FocusEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onContextmenu: {
+        readonly type: import("vue").PropType<(e: PointerEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly id: StringConstructor;
+    readonly open: BooleanConstructor;
+};
+export type PopperTriggerInstance = InstanceType<typeof Trigger> & unknown;
+/** @deprecated use `popperTriggerProps` instead, and it will be deprecated in the next major version */
+export declare const usePopperTriggerProps: {
+    readonly virtualRef: {
+        readonly type: import("vue").PropType<Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly virtualTriggering: BooleanConstructor;
+    readonly onMouseenter: {
+        readonly type: import("vue").PropType<(e: MouseEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onMouseleave: {
+        readonly type: import("vue").PropType<(e: MouseEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onClick: {
+        readonly type: import("vue").PropType<(e: PointerEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onFocus: {
+        readonly type: import("vue").PropType<(e: FocusEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onBlur: {
+        readonly type: import("vue").PropType<(e: FocusEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onContextmenu: {
+        readonly type: import("vue").PropType<(e: PointerEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly id: StringConstructor;
+    readonly open: BooleanConstructor;
+};
+/** @deprecated use `PopperTriggerInstance` instead, and it will be deprecated in the next major version */
+export type ElPopperArrowTrigger = PopperTriggerInstance;

package/dist/components/popper/src/trigger.js

@@ -0,0 +1,36 @@
+import { buildProps as n, definePropType as o } from "../../../utils/vue/props/runtime.js";
+import "vue";
+const i = n({
+  /** @description Indicates the reference element to which the popper is attached */
+  virtualRef: {
+    type: o(Object)
+  },
+  /** @description Indicates whether virtual triggering is enabled */
+  virtualTriggering: Boolean,
+  onMouseenter: {
+    type: o(Function)
+  },
+  onMouseleave: {
+    type: o(Function)
+  },
+  onClick: {
+    type: o(Function)
+  },
+  onKeydown: {
+    type: o(Function)
+  },
+  onFocus: {
+    type: o(Function)
+  },
+  onBlur: {
+    type: o(Function)
+  },
+  onContextmenu: {
+    type: o(Function)
+  },
+  id: String,
+  open: Boolean
+});
+export {
+  i as popperTriggerProps
+};

package/dist/components/popper/src/trigger.vue.d.ts

@@ -0,0 +1,18 @@
+import type { PopperTriggerProps } from './trigger';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<PopperTriggerProps, {
+    /**
+     * @description trigger element
+     */
+    triggerRef: import("vue").Ref<import("./constants").Measurable | undefined, import("./constants").Measurable | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PopperTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/popper/src/trigger.vue.js

@@ -0,0 +1,4 @@
+import f from "./trigger2.vue.js";
+export {
+  f as default
+};

package/dist/components/popper/src/trigger2.vue.js

@@ -0,0 +1,134 @@
+import { defineComponent as h, inject as C, computed as d, onMounted as B, watch as l, onBeforeUnmount as x, openBlock as g, createBlock as w, unref as L, mergeProps as R, withCtx as _, renderSlot as M, createCommentVNode as P } from "vue";
+import { unrefElement as k } from "../../../node_modules/.pnpm/@vueuse_core@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js";
+import { OnlyChild as I } from "../../slot/src/only-child.js";
+import { isElement as c } from "../../../utils/types.js";
+import { isFocusable as b } from "../../../utils/dom/aria.js";
+import "../../../hooks/use-size/index.js";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import { useForwardRef as K } from "../../../hooks/use-forward-ref/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { POPPER_INJECTION_KEY as O } from "./constants.js";
+import T from "../../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isNil.js";
+const Z = /* @__PURE__ */ h({
+  name: "ElPopperTrigger",
+  inheritAttrs: !1,
+  __name: "trigger",
+  props: {
+    virtualRef: {},
+    virtualTriggering: { type: Boolean },
+    onMouseenter: { type: Function },
+    onMouseleave: { type: Function },
+    onClick: { type: Function },
+    onKeydown: { type: Function },
+    onFocus: { type: Function },
+    onBlur: { type: Function },
+    onContextmenu: { type: Function },
+    id: {},
+    open: { type: Boolean }
+  },
+  setup(m, { expose: F }) {
+    const n = m, { role: u, triggerRef: i } = C(O, void 0);
+    K(i);
+    const f = d(() => s.value ? n.id : void 0), v = d(() => {
+      if (u && u.value === "tooltip")
+        return n.open && n.id ? n.id : void 0;
+    }), s = d(() => {
+      if (u && u.value !== "tooltip")
+        return u.value;
+    }), y = d(() => s.value ? `${n.open}` : void 0);
+    let t;
+    const p = [
+      "onMouseenter",
+      "onMouseleave",
+      "onClick",
+      "onKeydown",
+      "onFocus",
+      "onBlur",
+      "onContextmenu"
+    ];
+    return B(() => {
+      l(
+        () => n.virtualRef,
+        (e) => {
+          e && (i.value = k(e));
+        },
+        {
+          immediate: !0
+        }
+      ), l(
+        i,
+        (e, r) => {
+          t == null || t(), t = void 0, c(r) && p.forEach((o) => {
+            const a = n[o];
+            a && r.removeEventListener(
+              o.slice(2).toLowerCase(),
+              a,
+              ["onFocus", "onBlur"].includes(o)
+            );
+          }), c(e) && (p.forEach((o) => {
+            const a = n[o];
+            a && e.addEventListener(
+              o.slice(2).toLowerCase(),
+              a,
+              ["onFocus", "onBlur"].includes(o)
+            );
+          }), b(e) && (t = l(
+            [f, v, s, y],
+            (o) => {
+              [
+                "aria-controls",
+                "aria-describedby",
+                "aria-haspopup",
+                "aria-expanded"
+              ].forEach((a, E) => {
+                T(o[E]) ? e.removeAttribute(a) : e.setAttribute(a, o[E]);
+              });
+            },
+            { immediate: !0 }
+          ))), c(r) && b(r) && [
+            "aria-controls",
+            "aria-describedby",
+            "aria-haspopup",
+            "aria-expanded"
+          ].forEach((o) => r.removeAttribute(o));
+        },
+        {
+          immediate: !0
+        }
+      );
+    }), x(() => {
+      if (t == null || t(), t = void 0, i.value && c(i.value)) {
+        const e = i.value;
+        p.forEach((r) => {
+          const o = n[r];
+          o && e.removeEventListener(
+            r.slice(2).toLowerCase(),
+            o,
+            ["onFocus", "onBlur"].includes(r)
+          );
+        }), i.value = void 0;
+      }
+    }), F({
+      /**
+       * @description trigger element
+       */
+      triggerRef: i
+    }), (e, r) => m.virtualTriggering ? P("", !0) : (g(), w(L(I), R({ key: 0 }, e.$attrs, {
+      "aria-controls": f.value,
+      "aria-describedby": v.value,
+      "aria-expanded": y.value,
+      "aria-haspopup": s.value
+    }), {
+      default: _(() => [
+        M(e.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["aria-controls", "aria-describedby", "aria-expanded", "aria-haspopup"]));
+  }
+});
+export {
+  Z as default
+};

package/dist/components/popper/src/utils.d.ts

@@ -0,0 +1,48 @@
+import type { ComponentPublicInstance, MaybeRef } from 'vue';
+import type { Modifier } from '@popperjs/core';
+import type { Measurable } from './constants';
+import type { PopperCoreConfigProps } from './content';
+export declare const buildPopperOptions: (props: PopperCoreConfigProps, modifiers?: Modifier<any, any>[]) => {
+    modifiers: (Modifier<any, any> | {
+        name: string;
+        options: {
+            offset: number[];
+            padding?: undefined;
+            fallbackPlacements?: undefined;
+            gpuAcceleration?: undefined;
+        };
+    } | {
+        name: string;
+        options: {
+            padding: {
+                top: number;
+                bottom: number;
+                left: number;
+                right: number;
+            };
+            offset?: undefined;
+            fallbackPlacements?: undefined;
+            gpuAcceleration?: undefined;
+        };
+    } | {
+        name: string;
+        options: {
+            padding: number;
+            fallbackPlacements: import("element-plus").Placement[] | undefined;
+            offset?: undefined;
+            gpuAcceleration?: undefined;
+        };
+    } | {
+        name: string;
+        options: {
+            gpuAcceleration: boolean | undefined;
+            offset?: undefined;
+            padding?: undefined;
+            fallbackPlacements?: undefined;
+        };
+    })[];
+    placement: import("element-plus").Placement | undefined;
+    strategy: import("@popperjs/core").PositioningStrategy | undefined;
+    onFirstUpdate?: (arg0: Partial<import("@popperjs/core").State>) => void;
+};
+export declare const unwrapMeasurableEl: ($el: MaybeRef<Measurable | undefined | ComponentPublicInstance>) => HTMLElement | undefined;

package/dist/components/popper/src/utils.js

@@ -0,0 +1,57 @@
+import { unrefElement as f } from "../../../node_modules/.pnpm/@vueuse_core@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js";
+import "vue";
+import { isClient as s } from "../../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+const u = (e, t = []) => {
+  const { placement: n, strategy: i, popperOptions: o } = e, r = {
+    placement: n,
+    strategy: i,
+    ...o,
+    modifiers: [...m(e), ...t]
+  };
+  return a(r, o == null ? void 0 : o.modifiers), r;
+}, d = (e) => {
+  if (s)
+    return f(e);
+};
+function m(e) {
+  const { offset: t, gpuAcceleration: n, fallbackPlacements: i } = e;
+  return [
+    {
+      name: "offset",
+      options: {
+        offset: [0, t ?? 12]
+      }
+    },
+    {
+      name: "preventOverflow",
+      options: {
+        padding: {
+          top: 0,
+          bottom: 0,
+          left: 0,
+          right: 0
+        }
+      }
+    },
+    {
+      name: "flip",
+      options: {
+        padding: 5,
+        fallbackPlacements: i
+      }
+    },
+    {
+      name: "computeStyles",
+      options: {
+        gpuAcceleration: n
+      }
+    }
+  ];
+}
+function a(e, t) {
+  t && (e.modifiers = [...e.modifiers, ...t ?? []]);
+}
+export {
+  u as buildPopperOptions,
+  d as unwrapMeasurableEl
+};

package/dist/components/slot/index.d.ts

@@ -0,0 +1,3 @@
+import { OnlyChild } from "./src/only-child";
+export { OnlyChild as ElOnlyChild, OnlyChild };
+export * from './src/only-child';

package/dist/components/slot/src/only-child.d.ts

@@ -0,0 +1,7 @@
+import type { Ref, VNode } from 'vue';
+export declare const OnlyChild: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type OnlyChildExpose = {
+    forwardRef: Ref<HTMLElement>;
+};

package/dist/components/slot/src/only-child.js

@@ -0,0 +1,55 @@
+import { defineComponent as p, inject as h, withDirectives as g, cloneVNode as C, Comment as u, Fragment as N, Text as O } from "vue";
+import { NOOP as v, isObject as y } from "../../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { debugWarn as f } from "../../../utils/error.js";
+import { useNamespace as E } from "../../../hooks/use-namespace/index.js";
+import "../../../hooks/use-size/index.js";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import { FORWARD_REF_INJECTION_KEY as F, useForwardRefDirective as R } from "../../../hooks/use-forward-ref/index.js";
+import "../../../hooks/use-empty-values/index.js";
+const i = "ElOnlyChild", I = p({
+  name: i,
+  setup(r, { slots: t, attrs: n }) {
+    const e = h(F), a = R(
+      (e == null ? void 0 : e.setForwardRef) ?? v
+    );
+    return () => {
+      var l;
+      const o = (l = t.default) == null ? void 0 : l.call(t, n);
+      if (!o) return null;
+      const [c, s] = d(o);
+      return c ? (s > 1 && f(i, "requires exact only one valid child."), g(C(c, n), [
+        [a]
+      ])) : (f(i, "no valid child node found"), null);
+    };
+  }
+});
+function d(r) {
+  if (!r) return [null, 0];
+  const t = r, n = t.filter((e) => e.type !== u).length;
+  for (const e of t) {
+    if (y(e))
+      switch (e.type) {
+        case u:
+          continue;
+        case O:
+        case "svg":
+          return [m(e), n];
+        case N:
+          return d(e.children);
+        default:
+          return [e, n];
+      }
+    return [m(e), n];
+  }
+  return [null, 0];
+}
+function m(r) {
+  const t = E("only-child");
+  return /* @__PURE__ */ React.createElement("span", { class: t.e("content") }, r);
+}
+export {
+  I as OnlyChild
+};

package/dist/components/tabs/tabs.d.ts

@@ -102,8 +102,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly type: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "" | "card" | "border-card", unknown>;
     readonly closable: boolean;
     readonly tabindex: import("element-plus/es/utils/index.mjs").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
-    readonly editable: boolean;
     readonly stretch: boolean;
+    readonly editable: boolean;
     readonly addable: boolean;
     readonly tabPosition: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "top" | "bottom" | "left" | "right", unknown>;
     readonly beforeLeave: (newName: TabPaneName, oldName: TabPaneName) => import("element-plus/es/utils/typescript.mjs").Awaitable<void | boolean>;

package/dist/components/tag/EpTag.vue.js

@@ -0,0 +1,96 @@
+import { defineComponent as F, computed as K, openBlock as a, createElementBlock as u, normalizeStyle as C, normalizeClass as l, createElementVNode as m, renderSlot as h, withModifiers as y, unref as t, createVNode as c, withCtx as p, createCommentVNode as $, createBlock as L, Transition as P } from "vue";
+import { Close as E } from "../../node_modules/.pnpm/@element-plus_icons-vue@2.3.2_vue@3.5.40_typescript@5.9.3_/node_modules/@element-plus/icons-vue/dist/index.js";
+import { ElIcon as j } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/icon/index.js";
+import { useLocale as q } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/hooks/use-locale/index.js";
+import { useFormSize as A } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/form/src/hooks/use-form-common-props.js";
+import { tagEmits as D, tagProps as G } from "./tag.js";
+const H = {
+  class: /* @__PURE__ */ l("el-tag__content")
+}, J = ["aria-label"], O = {
+  class: /* @__PURE__ */ l("el-tag__content")
+}, Q = ["aria-label"], T = "el", z = "tag", v = /* @__PURE__ */ F({
+  name: "EpTag",
+  __name: "EpTag",
+  props: G,
+  emits: D,
+  setup(V, { emit: N }) {
+    const d = j, S = V, b = N, { t: f } = q(), B = A(), M = () => `${T}-${z}`, r = (e) => e ? `${T}-${z}--${e}` : "", i = (e, o = !0) => e && o ? `is-${e}` : "", _ = K(() => {
+      const { type: e, hit: o, effect: s, closable: n, round: I } = S;
+      return [
+        M(),
+        i("closable", n),
+        r(e || "primary"),
+        r(B.value),
+        r(s),
+        i("hit", o),
+        i("round", I)
+      ];
+    }), k = (e) => {
+      b("close", e);
+    }, g = (e) => {
+      b("click", e);
+    }, w = (e) => {
+      var o, s, n;
+      (n = (s = (o = e == null ? void 0 : e.component) == null ? void 0 : o.subTree) == null ? void 0 : s.component) != null && n.bum && (e.component.subTree.component.bum = null);
+    };
+    return (e, o) => e.disableTransitions ? (a(), u("span", {
+      key: 0,
+      class: l(_.value),
+      style: C({ backgroundColor: e.color }),
+      onClick: g
+    }, [
+      m("span", H, [
+        h(e.$slots, "default")
+      ]),
+      e.closable ? (a(), u("button", {
+        key: 0,
+        "aria-label": t(f)("el.tag.close"),
+        class: l("el-tag__close"),
+        type: "button",
+        onClick: y(k, ["stop"])
+      }, [
+        c(t(d), null, {
+          default: p(() => [
+            c(t(E))
+          ]),
+          _: 1
+        })
+      ], 8, J)) : $("", !0)
+    ], 6)) : (a(), L(P, {
+      key: 1,
+      name: "el-zoom-in-center",
+      appear: "",
+      onVnodeMounted: w
+    }, {
+      default: p(() => [
+        m("span", {
+          class: l(_.value),
+          style: C({ backgroundColor: e.color }),
+          onClick: g
+        }, [
+          m("span", O, [
+            h(e.$slots, "default")
+          ]),
+          e.closable ? (a(), u("button", {
+            key: 0,
+            "aria-label": t(f)("el.tag.close"),
+            class: l("el-tag__close"),
+            type: "button",
+            onClick: y(k, ["stop"])
+          }, [
+            c(t(d), null, {
+              default: p(() => [
+                c(t(E))
+              ]),
+              _: 1
+            })
+          ], 8, Q)) : $("", !0)
+        ], 6)
+      ]),
+      _: 3
+    }, 512));
+  }
+});
+export {
+  v as default
+};

package/dist/components/tag/EpTag2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpTag.vue.js";
+export {
+  f as default
+};

package/dist/components/tag/index.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin } from 'vue';
-import { ElTag } from 'element-plus';
-export declare const EpTag: typeof ElTag & Plugin;
+import _EpTag from './EpTag.vue';
+export declare const EpTag: typeof _EpTag & Plugin;
 export default EpTag;

package/dist/components/tag/index.js

@@ -1,7 +1,6 @@
-import "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/index.js";
 import { withInstall as t } from "../../utils/with-install.js";
-import { ElTag as a } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tag/index.js";
-const o = Object.assign({}, a, { name: "EpTag" }), r = t(o, "ep-tag");
+import o from "./EpTag.vue.js";
+const r = t(o, "ep-tag");
 export {
   r as EpTag
 };