ep-craft 0.1.19 → 0.1.21

package/dist/components/tooltip/src/content.d.ts

@@ -0,0 +1,327 @@
+import type { AriaProps, UseDelayedToggleProps } from '@element-plus/hooks';
+import type { PopperContentProps } from '@element-plus/components/popper';
+import type TooltipContent from './content.vue';
+import type { ExtractPublicPropTypes } from 'vue';
+export interface ElTooltipContentProps extends UseDelayedToggleProps, Omit<PopperContentProps, 'visible'> {
+    /**
+     * @description which element the tooltip CONTENT appends to
+     */
+    appendTo?: string | HTMLElement;
+    /**
+     * @description display content, can be overridden by `slot#content`
+     */
+    content?: string;
+    /**
+     * @description whether `content` is treated as HTML string
+     */
+    rawContent?: boolean;
+    /**
+     * @description when tooltip inactive and `persistent` is `false` , popconfirm will be destroyed
+     */
+    persistent?: boolean;
+    /**
+     * @description visibility of Tooltip
+     */
+    visible?: boolean | null;
+    /**
+     * @description animation name
+     */
+    transition?: string;
+    /**
+     * @description whether tooltip content is teleported, if `true` it will be teleported to where `append-to` sets
+     */
+    teleported?: boolean;
+    /**
+     * @description whether Tooltip is disabled
+     */
+    disabled?: boolean;
+    ariaLabel?: AriaProps['ariaLabel'];
+}
+export declare const useTooltipContentPropsDefaults: {
+    readonly content: "";
+    readonly visible: null;
+    readonly teleported: true;
+    readonly effect: "dark";
+    readonly enterable: true;
+    readonly stopPopperMouseEvent: true;
+    readonly pure: false;
+    readonly focusOnShow: false;
+    readonly trapping: false;
+    readonly virtualTriggering: false;
+    readonly loop: false;
+    readonly style: undefined;
+    readonly popperStyle: undefined;
+    readonly arrowOffset: 5;
+    readonly boundariesPadding: 0;
+    readonly gpuAcceleration: true;
+    readonly offset: 12;
+    readonly placement: "bottom";
+    readonly popperOptions: () => {};
+    readonly strategy: "absolute";
+    readonly showAfter: 0;
+    readonly hideAfter: 200;
+    readonly autoClose: 0;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `ElTooltipContentProps` instead.
+ */
+export declare const useTooltipContentProps: {
+    readonly ariaLabel: StringConstructor;
+    readonly appendTo: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly content: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly rawContent: BooleanConstructor;
+    readonly persistent: BooleanConstructor;
+    readonly visible: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => boolean) | (() => boolean | null) | (((new (...args: any[]) => boolean) | (() => boolean | null)) | null)[], unknown, unknown, null, boolean>;
+    readonly transition: StringConstructor;
+    readonly teleported: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly loop: BooleanConstructor;
+    readonly id: StringConstructor;
+    readonly style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly className: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly effect: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string) | (() => import("@element-plus/components/popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("@element-plus/components/popper").PopperEffect)) | null)[], unknown, unknown, "dark", boolean>;
+    readonly enterable: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly pure: BooleanConstructor;
+    readonly focusOnShow: BooleanConstructor;
+    readonly trapping: BooleanConstructor;
+    readonly popperClass: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly popperStyle: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly referenceEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly triggerTargetEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly stopPopperMouseEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly virtualTriggering: BooleanConstructor;
+    readonly zIndex: NumberConstructor;
+    readonly arrowOffset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
+    readonly boundariesPadding: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly fallbackPlacements: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, undefined, boolean>;
+    readonly gpuAcceleration: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, import("element-plus").Placement, unknown, "bottom", boolean>;
+    readonly popperOptions: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly strategy: import("@element-plus/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
+    readonly showAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly hideAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
+    readonly autoClose: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `ElTooltipContentProps` instead.
+ */
+export type ElTooltipContentPropsPublic = ExtractPublicPropTypes<typeof useTooltipContentProps>;
+export type TooltipContentInstance = InstanceType<typeof TooltipContent> & unknown;

package/dist/components/tooltip/src/content.js

@@ -0,0 +1,72 @@
+import { buildProps as o, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import "../../popper/index.js";
+import "../../../hooks/use-size/index.js";
+import "../../../hooks/use-z-index/index.js";
+import { useDelayedToggleProps as t, useDelayedTogglePropsDefaults as p } from "../../../hooks/use-delayed-toggle/index.js";
+import { useAriaProps as r } from "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { popperContentPropsDefaults as n, popperContentProps as l } from "../../popper/src/content.js";
+const b = {
+  ...p,
+  ...n,
+  content: "",
+  visible: null,
+  teleported: !0
+}, T = o({
+  ...t,
+  ...l,
+  /**
+   * @description which element the tooltip CONTENT appends to
+   */
+  appendTo: {
+    type: e([String, Object])
+  },
+  /**
+   * @description display content, can be overridden by `slot#content`
+   */
+  content: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description whether `content` is treated as HTML string
+   */
+  rawContent: Boolean,
+  /**
+   * @description when tooltip inactive and `persistent` is `false` , popconfirm will be destroyed
+   */
+  persistent: Boolean,
+  // because model toggle prop is generated dynamically
+  // so the typing cannot be evaluated by typescript as type:
+  // [name]: { type: Boolean, default: null }
+  // so we need to declare that again for type checking.
+  /**
+   * @description visibility of Tooltip
+   */
+  visible: {
+    type: e(Boolean),
+    default: null
+  },
+  /**
+   * @description animation name
+   */
+  transition: String,
+  /**
+   * @description whether tooltip content is teleported, if `true` it will be teleported to where `append-to` sets
+   */
+  teleported: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description whether Tooltip is disabled
+   */
+  disabled: Boolean,
+  ...r(["ariaLabel"])
+});
+export {
+  T as useTooltipContentProps,
+  b as useTooltipContentPropsDefaults
+};

package/dist/components/tooltip/src/content.vue.d.ts

@@ -0,0 +1,47 @@
+import type { ElTooltipContentProps } from './content';
+import type { PopperContentInstance } from '@element-plus/components/popper';
+declare var __VLS_29: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_29) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ElTooltipContentProps, {
+    /**
+     * @description el-popper-content component instance
+     */
+    contentRef: import("vue").Ref<PopperContentInstance | undefined, PopperContentInstance | undefined>;
+    /**
+     * @description validate current focus event is trigger inside el-popper-content
+     */
+    isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ElTooltipContentProps> & Readonly<{}>, {
+    offset: number;
+    teleported: boolean;
+    style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    effect: import("@element-plus/components/popper").PopperEffect;
+    content: string;
+    visible: boolean | null;
+    enterable: boolean;
+    pure: boolean;
+    focusOnShow: boolean;
+    trapping: boolean;
+    popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    stopPopperMouseEvent: boolean;
+    virtualTriggering: boolean;
+    loop: boolean;
+    boundariesPadding: number;
+    gpuAcceleration: boolean;
+    placement: import("element-plus").Placement;
+    popperOptions: Partial<import("element-plus").Options>;
+    strategy: "fixed" | "absolute";
+    arrowOffset: number;
+    showAfter: number;
+    hideAfter: number;
+    autoClose: number;
+}, {}, {}, {}, 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/tooltip/src/content.vue.js

@@ -0,0 +1,188 @@
+import { defineComponent as Y, ref as E, inject as q, computed as l, onBeforeUnmount as G, unref as o, watch as H, openBlock as h, createBlock as B, Teleport as Q, Transition as X, withCtx as S, withDirectives as Z, createVNode as _, mergeProps as ee, renderSlot as te, vShow as oe, createCommentVNode as ne, mergeDefaults as re } from "vue";
+import { onClickOutside as ae } 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 { useNamespace as le } from "../../../hooks/use-namespace/index.js";
+import { castArray as se } from "../../../utils/arrays.js";
+import { focusElement as ie } from "../../../utils/dom/aria.js";
+import { composeEventHandlers as w } from "../../../utils/dom/event.js";
+import "../../../hooks/use-size/index.js";
+import { usePopperContainerId as pe } from "../../../hooks/use-popper-container/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 "../../../hooks/use-empty-values/index.js";
+import "../../popper/index.js";
+import { TOOLTIP_INJECTION_KEY as ce } from "./constants.js";
+import { isTriggerType as O } from "./utils.js";
+import { useTooltipContentPropsDefaults as fe } from "./content.js";
+import { computedEager as ue } from "../../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+import de from "../../popper/src/content2.vue.js";
+const Le = /* @__PURE__ */ Y({
+  name: "ElTooltipContent",
+  inheritAttrs: !1,
+  __name: "content",
+  props: /* @__PURE__ */ re({
+    appendTo: {},
+    content: {},
+    rawContent: { type: Boolean },
+    persistent: { type: Boolean },
+    visible: { type: [Boolean, null] },
+    transition: {},
+    teleported: { type: Boolean },
+    disabled: { type: Boolean },
+    ariaLabel: {},
+    showAfter: {},
+    hideAfter: {},
+    autoClose: {},
+    id: {},
+    style: { type: [Boolean, null, String, Object, Array] },
+    className: {},
+    effect: {},
+    enterable: { type: Boolean },
+    pure: { type: Boolean },
+    focusOnShow: { type: Boolean },
+    trapping: { type: Boolean },
+    popperClass: {},
+    popperStyle: { type: [Boolean, null, String, Object, Array] },
+    referenceEl: {},
+    triggerTargetEl: {},
+    stopPopperMouseEvent: { type: Boolean },
+    virtualTriggering: { type: Boolean },
+    zIndex: {},
+    loop: { type: Boolean },
+    boundariesPadding: {},
+    fallbackPlacements: {},
+    gpuAcceleration: { type: Boolean },
+    offset: {},
+    placement: {},
+    popperOptions: {},
+    strategy: {},
+    arrowOffset: {}
+  }, fe),
+  setup(e, { expose: A }) {
+    const r = e, { selector: P } = pe(), I = le("tooltip"), s = E(), N = ue(() => {
+      var t;
+      return (t = s.value) == null ? void 0 : t.popperContentRef;
+    });
+    let a;
+    const {
+      controlled: g,
+      id: k,
+      open: f,
+      trigger: u,
+      onClose: i,
+      onOpen: R,
+      onShow: L,
+      onHide: x,
+      onBeforeShow: d,
+      onBeforeHide: m
+    } = q(ce, void 0), M = l(() => r.transition || `${I.namespace.value}-fade-in-linear`), v = l(() => process.env.NODE_ENV === "test" && !process.env.RUN_TEST_WITH_PERSISTENT ? !0 : r.persistent);
+    G(() => {
+      a == null || a();
+    });
+    const z = l(() => o(v) ? !0 : o(f)), y = l(() => r.disabled ? !1 : o(f)), D = l(() => r.appendTo || P.value), $ = l(() => r.style ?? {}), p = E(!0), j = () => {
+      x(), C() && ie(document.body, { preventScroll: !0 }), p.value = !0;
+    }, b = () => {
+      if (o(g)) return !0;
+    }, V = w(b, () => {
+      r.enterable && O(o(u), "hover") && R();
+    }), U = w(b, () => {
+      O(o(u), "hover") && i();
+    }), W = () => {
+      var t, n;
+      (n = (t = s.value) == null ? void 0 : t.updatePopper) == null || n.call(t), d == null || d();
+    }, F = () => {
+      m == null || m();
+    }, J = () => {
+      L();
+    }, K = () => {
+      r.virtualTriggering || i();
+    }, C = (t) => {
+      var T;
+      const n = (T = s.value) == null ? void 0 : T.popperContentRef, c = (t == null ? void 0 : t.relatedTarget) || document.activeElement;
+      return n == null ? void 0 : n.contains(c);
+    };
+    return H(
+      () => o(f),
+      (t) => {
+        t ? (p.value = !1, a = ae(
+          N,
+          () => {
+            if (o(g)) return;
+            se(o(u)).every((c) => c !== "hover" && c !== "focus") && i();
+          },
+          { detectIframe: !0 }
+        )) : a == null || a();
+      },
+      {
+        flush: "post"
+      }
+    ), A({
+      /**
+       * @description el-popper-content component instance
+       */
+      contentRef: s,
+      /**
+       * @description validate current focus event is trigger inside el-popper-content
+       */
+      isFocusInsideContent: C
+    }), (t, n) => (h(), B(Q, {
+      disabled: !e.teleported,
+      to: D.value
+    }, [
+      z.value || !p.value ? (h(), B(X, {
+        key: 0,
+        name: M.value,
+        appear: !v.value,
+        onAfterLeave: j,
+        onBeforeEnter: W,
+        onAfterEnter: J,
+        onBeforeLeave: F
+      }, {
+        default: S(() => [
+          Z(_(o(de), ee({
+            id: o(k),
+            ref_key: "contentRef",
+            ref: s
+          }, t.$attrs, {
+            "aria-label": e.ariaLabel,
+            "aria-hidden": p.value,
+            "boundaries-padding": e.boundariesPadding,
+            "fallback-placements": e.fallbackPlacements,
+            "gpu-acceleration": e.gpuAcceleration,
+            offset: e.offset,
+            placement: e.placement,
+            "popper-options": e.popperOptions,
+            "arrow-offset": e.arrowOffset,
+            strategy: e.strategy,
+            effect: e.effect,
+            enterable: e.enterable,
+            pure: e.pure,
+            "popper-class": e.popperClass,
+            "popper-style": [e.popperStyle, $.value],
+            "reference-el": e.referenceEl,
+            "trigger-target-el": e.triggerTargetEl,
+            visible: y.value,
+            "z-index": e.zIndex,
+            loop: e.loop,
+            onMouseenter: o(V),
+            onMouseleave: o(U),
+            onBlur: K,
+            onClose: o(i)
+          }), {
+            default: S(() => [
+              te(t.$slots, "default")
+            ]),
+            _: 3
+          }, 16, ["id", "aria-label", "aria-hidden", "boundaries-padding", "fallback-placements", "gpu-acceleration", "offset", "placement", "popper-options", "arrow-offset", "strategy", "effect", "enterable", "pure", "popper-class", "popper-style", "reference-el", "trigger-target-el", "visible", "z-index", "loop", "onMouseenter", "onMouseleave", "onClose"]), [
+            [oe, y.value]
+          ])
+        ]),
+        _: 3
+      }, 8, ["name", "appear"])) : ne("", !0)
+    ], 8, ["disabled", "to"]));
+  }
+});
+export {
+  Le as default
+};

package/dist/components/tooltip/src/content2.vue.js

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