init

node_modules/element-plus/es/components/dropdown/index.d.ts

@@ -0,0 +1,14 @@
+import Dropdown from './src/dropdown.vue';
+import DropdownItem from './src/dropdown-item.vue';
+import DropdownMenu from './src/dropdown-menu.vue';
+import type { SFCWithInstall } from 'element-plus/es/utils';
+export declare const ElDropdown: SFCWithInstall<typeof Dropdown> & {
+    DropdownItem: typeof DropdownItem;
+    DropdownMenu: typeof DropdownMenu;
+};
+export default ElDropdown;
+export declare const ElDropdownItem: SFCWithInstall<typeof DropdownItem>;
+export declare const ElDropdownMenu: SFCWithInstall<typeof DropdownMenu>;
+export * from './src/dropdown';
+export * from './src/instance';
+export * from './src/tokens';

node_modules/element-plus/es/components/dropdown/index.mjs

@@ -0,0 +1,16 @@
+import Dropdown from './src/dropdown2.mjs';
+import DropdownItem from './src/dropdown-item.mjs';
+import DropdownMenu from './src/dropdown-menu.mjs';
+export { DROPDOWN_COLLECTION_INJECTION_KEY, DROPDOWN_COLLECTION_ITEM_INJECTION_KEY, ElCollection, ElCollectionItem, FIRST_KEYS, FIRST_LAST_KEYS, LAST_KEYS, dropdownItemProps, dropdownMenuProps, dropdownProps } from './src/dropdown.mjs';
+export { DROPDOWN_INJECTION_KEY, DROPDOWN_INSTANCE_INJECTION_KEY } from './src/tokens.mjs';
+import { withInstall, withNoopInstall } from '../../utils/vue/install.mjs';
+
+const ElDropdown = withInstall(Dropdown, {
+  DropdownItem,
+  DropdownMenu
+});
+const ElDropdownItem = withNoopInstall(DropdownItem);
+const ElDropdownMenu = withNoopInstall(DropdownMenu);
+
+export { ElDropdown, ElDropdownItem, ElDropdownMenu, ElDropdown as default };
+//# sourceMappingURL=index.mjs.map

node_modules/element-plus/es/components/dropdown/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../../packages/components/dropdown/index.ts"],"sourcesContent":["import { withInstall, withNoopInstall } from '@element-plus/utils'\nimport Dropdown from './src/dropdown.vue'\nimport DropdownItem from './src/dropdown-item.vue'\nimport DropdownMenu from './src/dropdown-menu.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElDropdown: SFCWithInstall<typeof Dropdown> & {\n  DropdownItem: typeof DropdownItem\n  DropdownMenu: typeof DropdownMenu\n} = withInstall(Dropdown, {\n  DropdownItem,\n  DropdownMenu,\n})\nexport default ElDropdown\nexport const ElDropdownItem: SFCWithInstall<typeof DropdownItem> =\n  withNoopInstall(DropdownItem)\nexport const ElDropdownMenu: SFCWithInstall<typeof DropdownMenu> =\n  withNoopInstall(DropdownMenu)\nexport * from './src/dropdown'\nexport * from './src/instance'\nexport * from './src/tokens'\n"],"names":[],"mappings":";;;;;;;AAIY,MAAC,UAAU,GAAG,WAAW,CAAC,QAAQ,EAAE;AAChD,EAAE,YAAY;AACd,EAAE,YAAY;AACd,CAAC,EAAE;AAES,MAAC,cAAc,GAAG,eAAe,CAAC,YAAY,EAAE;AAChD,MAAC,cAAc,GAAG,eAAe,CAAC,YAAY;;;;"}

node_modules/element-plus/es/components/dropdown/src/dropdown-item-impl.mjs

@@ -0,0 +1,97 @@
+import { defineComponent, inject, computed, resolveComponent, openBlock, createElementBlock, Fragment, normalizeClass, createCommentVNode, createElementVNode, mergeProps, withModifiers, createBlock, withCtx, resolveDynamicComponent, renderSlot } from 'vue';
+import { ElIcon } from '../../icon/index.mjs';
+import { dropdownItemProps, DROPDOWN_COLLECTION_ITEM_INJECTION_KEY as COLLECTION_ITEM_INJECTION_KEY } from './dropdown.mjs';
+import { DROPDOWN_INJECTION_KEY } from './tokens.mjs';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
+import { ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY as COLLECTION_ITEM_INJECTION_KEY$1 } from '../../roving-focus-group/src/roving-focus-group.mjs';
+import { ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY } from '../../roving-focus-group/src/tokens.mjs';
+import { COLLECTION_ITEM_SIGN } from '../../collection/src/collection.mjs';
+import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
+import { composeRefs } from '../../../utils/vue/refs.mjs';
+import { composeEventHandlers } from '../../../utils/dom/event.mjs';
+import { EVENT_CODE } from '../../../constants/aria.mjs';
+
+const _sfc_main = defineComponent({
+  name: "DropdownItemImpl",
+  components: {
+    ElIcon
+  },
+  props: dropdownItemProps,
+  emits: ["pointermove", "pointerleave", "click", "clickimpl"],
+  setup(_, { emit }) {
+    const ns = useNamespace("dropdown");
+    const { role: menuRole } = inject(DROPDOWN_INJECTION_KEY, void 0);
+    const { collectionItemRef: dropdownCollectionItemRef } = inject(COLLECTION_ITEM_INJECTION_KEY, void 0);
+    const { collectionItemRef: rovingFocusCollectionItemRef } = inject(COLLECTION_ITEM_INJECTION_KEY$1, void 0);
+    const {
+      rovingFocusGroupItemRef,
+      tabIndex,
+      handleFocus,
+      handleKeydown: handleItemKeydown,
+      handleMousedown
+    } = inject(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, void 0);
+    const itemRef = composeRefs(dropdownCollectionItemRef, rovingFocusCollectionItemRef, rovingFocusGroupItemRef);
+    const role = computed(() => {
+      if (menuRole.value === "menu") {
+        return "menuitem";
+      } else if (menuRole.value === "navigation") {
+        return "link";
+      }
+      return "button";
+    });
+    const handleKeydown = composeEventHandlers((e) => {
+      if ([EVENT_CODE.enter, EVENT_CODE.numpadEnter, EVENT_CODE.space].includes(e.code)) {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+        emit("clickimpl", e);
+        return true;
+      }
+    }, handleItemKeydown);
+    return {
+      ns,
+      itemRef,
+      dataset: {
+        [COLLECTION_ITEM_SIGN]: ""
+      },
+      role,
+      tabIndex,
+      handleFocus,
+      handleKeydown,
+      handleMousedown
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_icon = resolveComponent("el-icon");
+  return openBlock(), createElementBlock(Fragment, null, [
+    _ctx.divided ? (openBlock(), createElementBlock("li", {
+      key: 0,
+      role: "separator",
+      class: normalizeClass(_ctx.ns.bem("menu", "item", "divided"))
+    }, null, 2)) : createCommentVNode("v-if", true),
+    createElementVNode("li", mergeProps({ ref: _ctx.itemRef }, { ..._ctx.dataset, ..._ctx.$attrs }, {
+      "aria-disabled": _ctx.disabled,
+      class: [_ctx.ns.be("menu", "item"), _ctx.ns.is("disabled", _ctx.disabled)],
+      tabindex: _ctx.tabIndex,
+      role: _ctx.role,
+      onClick: (e) => _ctx.$emit("clickimpl", e),
+      onFocus: _ctx.handleFocus,
+      onKeydown: withModifiers(_ctx.handleKeydown, ["self"]),
+      onMousedown: _ctx.handleMousedown,
+      onPointermove: (e) => _ctx.$emit("pointermove", e),
+      onPointerleave: (e) => _ctx.$emit("pointerleave", e)
+    }), [
+      _ctx.icon ? (openBlock(), createBlock(_component_el_icon, { key: 0 }, {
+        default: withCtx(() => [
+          (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
+        ]),
+        _: 1
+      })) : createCommentVNode("v-if", true),
+      renderSlot(_ctx.$slots, "default")
+    ], 16, ["aria-disabled", "tabindex", "role", "onClick", "onFocus", "onKeydown", "onMousedown", "onPointermove", "onPointerleave"])
+  ], 64);
+}
+var ElDropdownItemImpl = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "dropdown-item-impl.vue"]]);
+
+export { ElDropdownItemImpl as default };
+//# sourceMappingURL=dropdown-item-impl.mjs.map

node_modules/element-plus/es/components/dropdown/src/dropdown-item-impl.vue.d.ts

@@ -0,0 +1,61 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly command: import("element-plus/es/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    itemRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+    dataset: {
+        "data-el-collection-item": string;
+    };
+    role: import("vue").ComputedRef<string>;
+    tabIndex: import("vue").Ref<number>;
+    handleFocus: (e: Event) => void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    handleMousedown: (e: Event) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove" | "clickimpl")[], "click" | "pointerleave" | "pointermove" | "clickimpl", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly command: import("element-plus/es/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & {
+    onClick?: ((...args: any[]) => any) | undefined;
+    onPointermove?: ((...args: any[]) => any) | undefined;
+    onPointerleave?: ((...args: any[]) => any) | undefined;
+    onClickimpl?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly disabled: boolean;
+    readonly command: import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+    readonly divided: boolean;
+}>;
+export default _default;

node_modules/element-plus/es/components/dropdown/src/dropdown-item.mjs

@@ -0,0 +1,113 @@
+import { defineComponent, getCurrentInstance, ref, computed, unref, inject, resolveComponent, openBlock, createBlock, withCtx, createVNode, mergeProps, renderSlot } from 'vue';
+import ElRovingFocusItem from '../../roving-focus-group/src/roving-focus-item.mjs';
+import ElDropdownItemImpl from './dropdown-item-impl.mjs';
+import { useDropdown } from './useDropdown.mjs';
+import { ElCollectionItem, dropdownItemProps } from './dropdown.mjs';
+import { DROPDOWN_INJECTION_KEY } from './tokens.mjs';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
+import { composeEventHandlers, whenMouse } from '../../../utils/dom/event.mjs';
+
+const _sfc_main = defineComponent({
+  name: "ElDropdownItem",
+  components: {
+    ElDropdownCollectionItem: ElCollectionItem,
+    ElRovingFocusItem,
+    ElDropdownItemImpl
+  },
+  inheritAttrs: false,
+  props: dropdownItemProps,
+  emits: ["pointermove", "pointerleave", "click"],
+  setup(props, { emit, attrs }) {
+    const { elDropdown } = useDropdown();
+    const _instance = getCurrentInstance();
+    const itemRef = ref(null);
+    const textContent = computed(() => {
+      var _a, _b;
+      return (_b = (_a = unref(itemRef)) == null ? void 0 : _a.textContent) != null ? _b : "";
+    });
+    const { onItemEnter, onItemLeave } = inject(DROPDOWN_INJECTION_KEY, void 0);
+    const handlePointerMove = composeEventHandlers((e) => {
+      emit("pointermove", e);
+      return e.defaultPrevented;
+    }, whenMouse((e) => {
+      if (props.disabled) {
+        onItemLeave(e);
+        return;
+      }
+      const target = e.currentTarget;
+      if (target === document.activeElement || target.contains(document.activeElement)) {
+        return;
+      }
+      onItemEnter(e);
+      if (!e.defaultPrevented) {
+        target == null ? void 0 : target.focus({
+          preventScroll: true
+        });
+      }
+    }));
+    const handlePointerLeave = composeEventHandlers((e) => {
+      emit("pointerleave", e);
+      return e.defaultPrevented;
+    }, whenMouse(onItemLeave));
+    const handleClick = composeEventHandlers((e) => {
+      if (props.disabled) {
+        return;
+      }
+      emit("click", e);
+      return e.type !== "keydown" && e.defaultPrevented;
+    }, (e) => {
+      var _a, _b, _c;
+      if (props.disabled) {
+        e.stopImmediatePropagation();
+        return;
+      }
+      if ((_a = elDropdown == null ? void 0 : elDropdown.hideOnClick) == null ? void 0 : _a.value) {
+        (_b = elDropdown.handleClick) == null ? void 0 : _b.call(elDropdown);
+      }
+      (_c = elDropdown.commandHandler) == null ? void 0 : _c.call(elDropdown, props.command, _instance, e);
+    });
+    const propsAndAttrs = computed(() => ({ ...props, ...attrs }));
+    return {
+      handleClick,
+      handlePointerMove,
+      handlePointerLeave,
+      textContent,
+      propsAndAttrs
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  var _a;
+  const _component_el_dropdown_item_impl = resolveComponent("el-dropdown-item-impl");
+  const _component_el_roving_focus_item = resolveComponent("el-roving-focus-item");
+  const _component_el_dropdown_collection_item = resolveComponent("el-dropdown-collection-item");
+  return openBlock(), createBlock(_component_el_dropdown_collection_item, {
+    disabled: _ctx.disabled,
+    "text-value": (_a = _ctx.textValue) != null ? _a : _ctx.textContent
+  }, {
+    default: withCtx(() => [
+      createVNode(_component_el_roving_focus_item, {
+        focusable: !_ctx.disabled
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_el_dropdown_item_impl, mergeProps(_ctx.propsAndAttrs, {
+            onPointerleave: _ctx.handlePointerLeave,
+            onPointermove: _ctx.handlePointerMove,
+            onClickimpl: _ctx.handleClick
+          }), {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 16, ["onPointerleave", "onPointermove", "onClickimpl"])
+        ]),
+        _: 3
+      }, 8, ["focusable"])
+    ]),
+    _: 3
+  }, 8, ["disabled", "text-value"]);
+}
+var DropdownItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "dropdown-item.vue"]]);
+
+export { DropdownItem as default };
+//# sourceMappingURL=dropdown-item.mjs.map

node_modules/element-plus/es/components/dropdown/src/dropdown-item.vue.d.ts

@@ -0,0 +1,47 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly command: import("element-plus/es/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {
+    handleClick: (event: PointerEvent) => void;
+    handlePointerMove: (event: PointerEvent) => void;
+    handlePointerLeave: (event: PointerEvent) => void;
+    textContent: import("vue").ComputedRef<string>;
+    propsAndAttrs: import("vue").ComputedRef<{
+        disabled: boolean;
+        icon: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown> | undefined;
+        onClick: ((...args: any[]) => any) | undefined;
+        onPointermove: ((...args: any[]) => any) | undefined;
+        onPointerleave: ((...args: any[]) => any) | undefined;
+        command: import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        divided: boolean;
+        textValue: string | undefined;
+    }>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], "click" | "pointerleave" | "pointermove", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly command: import("element-plus/es/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & {
+    onClick?: ((...args: any[]) => any) | undefined;
+    onPointermove?: ((...args: any[]) => any) | undefined;
+    onPointerleave?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly disabled: boolean;
+    readonly command: import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+    readonly divided: boolean;
+}>;
+export default _default;

node_modules/element-plus/es/components/dropdown/src/dropdown-menu.mjs

@@ -0,0 +1,95 @@
+import { defineComponent, inject, computed, openBlock, createElementBlock, normalizeClass, normalizeStyle, withModifiers, renderSlot, unref } from 'vue';
+import { DROPDOWN_INJECTION_KEY } from './tokens.mjs';
+import { dropdownMenuProps, DROPDOWN_COLLECTION_INJECTION_KEY as COLLECTION_INJECTION_KEY, FIRST_LAST_KEYS, LAST_KEYS } from './dropdown.mjs';
+import { useDropdown } from './useDropdown.mjs';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
+import { ROVING_FOCUS_GROUP_INJECTION_KEY } from '../../roving-focus-group/src/tokens.mjs';
+import { ROVING_FOCUS_COLLECTION_INJECTION_KEY as COLLECTION_INJECTION_KEY$1 } from '../../roving-focus-group/src/roving-focus-group.mjs';
+import { focusFirst } from '../../roving-focus-group/src/utils.mjs';
+import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
+import { FOCUS_TRAP_INJECTION_KEY } from '../../focus-trap/src/tokens.mjs';
+import { composeRefs } from '../../../utils/vue/refs.mjs';
+import { composeEventHandlers } from '../../../utils/dom/event.mjs';
+import { EVENT_CODE } from '../../../constants/aria.mjs';
+
+const _sfc_main = defineComponent({
+  name: "ElDropdownMenu",
+  props: dropdownMenuProps,
+  setup(props) {
+    const ns = useNamespace("dropdown");
+    const { _elDropdownSize } = useDropdown();
+    const size = _elDropdownSize.value;
+    const { focusTrapRef, onKeydown } = inject(FOCUS_TRAP_INJECTION_KEY, void 0);
+    const { contentRef, role, triggerId } = inject(DROPDOWN_INJECTION_KEY, void 0);
+    const { collectionRef: dropdownCollectionRef, getItems } = inject(COLLECTION_INJECTION_KEY, void 0);
+    const {
+      rovingFocusGroupRef,
+      rovingFocusGroupRootStyle,
+      tabIndex,
+      onBlur,
+      onFocus,
+      onMousedown
+    } = inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
+    const { collectionRef: rovingFocusGroupCollectionRef } = inject(COLLECTION_INJECTION_KEY$1, void 0);
+    const dropdownKls = computed(() => {
+      return [ns.b("menu"), ns.bm("menu", size == null ? void 0 : size.value)];
+    });
+    const dropdownListWrapperRef = composeRefs(contentRef, dropdownCollectionRef, focusTrapRef, rovingFocusGroupRef, rovingFocusGroupCollectionRef);
+    const composedKeydown = composeEventHandlers((e) => {
+      var _a;
+      (_a = props.onKeydown) == null ? void 0 : _a.call(props, e);
+    }, (e) => {
+      const { currentTarget, code, target } = e;
+      currentTarget.contains(target);
+      if (EVENT_CODE.tab === code) {
+        e.stopImmediatePropagation();
+      }
+      e.preventDefault();
+      if (target !== unref(contentRef) || !FIRST_LAST_KEYS.includes(code))
+        return;
+      const items = getItems().filter((item) => !item.disabled);
+      const targets = items.map((item) => item.ref);
+      if (LAST_KEYS.includes(code)) {
+        targets.reverse();
+      }
+      focusFirst(targets);
+    });
+    const handleKeydown = (e) => {
+      composedKeydown(e);
+      onKeydown(e);
+    };
+    return {
+      size,
+      rovingFocusGroupRootStyle,
+      tabIndex,
+      dropdownKls,
+      role,
+      triggerId,
+      dropdownListWrapperRef,
+      handleKeydown,
+      onBlur,
+      onFocus,
+      onMousedown
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("ul", {
+    ref: _ctx.dropdownListWrapperRef,
+    class: normalizeClass(_ctx.dropdownKls),
+    style: normalizeStyle(_ctx.rovingFocusGroupRootStyle),
+    tabindex: -1,
+    role: _ctx.role,
+    "aria-labelledby": _ctx.triggerId,
+    onBlur: _ctx.onBlur,
+    onFocus: _ctx.onFocus,
+    onKeydown: withModifiers(_ctx.handleKeydown, ["self"]),
+    onMousedown: withModifiers(_ctx.onMousedown, ["self"])
+  }, [
+    renderSlot(_ctx.$slots, "default")
+  ], 46, ["role", "aria-labelledby", "onBlur", "onFocus", "onKeydown", "onMousedown"]);
+}
+var DropdownMenu = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "dropdown-menu.vue"]]);
+
+export { DropdownMenu as default };
+//# sourceMappingURL=dropdown-menu.mjs.map

node_modules/element-plus/es/components/dropdown/src/dropdown-menu.vue.d.ts

@@ -0,0 +1,28 @@
+declare const _default: import("vue").DefineComponent<{
+    onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {
+    size: import("vue").ComputedRef<string> | undefined;
+    rovingFocusGroupRootStyle: import("vue").Ref<import("vue").StyleValue>;
+    tabIndex: import("vue").Ref<number>;
+    dropdownKls: import("vue").ComputedRef<string[]>;
+    role: import("vue").ComputedRef<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>>;
+    triggerId: import("vue").ComputedRef<string>;
+    dropdownListWrapperRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+    handleKeydown: (e: KeyboardEvent) => void;
+    onBlur: (e: Event) => void;
+    onFocus: (e: FocusEvent) => void;
+    onMousedown: (e: Event) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {}>;
+export default _default;

node_modules/element-plus/es/components/dropdown/src/dropdown.d.ts

@@ -0,0 +1,274 @@
+import type { Placement } from 'element-plus/es/components/popper';
+import type { Options } from '@popperjs/core';
+import type { ButtonProps } from 'element-plus/es/components/button';
+import type { ComponentInternalInstance, ComputedRef } from 'vue';
+import type { Nullable } from 'element-plus/es/utils';
+export interface IElDropdownInstance {
+    instance?: ComponentInternalInstance;
+    dropdownSize?: ComputedRef<string>;
+    handleClick?: () => void;
+    commandHandler?: (...arg: any[]) => void;
+    show?: () => void;
+    hide?: () => void;
+    trigger?: ComputedRef<string>;
+    hideOnClick?: ComputedRef<boolean>;
+    triggerElm?: ComputedRef<Nullable<HTMLButtonElement>>;
+}
+export declare const dropdownProps: {
+    readonly trigger: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("element-plus/es/components/tooltip").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus/es/components/tooltip").TooltipTriggerType>) | ((new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("element-plus/es/components/tooltip").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus/es/components/tooltip").TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
+    readonly triggerKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => string[], boolean>;
+    readonly virtualTriggering: BooleanConstructor;
+    readonly virtualRef: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/popper").Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly effect: {
+        readonly default: "light";
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("element-plus/es/components/popper").PopperEffect) | ((new (...args: any[]) => string) | (() => import("element-plus/es/components/popper").PopperEffect))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger", unknown>) | ((new (...args: any[]) => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger", unknown>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | ((new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement))[], unknown, unknown, "bottom", boolean>;
+    readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | ((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>))[], unknown, unknown, () => {}, boolean>;
+    readonly id: StringConstructor;
+    readonly size: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly splitButton: BooleanConstructor;
+    readonly hideOnClick: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly loop: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showArrow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showTimeout: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+    readonly hideTimeout: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+    readonly tabindex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, 0, boolean>;
+    readonly maxHeight: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, "", boolean>;
+    readonly popperClass: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly role: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "menu", boolean>;
+    readonly buttonProps: {
+        readonly type: import("vue").PropType<Partial<ButtonProps>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly teleported: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly persistent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+};
+export declare const dropdownItemProps: {
+    readonly command: import("element-plus/es/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export declare const dropdownMenuProps: {
+    onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export declare const FIRST_KEYS: string[];
+export declare const LAST_KEYS: string[];
+export declare const FIRST_LAST_KEYS: string[];
+declare const ElCollection: {
+    name: string;
+    setup(): void;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+    template?: string | object;
+    render?: Function;
+    components?: Record<string, import("vue").Component>;
+    directives?: Record<string, import("vue").Directive>;
+    inheritAttrs?: boolean;
+    emits?: (import("vue").EmitsOptions & ThisType<void>) | undefined;
+    expose?: string[];
+    serverPrefetch?(): Promise<any>;
+    compilerOptions?: import("vue").RuntimeCompilerOptions;
+    call?: (this: unknown, ...args: unknown[]) => never;
+    __defaults?: {} | undefined;
+    compatConfig?: Partial<Record<import("vue").DeprecationTypes, boolean | "suppress-warning">> & {
+        MODE?: 2 | 3 | ((comp: import("vue").Component | null) => 2 | 3);
+    };
+    data?: ((this: import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{}>>, {}, false, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, {}>, vm: import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{}>>, {}, false, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, {}>) => {}) | undefined;
+    computed?: {} | undefined;
+    methods?: {} | undefined;
+    watch?: {
+        [x: string]: (string | import("vue").WatchCallback<any, any> | ({
+            handler: import("vue").WatchCallback | string;
+        } & import("vue").WatchOptions<boolean>)) | (string | import("vue").WatchCallback<any, any> | ({
+            handler: import("vue").WatchCallback | string;
+        } & import("vue").WatchOptions<boolean>))[];
+    };
+    provide?: import("vue").ComponentProvideOptions;
+    inject?: string[] | {
+        [x: string]: string | symbol | {
+            from?: string | symbol;
+            default?: unknown;
+        };
+        [x: symbol]: string | symbol | {
+            from?: string | symbol;
+            default?: unknown;
+        };
+    };
+    filters?: Record<string, Function>;
+    mixins?: import("vue").ComponentOptionsMixin[] | undefined;
+    extends?: import("vue").ComponentOptionsMixin | undefined;
+    beforeCreate?(): void;
+    created?(): void;
+    beforeMount?(): void;
+    mounted?(): void;
+    beforeUpdate?(): void;
+    updated?(): void;
+    activated?(): void;
+    deactivated?(): void;
+    beforeDestroy?(): void;
+    beforeUnmount?(): void;
+    destroyed?(): void;
+    unmounted?(): void;
+    renderTracked?: (e: import("vue").DebuggerEvent) => void;
+    renderTriggered?: (e: import("vue").DebuggerEvent) => void;
+    errorCaptured?: (err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void;
+    delimiters?: [string, string];
+    __differentiator?: undefined;
+    __isBuiltIn?: boolean;
+    __file?: string;
+    __name?: string;
+    beforeRouteEnter?: import("vue-router").NavigationGuardWithThis<undefined>;
+    beforeRouteUpdate?: import("vue-router").NavigationGuard;
+    beforeRouteLeave?: import("vue-router").NavigationGuard;
+    key?: string | number | symbol;
+    ref?: import("vue").VNodeRef;
+    ref_for?: boolean;
+    ref_key?: string;
+    onVnodeBeforeMount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+    onVnodeMounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+    onVnodeBeforeUpdate?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
+    onVnodeUpdated?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
+    onVnodeBeforeUnmount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+    onVnodeUnmounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+    class?: unknown;
+    style?: unknown;
+}, ElCollectionItem: {
+    name: string;
+    setup(_: unknown, { attrs }: import("vue").SetupContext): void;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+    template?: string | object;
+    render?: Function;
+    components?: Record<string, import("vue").Component>;
+    directives?: Record<string, import("vue").Directive>;
+    inheritAttrs?: boolean;
+    emits?: (import("vue").EmitsOptions & ThisType<void>) | undefined;
+    expose?: string[];
+    serverPrefetch?(): Promise<any>;
+    compilerOptions?: import("vue").RuntimeCompilerOptions;
+    call?: (this: unknown, ...args: unknown[]) => never;
+    __defaults?: {} | undefined;
+    compatConfig?: Partial<Record<import("vue").DeprecationTypes, boolean | "suppress-warning">> & {
+        MODE?: 2 | 3 | ((comp: import("vue").Component | null) => 2 | 3);
+    };
+    data?: ((this: import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{}>>, {}, false, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, {}>, vm: import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{}>>, {}, false, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, import("vue").MethodOptions, {}>) => {}) | undefined;
+    computed?: {} | undefined;
+    methods?: {} | undefined;
+    watch?: {
+        [x: string]: (string | import("vue").WatchCallback<any, any> | ({
+            handler: import("vue").WatchCallback | string;
+        } & import("vue").WatchOptions<boolean>)) | (string | import("vue").WatchCallback<any, any> | ({
+            handler: import("vue").WatchCallback | string;
+        } & import("vue").WatchOptions<boolean>))[];
+    };
+    provide?: import("vue").ComponentProvideOptions;
+    inject?: string[] | {
+        [x: string]: string | symbol | {
+            from?: string | symbol;
+            default?: unknown;
+        };
+        [x: symbol]: string | symbol | {
+            from?: string | symbol;
+            default?: unknown;
+        };
+    };
+    filters?: Record<string, Function>;
+    mixins?: import("vue").ComponentOptionsMixin[] | undefined;
+    extends?: import("vue").ComponentOptionsMixin | undefined;
+    beforeCreate?(): void;
+    created?(): void;
+    beforeMount?(): void;
+    mounted?(): void;
+    beforeUpdate?(): void;
+    updated?(): void;
+    activated?(): void;
+    deactivated?(): void;
+    beforeDestroy?(): void;
+    beforeUnmount?(): void;
+    destroyed?(): void;
+    unmounted?(): void;
+    renderTracked?: (e: import("vue").DebuggerEvent) => void;
+    renderTriggered?: (e: import("vue").DebuggerEvent) => void;
+    errorCaptured?: (err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void;
+    delimiters?: [string, string];
+    __differentiator?: undefined;
+    __isBuiltIn?: boolean;
+    __file?: string;
+    __name?: string;
+    beforeRouteEnter?: import("vue-router").NavigationGuardWithThis<undefined>;
+    beforeRouteUpdate?: import("vue-router").NavigationGuard;
+    beforeRouteLeave?: import("vue-router").NavigationGuard;
+    key?: string | number | symbol;
+    ref?: import("vue").VNodeRef;
+    ref_for?: boolean;
+    ref_key?: string;
+    onVnodeBeforeMount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+    onVnodeMounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+    onVnodeBeforeUpdate?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
+    onVnodeUpdated?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
+    onVnodeBeforeUnmount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+    onVnodeUnmounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+    class?: unknown;
+    style?: unknown;
+}, COLLECTION_INJECTION_KEY: import("vue").InjectionKey<import("element-plus/es/components/collection").ElCollectionInjectionContext>, COLLECTION_ITEM_INJECTION_KEY: import("vue").InjectionKey<import("element-plus/es/components/collection").ElCollectionItemInjectionContext>;
+export { ElCollection, ElCollectionItem, COLLECTION_INJECTION_KEY as DROPDOWN_COLLECTION_INJECTION_KEY, COLLECTION_ITEM_INJECTION_KEY as DROPDOWN_COLLECTION_ITEM_INJECTION_KEY, };

node_modules/element-plus/es/components/dropdown/src/dropdown.mjs

@@ -0,0 +1,120 @@
+import { useTooltipTriggerProps } from '../../tooltip/src/trigger.mjs';
+import { roleTypes } from '../../popper/src/popper.mjs';
+import { buildProps, definePropType } from '../../../utils/vue/props/runtime.mjs';
+import { EVENT_CODE } from '../../../constants/aria.mjs';
+import { useTooltipContentProps } from '../../tooltip/src/content.mjs';
+import { iconPropType } from '../../../utils/vue/icon.mjs';
+import { createCollectionWithScope } from '../../collection/src/collection.mjs';
+
+const dropdownProps = buildProps({
+  trigger: useTooltipTriggerProps.trigger,
+  triggerKeys: {
+    type: definePropType(Array),
+    default: () => [
+      EVENT_CODE.enter,
+      EVENT_CODE.numpadEnter,
+      EVENT_CODE.space,
+      EVENT_CODE.down
+    ]
+  },
+  virtualTriggering: useTooltipTriggerProps.virtualTriggering,
+  virtualRef: useTooltipTriggerProps.virtualRef,
+  effect: {
+    ...useTooltipContentProps.effect,
+    default: "light"
+  },
+  type: {
+    type: definePropType(String)
+  },
+  placement: {
+    type: definePropType(String),
+    default: "bottom"
+  },
+  popperOptions: {
+    type: definePropType(Object),
+    default: () => ({})
+  },
+  id: String,
+  size: {
+    type: String,
+    default: ""
+  },
+  splitButton: Boolean,
+  hideOnClick: {
+    type: Boolean,
+    default: true
+  },
+  loop: {
+    type: Boolean,
+    default: true
+  },
+  showArrow: {
+    type: Boolean,
+    default: true
+  },
+  showTimeout: {
+    type: Number,
+    default: 150
+  },
+  hideTimeout: {
+    type: Number,
+    default: 150
+  },
+  tabindex: {
+    type: definePropType([Number, String]),
+    default: 0
+  },
+  maxHeight: {
+    type: definePropType([Number, String]),
+    default: ""
+  },
+  popperClass: {
+    type: String,
+    default: ""
+  },
+  disabled: Boolean,
+  role: {
+    type: String,
+    values: roleTypes,
+    default: "menu"
+  },
+  buttonProps: {
+    type: definePropType(Object)
+  },
+  teleported: useTooltipContentProps.teleported,
+  persistent: {
+    type: Boolean,
+    default: true
+  }
+});
+const dropdownItemProps = buildProps({
+  command: {
+    type: [Object, String, Number],
+    default: () => ({})
+  },
+  disabled: Boolean,
+  divided: Boolean,
+  textValue: String,
+  icon: {
+    type: iconPropType
+  }
+});
+const dropdownMenuProps = buildProps({
+  onKeydown: { type: definePropType(Function) }
+});
+const FIRST_KEYS = [
+  EVENT_CODE.down,
+  EVENT_CODE.pageDown,
+  EVENT_CODE.home
+];
+const LAST_KEYS = [EVENT_CODE.up, EVENT_CODE.pageUp, EVENT_CODE.end];
+const FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];
+const {
+  ElCollection,
+  ElCollectionItem,
+  COLLECTION_INJECTION_KEY,
+  COLLECTION_ITEM_INJECTION_KEY
+} = createCollectionWithScope("Dropdown");
+
+export { COLLECTION_INJECTION_KEY as DROPDOWN_COLLECTION_INJECTION_KEY, COLLECTION_ITEM_INJECTION_KEY as DROPDOWN_COLLECTION_ITEM_INJECTION_KEY, ElCollection, ElCollectionItem, FIRST_KEYS, FIRST_LAST_KEYS, LAST_KEYS, dropdownItemProps, dropdownMenuProps, dropdownProps };
+//# sourceMappingURL=dropdown.mjs.map

node_modules/element-plus/es/components/dropdown/src/dropdown.vue.d.ts

@@ -0,0 +1,160 @@
+import type { TooltipInstance } from 'element-plus/es/components/tooltip';
+import type { CSSProperties } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    readonly trigger: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("element-plus/es/components/tooltip").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus/es/components/tooltip").TooltipTriggerType>) | ((new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("element-plus/es/components/tooltip").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus/es/components/tooltip").TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
+    readonly triggerKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => string[], boolean>;
+    readonly virtualTriggering: BooleanConstructor;
+    readonly virtualRef: {
+        readonly type: import("vue").PropType<import("element-plus").Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly effect: {
+        readonly default: "light";
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | ((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger", unknown>) | ((new (...args: any[]) => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger", unknown>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | ((new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement))[], unknown, unknown, "bottom", boolean>;
+    readonly popperOptions: import("element-plus/es/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>))[], unknown, unknown, () => {}, boolean>;
+    readonly id: StringConstructor;
+    readonly size: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly splitButton: BooleanConstructor;
+    readonly hideOnClick: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly loop: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showArrow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showTimeout: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+    readonly hideTimeout: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+    readonly tabindex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, 0, boolean>;
+    readonly maxHeight: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, "", boolean>;
+    readonly popperClass: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly role: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "menu", boolean>;
+    readonly buttonProps: {
+        readonly type: import("vue").PropType<Partial<import("element-plus/es/components/button").ButtonProps>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly teleported: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly persistent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}, {
+    t: import("element-plus/es/hooks").Translator;
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    scrollbar: import("vue").Ref<null>;
+    wrapStyle: import("vue").ComputedRef<CSSProperties>;
+    dropdownTriggerKls: import("vue").ComputedRef<string[]>;
+    dropdownSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+    triggerId: import("vue").ComputedRef<string>;
+    currentTabId: import("vue").Ref<string | null>;
+    handleCurrentTabIdChange: (id: string) => void;
+    handlerMainButtonClick: (event: MouseEvent) => void;
+    handleEntryFocus: (e: Event) => void;
+    handleClose: () => void;
+    handleOpen: () => void;
+    handleBeforeShowTooltip: () => void;
+    handleShowTooltip: (event?: Event) => void;
+    handleBeforeHideTooltip: () => void;
+    onFocusAfterTrapped: (e: Event) => void;
+    popperRef: import("vue").Ref<TooltipInstance | undefined>;
+    contentRef: import("vue").Ref<HTMLElement | undefined>;
+    triggeringElementRef: import("vue").Ref<any>;
+    referenceElementRef: import("vue").Ref<any>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "visible-change" | "command")[], "click" | "visible-change" | "command", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly trigger: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("element-plus/es/components/tooltip").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus/es/components/tooltip").TooltipTriggerType>) | ((new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("element-plus/es/components/tooltip").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus/es/components/tooltip").TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
+    readonly triggerKeys: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => string[], boolean>;
+    readonly virtualTriggering: BooleanConstructor;
+    readonly virtualRef: {
+        readonly type: import("vue").PropType<import("element-plus").Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly effect: {
+        readonly default: "light";
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | ((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger", unknown>) | ((new (...args: any[]) => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger", unknown>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | ((new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement))[], unknown, unknown, "bottom", boolean>;
+    readonly popperOptions: import("element-plus/es/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>))[], unknown, unknown, () => {}, boolean>;
+    readonly id: StringConstructor;
+    readonly size: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly splitButton: BooleanConstructor;
+    readonly hideOnClick: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly loop: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showArrow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showTimeout: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+    readonly hideTimeout: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+    readonly tabindex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, 0, boolean>;
+    readonly maxHeight: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, "", boolean>;
+    readonly popperClass: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly role: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "menu", boolean>;
+    readonly buttonProps: {
+        readonly type: import("vue").PropType<Partial<import("element-plus/es/components/button").ButtonProps>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly teleported: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly persistent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}>> & {
+    onClick?: ((...args: any[]) => any) | undefined;
+    "onVisible-change"?: ((...args: any[]) => any) | undefined;
+    onCommand?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly disabled: boolean;
+    readonly tabindex: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>;
+    readonly maxHeight: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>;
+    readonly size: string;
+    readonly placement: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | ((new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement))[], unknown, unknown>;
+    readonly effect: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("element-plus").PopperEffect) | ((new (...args: any[]) => string) | (() => import("element-plus").PopperEffect))[], unknown, unknown>;
+    readonly role: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
+    readonly trigger: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("element-plus/es/components/tooltip").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus/es/components/tooltip").TooltipTriggerType>) | ((new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("element-plus/es/components/tooltip").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus/es/components/tooltip").TooltipTriggerType>))[], unknown, unknown>;
+    readonly virtualTriggering: boolean;
+    readonly loop: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly popperOptions: Partial<import("element-plus").Options>;
+    readonly popperClass: string;
+    readonly triggerKeys: string[];
+    readonly teleported: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly persistent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showArrow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly hideOnClick: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showTimeout: number;
+    readonly hideTimeout: number;
+    readonly splitButton: boolean;
+}>;
+export default _default;

node_modules/element-plus/es/components/dropdown/src/dropdown2.mjs

@@ -0,0 +1,288 @@
+import { defineComponent, getCurrentInstance, ref, computed, provide, toRef, unref, resolveComponent, openBlock, createElementBlock, normalizeClass, createVNode, createSlots, withCtx, renderSlot, createBlock, mergeProps, createCommentVNode } from 'vue';
+import { ElButton } from '../../button/index.mjs';
+import { ElTooltip } from '../../tooltip/index.mjs';
+import { ElScrollbar } from '../../scrollbar/index.mjs';
+import { ElIcon } from '../../icon/index.mjs';
+import ElRovingFocusGroup from '../../roving-focus-group/src/roving-focus-group2.mjs';
+import { ArrowDown } from '@element-plus/icons-vue';
+import { ElCollection, dropdownProps } from './dropdown.mjs';
+import { DROPDOWN_INJECTION_KEY, DROPDOWN_INSTANCE_INJECTION_KEY } from './tokens.mjs';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
+import { OnlyChild } from '../../slot/src/only-child.mjs';
+import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
+import { useLocale } from '../../../hooks/use-locale/index.mjs';
+import { addUnit } from '../../../utils/dom/style.mjs';
+import { castArray } from 'lodash-unified';
+import { useId } from '../../../hooks/use-id/index.mjs';
+import { useFormSize } from '../../form/src/hooks/use-form-common-props.mjs';
+
+const { ButtonGroup: ElButtonGroup } = ElButton;
+const _sfc_main = defineComponent({
+  name: "ElDropdown",
+  components: {
+    ElButton,
+    ElButtonGroup,
+    ElScrollbar,
+    ElDropdownCollection: ElCollection,
+    ElTooltip,
+    ElRovingFocusGroup,
+    ElOnlyChild: OnlyChild,
+    ElIcon,
+    ArrowDown
+  },
+  props: dropdownProps,
+  emits: ["visible-change", "click", "command"],
+  setup(props, { emit }) {
+    const _instance = getCurrentInstance();
+    const ns = useNamespace("dropdown");
+    const { t } = useLocale();
+    const triggeringElementRef = ref();
+    const referenceElementRef = ref();
+    const popperRef = ref();
+    const contentRef = ref();
+    const scrollbar = ref(null);
+    const currentTabId = ref(null);
+    const isUsingKeyboard = ref(false);
+    const wrapStyle = computed(() => ({
+      maxHeight: addUnit(props.maxHeight)
+    }));
+    const dropdownTriggerKls = computed(() => [ns.m(dropdownSize.value)]);
+    const trigger = computed(() => castArray(props.trigger));
+    const defaultTriggerId = useId().value;
+    const triggerId = computed(() => props.id || defaultTriggerId);
+    function handleClick() {
+      var _a;
+      (_a = popperRef.value) == null ? void 0 : _a.onClose(void 0, 0);
+    }
+    function handleClose() {
+      var _a;
+      (_a = popperRef.value) == null ? void 0 : _a.onClose();
+    }
+    function handleOpen() {
+      var _a;
+      (_a = popperRef.value) == null ? void 0 : _a.onOpen();
+    }
+    const dropdownSize = useFormSize();
+    function commandHandler(...args) {
+      emit("command", ...args);
+    }
+    function onItemEnter() {
+    }
+    function onItemLeave() {
+      const contentEl = unref(contentRef);
+      trigger.value.includes("hover") && (contentEl == null ? void 0 : contentEl.focus({
+        preventScroll: true
+      }));
+      currentTabId.value = null;
+    }
+    function handleCurrentTabIdChange(id) {
+      currentTabId.value = id;
+    }
+    function handleEntryFocus(e) {
+      if (!isUsingKeyboard.value) {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+      }
+    }
+    function handleBeforeShowTooltip() {
+      emit("visible-change", true);
+    }
+    function handleShowTooltip(event) {
+      var _a;
+      if ((event == null ? void 0 : event.type) === "keydown") {
+        (_a = contentRef.value) == null ? void 0 : _a.focus();
+      }
+    }
+    function handleBeforeHideTooltip() {
+      emit("visible-change", false);
+    }
+    provide(DROPDOWN_INJECTION_KEY, {
+      contentRef,
+      role: computed(() => props.role),
+      triggerId,
+      isUsingKeyboard,
+      onItemEnter,
+      onItemLeave
+    });
+    provide(DROPDOWN_INSTANCE_INJECTION_KEY, {
+      instance: _instance,
+      dropdownSize,
+      handleClick,
+      commandHandler,
+      trigger: toRef(props, "trigger"),
+      hideOnClick: toRef(props, "hideOnClick")
+    });
+    const onFocusAfterTrapped = (e) => {
+      var _a, _b;
+      e.preventDefault();
+      (_b = (_a = contentRef.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a, {
+        preventScroll: true
+      });
+    };
+    const handlerMainButtonClick = (event) => {
+      emit("click", event);
+    };
+    return {
+      t,
+      ns,
+      scrollbar,
+      wrapStyle,
+      dropdownTriggerKls,
+      dropdownSize,
+      triggerId,
+      currentTabId,
+      handleCurrentTabIdChange,
+      handlerMainButtonClick,
+      handleEntryFocus,
+      handleClose,
+      handleOpen,
+      handleBeforeShowTooltip,
+      handleShowTooltip,
+      handleBeforeHideTooltip,
+      onFocusAfterTrapped,
+      popperRef,
+      contentRef,
+      triggeringElementRef,
+      referenceElementRef
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  var _a, _b;
+  const _component_el_dropdown_collection = resolveComponent("el-dropdown-collection");
+  const _component_el_roving_focus_group = resolveComponent("el-roving-focus-group");
+  const _component_el_scrollbar = resolveComponent("el-scrollbar");
+  const _component_el_only_child = resolveComponent("el-only-child");
+  const _component_el_tooltip = resolveComponent("el-tooltip");
+  const _component_el_button = resolveComponent("el-button");
+  const _component_arrow_down = resolveComponent("arrow-down");
+  const _component_el_icon = resolveComponent("el-icon");
+  const _component_el_button_group = resolveComponent("el-button-group");
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass([_ctx.ns.b(), _ctx.ns.is("disabled", _ctx.disabled)])
+  }, [
+    createVNode(_component_el_tooltip, {
+      ref: "popperRef",
+      role: _ctx.role,
+      effect: _ctx.effect,
+      "fallback-placements": ["bottom", "top"],
+      "popper-options": _ctx.popperOptions,
+      "gpu-acceleration": false,
+      "manual-mode": true,
+      placement: _ctx.placement,
+      "popper-class": [_ctx.ns.e("popper"), _ctx.popperClass],
+      "reference-element": (_a = _ctx.referenceElementRef) == null ? void 0 : _a.$el,
+      trigger: _ctx.trigger,
+      "trigger-keys": _ctx.triggerKeys,
+      "trigger-target-el": _ctx.contentRef,
+      "show-arrow": _ctx.showArrow,
+      "show-after": _ctx.trigger === "hover" ? _ctx.showTimeout : 0,
+      "hide-after": _ctx.trigger === "hover" ? _ctx.hideTimeout : 0,
+      "stop-popper-mouse-event": false,
+      "virtual-ref": (_b = _ctx.virtualRef) != null ? _b : _ctx.triggeringElementRef,
+      "virtual-triggering": _ctx.virtualTriggering || _ctx.splitButton,
+      disabled: _ctx.disabled,
+      transition: `${_ctx.ns.namespace.value}-zoom-in-top`,
+      teleported: _ctx.teleported,
+      pure: "",
+      "focus-on-target": "",
+      persistent: _ctx.persistent,
+      onBeforeShow: _ctx.handleBeforeShowTooltip,
+      onShow: _ctx.handleShowTooltip,
+      onBeforeHide: _ctx.handleBeforeHideTooltip
+    }, createSlots({
+      content: withCtx(() => [
+        createVNode(_component_el_scrollbar, {
+          ref: "scrollbar",
+          "wrap-style": _ctx.wrapStyle,
+          tag: "div",
+          "view-class": _ctx.ns.e("list")
+        }, {
+          default: withCtx(() => [
+            createVNode(_component_el_roving_focus_group, {
+              loop: _ctx.loop,
+              "current-tab-id": _ctx.currentTabId,
+              orientation: "horizontal",
+              onCurrentTabIdChange: _ctx.handleCurrentTabIdChange,
+              onEntryFocus: _ctx.handleEntryFocus
+            }, {
+              default: withCtx(() => [
+                createVNode(_component_el_dropdown_collection, null, {
+                  default: withCtx(() => [
+                    renderSlot(_ctx.$slots, "dropdown")
+                  ]),
+                  _: 3
+                })
+              ]),
+              _: 3
+            }, 8, ["loop", "current-tab-id", "onCurrentTabIdChange", "onEntryFocus"])
+          ]),
+          _: 3
+        }, 8, ["wrap-style", "view-class"])
+      ]),
+      _: 2
+    }, [
+      !_ctx.splitButton ? {
+        name: "default",
+        fn: withCtx(() => [
+          createVNode(_component_el_only_child, {
+            id: _ctx.triggerId,
+            ref: "triggeringElementRef",
+            role: "button",
+            tabindex: _ctx.tabindex
+          }, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 8, ["id", "tabindex"])
+        ])
+      } : void 0
+    ]), 1032, ["role", "effect", "popper-options", "placement", "popper-class", "reference-element", "trigger", "trigger-keys", "trigger-target-el", "show-arrow", "show-after", "hide-after", "virtual-ref", "virtual-triggering", "disabled", "transition", "teleported", "persistent", "onBeforeShow", "onShow", "onBeforeHide"]),
+    _ctx.splitButton ? (openBlock(), createBlock(_component_el_button_group, { key: 0 }, {
+      default: withCtx(() => [
+        createVNode(_component_el_button, mergeProps({ ref: "referenceElementRef" }, _ctx.buttonProps, {
+          size: _ctx.dropdownSize,
+          type: _ctx.type,
+          disabled: _ctx.disabled,
+          tabindex: _ctx.tabindex,
+          onClick: _ctx.handlerMainButtonClick
+        }), {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "default")
+          ]),
+          _: 3
+        }, 16, ["size", "type", "disabled", "tabindex", "onClick"]),
+        createVNode(_component_el_button, mergeProps({
+          id: _ctx.triggerId,
+          ref: "triggeringElementRef"
+        }, _ctx.buttonProps, {
+          role: "button",
+          size: _ctx.dropdownSize,
+          type: _ctx.type,
+          class: _ctx.ns.e("caret-button"),
+          disabled: _ctx.disabled,
+          tabindex: _ctx.tabindex,
+          "aria-label": _ctx.t("el.dropdown.toggleDropdown")
+        }), {
+          default: withCtx(() => [
+            createVNode(_component_el_icon, {
+              class: normalizeClass(_ctx.ns.e("icon"))
+            }, {
+              default: withCtx(() => [
+                createVNode(_component_arrow_down)
+              ]),
+              _: 1
+            }, 8, ["class"])
+          ]),
+          _: 1
+        }, 16, ["id", "size", "type", "class", "disabled", "tabindex", "aria-label"])
+      ]),
+      _: 3
+    })) : createCommentVNode("v-if", true)
+  ], 2);
+}
+var Dropdown = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "dropdown.vue"]]);
+
+export { Dropdown as default };
+//# sourceMappingURL=dropdown2.mjs.map

node_modules/element-plus/es/components/dropdown/src/instance.d.ts

@@ -0,0 +1,2 @@
+import type Dropdown from './dropdown.vue';
+export type DropdownInstance = InstanceType<typeof Dropdown> & unknown;

node_modules/element-plus/es/components/dropdown/src/instance.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=instance.mjs.map

node_modules/element-plus/es/components/dropdown/src/instance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

node_modules/element-plus/es/components/dropdown/src/tokens.d.ts

@@ -0,0 +1,12 @@
+import type { PopperProps } from 'element-plus/es/components/popper';
+import type { ComputedRef, InjectionKey, Ref } from 'vue';
+export type ElDropdownInjectionContext = {
+    contentRef: Ref<HTMLElement | undefined>;
+    role: ComputedRef<PopperProps['role']>;
+    triggerId: ComputedRef<string>;
+    isUsingKeyboard: Ref<boolean>;
+    onItemLeave: (e: PointerEvent) => void;
+    onItemEnter: (e: PointerEvent) => void;
+};
+export declare const DROPDOWN_INJECTION_KEY: InjectionKey<ElDropdownInjectionContext>;
+export declare const DROPDOWN_INSTANCE_INJECTION_KEY = "elDropdown";

node_modules/element-plus/es/components/dropdown/src/tokens.mjs

@@ -0,0 +1,5 @@
+const DROPDOWN_INJECTION_KEY = Symbol("elDropdown");
+const DROPDOWN_INSTANCE_INJECTION_KEY = "elDropdown";
+
+export { DROPDOWN_INJECTION_KEY, DROPDOWN_INSTANCE_INJECTION_KEY };
+//# sourceMappingURL=tokens.mjs.map

node_modules/element-plus/es/components/dropdown/src/tokens.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.mjs","sources":["../../../../../../packages/components/dropdown/src/tokens.ts"],"sourcesContent":["import type { PopperProps } from '@element-plus/components/popper'\nimport type { ComputedRef, InjectionKey, Ref } from 'vue'\n\nexport type ElDropdownInjectionContext = {\n  contentRef: Ref<HTMLElement | undefined>\n  role: ComputedRef<PopperProps['role']>\n  triggerId: ComputedRef<string>\n  isUsingKeyboard: Ref<boolean>\n  onItemLeave: (e: PointerEvent) => void\n  onItemEnter: (e: PointerEvent) => void\n}\n\nexport const DROPDOWN_INJECTION_KEY: InjectionKey<ElDropdownInjectionContext> =\n  Symbol('elDropdown')\n\nexport const DROPDOWN_INSTANCE_INJECTION_KEY = 'elDropdown'\n"],"names":[],"mappings":"AAAY,MAAC,sBAAsB,GAAG,MAAM,CAAC,YAAY,EAAE;AAC/C,MAAC,+BAA+B,GAAG;;;;"}

node_modules/element-plus/es/components/dropdown/src/useDropdown.d.ts

@@ -0,0 +1,5 @@
+import type { IElDropdownInstance } from './dropdown';
+export declare const useDropdown: () => {
+    elDropdown: IElDropdownInstance;
+    _elDropdownSize: import("vue").ComputedRef<import("vue").ComputedRef<string> | undefined>;
+};

node_modules/element-plus/es/components/dropdown/src/useDropdown.mjs

@@ -0,0 +1,14 @@
+import { inject, computed } from 'vue';
+import { DROPDOWN_INSTANCE_INJECTION_KEY } from './tokens.mjs';
+
+const useDropdown = () => {
+  const elDropdown = inject(DROPDOWN_INSTANCE_INJECTION_KEY, {});
+  const _elDropdownSize = computed(() => elDropdown == null ? void 0 : elDropdown.dropdownSize);
+  return {
+    elDropdown,
+    _elDropdownSize
+  };
+};
+
+export { useDropdown };
+//# sourceMappingURL=useDropdown.mjs.map

node_modules/element-plus/es/components/dropdown/src/useDropdown.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDropdown.mjs","sources":["../../../../../../packages/components/dropdown/src/useDropdown.ts"],"sourcesContent":["import { computed, inject } from 'vue'\nimport { DROPDOWN_INSTANCE_INJECTION_KEY } from './tokens'\n\nimport type { IElDropdownInstance } from './dropdown'\n\nexport const useDropdown = () => {\n  const elDropdown = inject<IElDropdownInstance>(\n    DROPDOWN_INSTANCE_INJECTION_KEY,\n    {}\n  )\n  const _elDropdownSize = computed(() => elDropdown?.dropdownSize)\n\n  return {\n    elDropdown,\n    _elDropdownSize,\n  }\n}\n"],"names":[],"mappings":";;;AAEY,MAAC,WAAW,GAAG,MAAM;AACjC,EAAE,MAAM,UAAU,GAAG,MAAM,CAAC,+BAA+B,EAAE,EAAE,CAAC,CAAC;AACjE,EAAE,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,UAAU,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;AAChG,EAAE,OAAO;AACT,IAAI,UAAU;AACd,IAAI,eAAe;AACnB,GAAG,CAAC;AACJ;;;;"}

node_modules/element-plus/es/components/dropdown/style/css.d.ts

@@ -0,0 +1,6 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/es/components/button/style/css';
+import 'element-plus/es/components/button-group/style/css';
+import 'element-plus/es/components/popper/style/css';
+import 'element-plus/es/components/scrollbar/style/css';
+import 'element-plus/theme-chalk/el-dropdown.css';

node_modules/element-plus/es/components/dropdown/style/css.mjs

@@ -0,0 +1,7 @@
+import '../../base/style/css.mjs';
+import '../../button/style/css.mjs';
+import '../../button-group/style/css.mjs';
+import '../../popper/style/css.mjs';
+import '../../scrollbar/style/css.mjs';
+import 'element-plus/theme-chalk/el-dropdown.css';
+//# sourceMappingURL=css.mjs.map

node_modules/element-plus/es/components/dropdown/style/css.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

node_modules/element-plus/es/components/dropdown/style/index.d.ts

@@ -0,0 +1,6 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/es/components/button/style';
+import 'element-plus/es/components/button-group/style';
+import 'element-plus/es/components/popper/style';
+import 'element-plus/es/components/scrollbar/style';
+import 'element-plus/theme-chalk/src/dropdown.scss';

node_modules/element-plus/es/components/dropdown/style/index.mjs

@@ -0,0 +1,7 @@
+import '../../base/style/index.mjs';
+import '../../button/style/index.mjs';
+import '../../button-group/style/index.mjs';
+import '../../popper/style/index.mjs';
+import '../../scrollbar/style/index.mjs';
+import 'element-plus/theme-chalk/src/dropdown.scss';
+//# sourceMappingURL=index.mjs.map

node_modules/element-plus/es/components/dropdown/style/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}