ep-craft 0.1.19 → 0.1.21

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

@@ -0,0 +1,151 @@
+import { defineComponent as z, inject as J, provide as P, onMounted as U, watch as u, unref as e, onBeforeUnmount as V, openBlock as Y, createElementBlock as Z, mergeProps as G, createVNode as H, withCtx as Q, renderSlot as X, mergeDefaults as h } from "vue";
+import { isElement as R } from "../../../utils/types.js";
+import { NOOP as E } from "../../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { EpFocusTrap as W } from "../../focus-trap/index.js";
+import "../../form/index.js";
+import { POPPER_CONTENT_INJECTION_KEY as ee } from "./constants.js";
+import { popperContentEmits as oe, popperContentPropsDefaults as te } from "./content.js";
+import { usePopperContent as re } from "./composables/use-content.js";
+import { usePopperContentDOM as ne } from "./composables/use-content-dom.js";
+import { usePopperContentFocusTrap as pe } from "./composables/use-focus-trap.js";
+import { formItemContextKey as C } from "../../form/src/constants.js";
+import ae from "../../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isNil.js";
+const Re = /* @__PURE__ */ z({
+  name: "ElPopperContent",
+  __name: "content",
+  props: /* @__PURE__ */ h({
+    id: {},
+    style: { type: [Boolean, null, String, Object, Array] },
+    className: {},
+    effect: {},
+    visible: { type: Boolean },
+    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: {},
+    ariaLabel: {},
+    loop: { type: Boolean },
+    boundariesPadding: {},
+    fallbackPlacements: {},
+    gpuAcceleration: { type: Boolean },
+    offset: {},
+    placement: {},
+    popperOptions: {},
+    strategy: {},
+    arrowOffset: {}
+  }, te),
+  emits: oe,
+  setup(f, { expose: B, emit: F }) {
+    const I = F, o = f, {
+      focusStartRef: O,
+      trapped: l,
+      onFocusAfterReleased: A,
+      onFocusAfterTrapped: g,
+      onFocusInTrap: T,
+      onFocusoutPrevented: N,
+      onReleaseRequested: w
+    } = pe(o, I), { attributes: M, arrowRef: S, contentRef: p, styles: x, instanceRef: j, role: m, update: k } = re(o), {
+      ariaModal: q,
+      arrowStyle: D,
+      contentAttrs: $,
+      contentClass: K,
+      contentStyle: d,
+      updateZIndex: L
+    } = ne(o, {
+      styles: x,
+      attributes: M,
+      role: m
+    }), c = J(C, void 0);
+    P(ee, {
+      arrowStyle: D,
+      arrowRef: S
+    }), c && P(C, {
+      ...c,
+      addInputId: E,
+      removeInputId: E
+    });
+    let t;
+    const v = (n = !0) => {
+      k(), n && L();
+    }, _ = () => {
+      v(!1), o.visible && o.focusOnShow ? l.value = !0 : o.visible === !1 && (l.value = !1);
+    };
+    return U(() => {
+      u(
+        () => o.triggerTargetEl,
+        (n, a) => {
+          t == null || t(), t = void 0;
+          const r = e(n || p.value), i = e(a || p.value);
+          R(r) && (t = u(
+            [m, () => o.ariaLabel, q, () => o.id],
+            (s) => {
+              ["role", "aria-label", "aria-modal", "id"].forEach((y, b) => {
+                ae(s[b]) ? r.removeAttribute(y) : r.setAttribute(y, s[b]);
+              });
+            },
+            { immediate: !0 }
+          )), i !== r && R(i) && ["role", "aria-label", "aria-modal", "id"].forEach((s) => {
+            i.removeAttribute(s);
+          });
+        },
+        { immediate: !0 }
+      ), u(() => o.visible, _, { immediate: !0 });
+    }), V(() => {
+      t == null || t(), t = void 0, p.value = void 0;
+    }), B({
+      /**
+       * @description popper content element
+       */
+      popperContentRef: p,
+      /**
+       * @description popperjs instance
+       */
+      popperInstanceRef: j,
+      /**
+       * @description method for updating popper
+       */
+      updatePopper: v,
+      /**
+       * @description content style
+       */
+      contentStyle: d
+    }), (n, a) => (Y(), Z("div", G({
+      ref_key: "contentRef",
+      ref: p
+    }, e($), {
+      style: e(d),
+      class: e(K),
+      tabindex: "-1",
+      onMouseenter: a[0] || (a[0] = (r) => n.$emit("mouseenter", r)),
+      onMouseleave: a[1] || (a[1] = (r) => n.$emit("mouseleave", r))
+    }), [
+      H(e(W), {
+        loop: f.loop,
+        trapped: e(l),
+        "trap-on-focus-in": !0,
+        "focus-trap-el": e(p),
+        "focus-start-el": e(O),
+        onFocusAfterTrapped: e(g),
+        onFocusAfterReleased: e(A),
+        onFocusin: e(T),
+        onFocusoutPrevented: e(N),
+        onReleaseRequested: e(w)
+      }, {
+        default: Q(() => [
+          X(n.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["loop", "trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusin", "onFocusoutPrevented", "onReleaseRequested"])
+    ], 16));
+  }
+});
+export {
+  Re as default
+};

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

@@ -0,0 +1,35 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type Popper from './popper.vue';
+declare const effects: readonly ["light", "dark"];
+declare const triggers: readonly ["click", "contextmenu", "hover", "focus"];
+export declare const Effect: {
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+};
+export declare const roleTypes: readonly ["dialog", "grid", "group", "listbox", "menu", "navigation", "tooltip", "tree"];
+export type PopperEffect = (typeof effects)[number] | (string & NonNullable<unknown>);
+export type PopperTrigger = (typeof triggers)[number];
+export interface PopperProps {
+    /**
+     * @description role determines how aria attributes are distributed
+     */
+    role?: (typeof roleTypes)[number];
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperProps` instead.
+ */
+export declare const popperProps: {
+    readonly role: import("@element-plus/utils").EpPropFinalized<StringConstructor, "dialog" | "menu" | "listbox" | "grid" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperProps` instead.
+ */
+export type PopperPropsPublic = ExtractPublicPropTypes<typeof popperProps>;
+export type PopperInstance = InstanceType<typeof Popper> & unknown;
+/** @deprecated use `popperProps` instead, and it will be deprecated in the next major version */
+export declare const usePopperProps: {
+    readonly role: import("@element-plus/utils").EpPropFinalized<StringConstructor, "dialog" | "menu" | "listbox" | "grid" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
+};
+/** @deprecated use `PopperProps` instead, and it will be deprecated in the next major version */
+export type UsePopperProps = PopperProps;
+export {};

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

@@ -0,0 +1,22 @@
+import { buildProps as o } from "../../../utils/vue/props/runtime.js";
+import "vue";
+const t = [
+  "dialog",
+  "grid",
+  "group",
+  "listbox",
+  "menu",
+  "navigation",
+  "tooltip",
+  "tree"
+], e = o({
+  role: {
+    type: String,
+    values: t,
+    default: "tooltip"
+  }
+});
+export {
+  e as popperProps,
+  t as roleTypes
+};

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

@@ -0,0 +1,22 @@
+import type { Instance as PopperInstance } from '@popperjs/core';
+import type { PopperProps } from './popper';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<PopperProps, {
+    triggerRef: import("vue").Ref<import("./constants").Measurable | undefined>;
+    contentRef: import("vue").Ref<HTMLElement | undefined>;
+    popperInstanceRef: import("vue").Ref<PopperInstance | undefined>;
+    referenceRef: import("vue").Ref<import("./constants").Measurable | undefined>;
+    role: import("vue").ComputedRef<string>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PopperProps> & Readonly<{}>, {
+    role: typeof import("./popper").roleTypes[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/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;