init

node_modules/element-plus/lib/components/message/index.d.ts

@@ -0,0 +1,3 @@
+export declare const ElMessage: import("element-plus/es/utils").SFCInstallWithContext<import("./src/message").Message>;
+export default ElMessage;
+export * from './src/message';

node_modules/element-plus/lib/components/message/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var method = require('./src/method.js');
+var message = require('./src/message2.js');
+var install = require('../../utils/vue/install.js');
+
+const ElMessage = install.withInstallFunction(method["default"], "$message");
+
+exports.MESSAGE_DEFAULT_PLACEMENT = message.MESSAGE_DEFAULT_PLACEMENT;
+exports.messageDefaults = message.messageDefaults;
+exports.messageEmits = message.messageEmits;
+exports.messagePlacement = message.messagePlacement;
+exports.messageProps = message.messageProps;
+exports.messageTypes = message.messageTypes;
+exports.ElMessage = ElMessage;
+exports["default"] = ElMessage;
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/message/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../packages/components/message/index.ts"],"sourcesContent":["import { withInstallFunction } from '@element-plus/utils'\nimport Message from './src/method'\n\nexport const ElMessage = withInstallFunction(Message, '$message')\nexport default ElMessage\n\nexport * from './src/message'\n"],"names":["withInstallFunction","Message"],"mappings":";;;;;;;;AAEY,MAAC,SAAS,GAAGA,2BAAmB,CAACC,iBAAO,EAAE,UAAU;;;;;;;;;;;"}

node_modules/element-plus/lib/components/message/src/instance.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentInternalInstance, VNode } from 'vue';
+import type { Mutable } from 'element-plus/es/utils';
+import type { MessageHandler, MessagePlacement, MessageProps } from './message';
+export type MessageContext = {
+    id: string;
+    vnode: VNode;
+    handler: MessageHandler;
+    vm: ComponentInternalInstance;
+    props: Mutable<MessageProps>;
+};
+export declare const placementInstances: import("vue").ShallowReactive<Record<"top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right", MessageContext[]>>;
+export declare const getOrCreatePlacementInstances: (placement: MessagePlacement) => MessageContext[];
+export declare const getInstance: (id: string, placement: MessagePlacement) => {
+    current: MessageContext;
+    prev: MessageContext | undefined;
+};
+export declare const getLastOffset: (id: string, placement: MessagePlacement) => number;
+export declare const getOffsetOrSpace: (id: string, offset: number, placement: MessagePlacement) => number;

node_modules/element-plus/lib/components/message/src/instance.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const placementInstances = vue.shallowReactive({});
+const getOrCreatePlacementInstances = (placement) => {
+  if (!placementInstances[placement]) {
+    placementInstances[placement] = vue.shallowReactive([]);
+  }
+  return placementInstances[placement];
+};
+const getInstance = (id, placement) => {
+  const instances = placementInstances[placement] || [];
+  const idx = instances.findIndex((instance) => instance.id === id);
+  const current = instances[idx];
+  let prev;
+  if (idx > 0) {
+    prev = instances[idx - 1];
+  }
+  return { current, prev };
+};
+const getLastOffset = (id, placement) => {
+  const { prev } = getInstance(id, placement);
+  if (!prev)
+    return 0;
+  return prev.vm.exposed.bottom.value;
+};
+const getOffsetOrSpace = (id, offset, placement) => {
+  const instances = placementInstances[placement] || [];
+  const idx = instances.findIndex((instance) => instance.id === id);
+  return idx > 0 ? 16 : offset;
+};
+
+exports.getInstance = getInstance;
+exports.getLastOffset = getLastOffset;
+exports.getOffsetOrSpace = getOffsetOrSpace;
+exports.getOrCreatePlacementInstances = getOrCreatePlacementInstances;
+exports.placementInstances = placementInstances;
+//# sourceMappingURL=instance.js.map

node_modules/element-plus/lib/components/message/src/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.js","sources":["../../../../../../packages/components/message/src/instance.ts"],"sourcesContent":["import { shallowReactive } from 'vue'\n\nimport type { ComponentInternalInstance, VNode } from 'vue'\nimport type { Mutable } from '@element-plus/utils'\nimport type { MessageHandler, MessagePlacement, MessageProps } from './message'\n\nexport type MessageContext = {\n  id: string\n  vnode: VNode\n  handler: MessageHandler\n  vm: ComponentInternalInstance\n  props: Mutable<MessageProps>\n}\n\nexport const placementInstances = shallowReactive(\n  {} as Record<MessagePlacement, MessageContext[]>\n)\n\nexport const getOrCreatePlacementInstances = (placement: MessagePlacement) => {\n  if (!placementInstances[placement]) {\n    placementInstances[placement] = shallowReactive([])\n  }\n  return placementInstances[placement]\n}\n\nexport const getInstance = (id: string, placement: MessagePlacement) => {\n  const instances = placementInstances[placement] || []\n  const idx = instances.findIndex((instance) => instance.id === id)\n  const current = instances[idx]\n  let prev: MessageContext | undefined\n  if (idx > 0) {\n    prev = instances[idx - 1]\n  }\n  return { current, prev }\n}\n\nexport const getLastOffset = (\n  id: string,\n  placement: MessagePlacement\n): number => {\n  const { prev } = getInstance(id, placement)\n  if (!prev) return 0\n  return prev.vm.exposed!.bottom.value\n}\n\nexport const getOffsetOrSpace = (\n  id: string,\n  offset: number,\n  placement: MessagePlacement\n) => {\n  const instances = placementInstances[placement] || []\n  const idx = instances.findIndex((instance) => instance.id === id)\n  return idx > 0 ? 16 : offset\n}\n"],"names":["shallowReactive"],"mappings":";;;;;;AACY,MAAC,kBAAkB,GAAGA,mBAAe,CAAC,EAAE,EAAE;AAC1C,MAAC,6BAA6B,GAAG,CAAC,SAAS,KAAK;AAC5D,EAAE,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE;AACtC,IAAI,kBAAkB,CAAC,SAAS,CAAC,GAAGA,mBAAe,CAAC,EAAE,CAAC,CAAC;AACxD,GAAG;AACH,EAAE,OAAO,kBAAkB,CAAC,SAAS,CAAC,CAAC;AACvC,EAAE;AACU,MAAC,WAAW,GAAG,CAAC,EAAE,EAAE,SAAS,KAAK;AAC9C,EAAE,MAAM,SAAS,GAAG,kBAAkB,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;AACxD,EAAE,MAAM,GAAG,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACpE,EAAE,MAAM,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;AACjC,EAAE,IAAI,IAAI,CAAC;AACX,EAAE,IAAI,GAAG,GAAG,CAAC,EAAE;AACf,IAAI,IAAI,GAAG,SAAS,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AAC9B,GAAG;AACH,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAC3B,EAAE;AACU,MAAC,aAAa,GAAG,CAAC,EAAE,EAAE,SAAS,KAAK;AAChD,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,WAAW,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;AAC9C,EAAE,IAAI,CAAC,IAAI;AACX,IAAI,OAAO,CAAC,CAAC;AACb,EAAE,OAAO,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC;AACtC,EAAE;AACU,MAAC,gBAAgB,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,KAAK;AAC3D,EAAE,MAAM,SAAS,GAAG,kBAAkB,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;AACxD,EAAE,MAAM,GAAG,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACpE,EAAE,OAAO,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC;AAC/B;;;;;;;;"}

node_modules/element-plus/lib/components/message/src/message.d.ts

@@ -0,0 +1,108 @@
+import type { AppContext, ExtractPropTypes, VNode, __ExtractPublicPropTypes } from 'vue';
+import type { Mutable } from 'element-plus/es/utils';
+import type MessageConstructor from './message.vue';
+export declare const messageTypes: readonly ["primary", "success", "info", "warning", "error"];
+export declare const messagePlacement: readonly ["top", "top-left", "top-right", "bottom", "bottom-left", "bottom-right"];
+export declare const MESSAGE_DEFAULT_PLACEMENT = "top";
+export type MessageType = typeof messageTypes[number];
+export type MessagePlacement = typeof messagePlacement[number];
+/** @deprecated please use `MessageType` instead */
+export type messageType = MessageType;
+export interface MessageConfigContext {
+    max?: number;
+    grouping?: boolean;
+    duration?: number;
+    offset?: number;
+    showClose?: boolean;
+    plain?: boolean;
+    placement?: string;
+}
+export declare const messageDefaults: Mutable<{
+    readonly customClass: "";
+    readonly dangerouslyUseHTMLString: false;
+    readonly duration: 3000;
+    readonly icon: undefined;
+    readonly id: "";
+    readonly message: "";
+    readonly onClose: undefined;
+    readonly showClose: false;
+    readonly type: "info";
+    readonly plain: false;
+    readonly offset: 16;
+    readonly placement: undefined;
+    readonly zIndex: 0;
+    readonly grouping: false;
+    readonly repeatNum: 1;
+    readonly appendTo: HTMLElement;
+}>;
+export declare const messageProps: {
+    readonly customClass: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly dangerouslyUseHTMLString: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly duration: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 3000, boolean>;
+    readonly icon: import("element-plus/es/utils").EpPropFinalized<(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, boolean>;
+    readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly message: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => VNode)) | (() => string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => VNode)) | ((new (...args: any[]) => string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => VNode)) | (() => string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => VNode)))[], unknown, unknown, "", boolean>;
+    readonly onClose: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => () => void) | (() => () => void) | {
+        (): () => void;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => () => void) | (() => () => void) | {
+        (): () => void;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, undefined, boolean>;
+    readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "error" | "primary" | "success" | "warning" | "info", unknown, "info", boolean>;
+    readonly plain: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 16, boolean>;
+    readonly placement: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right", unknown, undefined, boolean>;
+    readonly zIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly grouping: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly repeatNum: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+};
+export type MessageProps = ExtractPropTypes<typeof messageProps>;
+export type MessagePropsPublic = __ExtractPublicPropTypes<typeof messageProps>;
+export declare const messageEmits: {
+    destroy: () => boolean;
+};
+export type MessageEmits = typeof messageEmits;
+export type MessageInstance = InstanceType<typeof MessageConstructor> & unknown;
+export type MessageOptions = Partial<Mutable<Omit<MessageProps, 'id'> & {
+    appendTo?: HTMLElement | string;
+}>>;
+export type MessageParams = MessageOptions | MessageOptions['message'];
+export type MessageParamsNormalized = Omit<MessageProps, 'id'> & {
+    /**
+     * @description set the root element for the message, default to `document.body`
+     */
+    appendTo: HTMLElement;
+};
+export type MessageOptionsWithType = Omit<MessageOptions, 'type'>;
+export type MessageParamsWithType = MessageOptionsWithType | MessageOptions['message'];
+export interface MessageHandler {
+    /**
+     * @description close the Message
+     */
+    close: () => void;
+}
+export type MessageFn = {
+    (options?: MessageParams, appContext?: null | AppContext): MessageHandler;
+    closeAll(type?: MessageType): void;
+    closeAllByPlacement(position: MessagePlacement): void;
+};
+export type MessageTypedFn = (options?: MessageParamsWithType, appContext?: null | AppContext) => MessageHandler;
+export type Message = MessageFn & {
+    primary: MessageTypedFn;
+    success: MessageTypedFn;
+    warning: MessageTypedFn;
+    info: MessageTypedFn;
+    error: MessageTypedFn;
+};

node_modules/element-plus/lib/components/message/src/message.js

@@ -0,0 +1,176 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var core = require('@vueuse/core');
+var index = require('../../badge/index.js');
+var index$1 = require('../../icon/index.js');
+var message = require('./message2.js');
+var instance = require('./instance.js');
+var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+var useGlobalConfig = require('../../config-provider/src/hooks/use-global-config.js');
+var icon = require('../../../utils/vue/icon.js');
+var aria = require('../../../constants/aria.js');
+
+const __default__ = vue.defineComponent({
+  name: "ElMessage"
+});
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: message.messageProps,
+  emits: message.messageEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const { Close } = icon.TypeComponents;
+    const isStartTransition = vue.ref(false);
+    const { ns, zIndex } = useGlobalConfig.useGlobalComponentSettings("message");
+    const { currentZIndex, nextZIndex } = zIndex;
+    const messageRef = vue.ref();
+    const visible = vue.ref(false);
+    const height = vue.ref(0);
+    let stopTimer = void 0;
+    const badgeType = vue.computed(() => props.type ? props.type === "error" ? "danger" : props.type : "info");
+    const typeClass = vue.computed(() => {
+      const type = props.type;
+      return { [ns.bm("icon", type)]: type && icon.TypeComponentsMap[type] };
+    });
+    const iconComponent = vue.computed(() => props.icon || icon.TypeComponentsMap[props.type] || "");
+    const placement = vue.computed(() => props.placement || message.MESSAGE_DEFAULT_PLACEMENT);
+    const lastOffset = vue.computed(() => instance.getLastOffset(props.id, placement.value));
+    const offset = vue.computed(() => {
+      return instance.getOffsetOrSpace(props.id, props.offset, placement.value) + lastOffset.value;
+    });
+    const bottom = vue.computed(() => height.value + offset.value);
+    const horizontalClass = vue.computed(() => {
+      if (placement.value.includes("left"))
+        return ns.is("left");
+      if (placement.value.includes("right"))
+        return ns.is("right");
+      return ns.is("center");
+    });
+    const verticalProperty = vue.computed(() => placement.value.startsWith("top") ? "top" : "bottom");
+    const customStyle = vue.computed(() => ({
+      [verticalProperty.value]: `${offset.value}px`,
+      zIndex: currentZIndex.value
+    }));
+    function startTimer() {
+      if (props.duration === 0)
+        return;
+      ({ stop: stopTimer } = core.useTimeoutFn(() => {
+        close();
+      }, props.duration));
+    }
+    function clearTimer() {
+      stopTimer == null ? void 0 : stopTimer();
+    }
+    function close() {
+      visible.value = false;
+      vue.nextTick(() => {
+        var _a;
+        if (!isStartTransition.value) {
+          (_a = props.onClose) == null ? void 0 : _a.call(props);
+          emit("destroy");
+        }
+      });
+    }
+    function keydown({ code }) {
+      if (code === aria.EVENT_CODE.esc) {
+        close();
+      }
+    }
+    vue.onMounted(() => {
+      startTimer();
+      nextZIndex();
+      visible.value = true;
+    });
+    vue.watch(() => props.repeatNum, () => {
+      clearTimer();
+      startTimer();
+    });
+    core.useEventListener(document, "keydown", keydown);
+    core.useResizeObserver(messageRef, () => {
+      height.value = messageRef.value.getBoundingClientRect().height;
+    });
+    expose({
+      visible,
+      bottom,
+      close
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.Transition, {
+        name: vue.unref(ns).b("fade"),
+        onBeforeEnter: ($event) => isStartTransition.value = true,
+        onBeforeLeave: _ctx.onClose,
+        onAfterLeave: ($event) => _ctx.$emit("destroy"),
+        persisted: ""
+      }, {
+        default: vue.withCtx(() => [
+          vue.withDirectives(vue.createElementVNode("div", {
+            id: _ctx.id,
+            ref_key: "messageRef",
+            ref: messageRef,
+            class: vue.normalizeClass([
+              vue.unref(ns).b(),
+              { [vue.unref(ns).m(_ctx.type)]: _ctx.type },
+              vue.unref(ns).is("closable", _ctx.showClose),
+              vue.unref(ns).is("plain", _ctx.plain),
+              vue.unref(ns).is("bottom", vue.unref(verticalProperty) === "bottom"),
+              vue.unref(horizontalClass),
+              _ctx.customClass
+            ]),
+            style: vue.normalizeStyle(vue.unref(customStyle)),
+            role: "alert",
+            onMouseenter: clearTimer,
+            onMouseleave: startTimer
+          }, [
+            _ctx.repeatNum > 1 ? (vue.openBlock(), vue.createBlock(vue.unref(index.ElBadge), {
+              key: 0,
+              value: _ctx.repeatNum,
+              type: vue.unref(badgeType),
+              class: vue.normalizeClass(vue.unref(ns).e("badge"))
+            }, null, 8, ["value", "type", "class"])) : vue.createCommentVNode("v-if", true),
+            vue.unref(iconComponent) ? (vue.openBlock(), vue.createBlock(vue.unref(index$1.ElIcon), {
+              key: 1,
+              class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(typeClass)])
+            }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(iconComponent))))
+              ]),
+              _: 1
+            }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
+            vue.renderSlot(_ctx.$slots, "default", {}, () => [
+              !_ctx.dangerouslyUseHTMLString ? (vue.openBlock(), vue.createElementBlock("p", {
+                key: 0,
+                class: vue.normalizeClass(vue.unref(ns).e("content"))
+              }, vue.toDisplayString(_ctx.message), 3)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                vue.createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
+                vue.createElementVNode("p", {
+                  class: vue.normalizeClass(vue.unref(ns).e("content")),
+                  innerHTML: _ctx.message
+                }, null, 10, ["innerHTML"])
+              ], 2112))
+            ]),
+            _ctx.showClose ? (vue.openBlock(), vue.createBlock(vue.unref(index$1.ElIcon), {
+              key: 2,
+              class: vue.normalizeClass(vue.unref(ns).e("closeBtn")),
+              onClick: vue.withModifiers(close, ["stop"])
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(vue.unref(Close))
+              ]),
+              _: 1
+            }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
+          ], 46, ["id"]), [
+            [vue.vShow, visible.value]
+          ])
+        ]),
+        _: 3
+      }, 8, ["name", "onBeforeEnter", "onBeforeLeave", "onAfterLeave"]);
+    };
+  }
+});
+var MessageConstructor = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "message.vue"]]);
+
+exports["default"] = MessageConstructor;
+//# sourceMappingURL=message.js.map

node_modules/element-plus/lib/components/message/src/message.vue.d.ts

@@ -0,0 +1,108 @@
+declare function close(): void;
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly customClass: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly dangerouslyUseHTMLString: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly duration: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 3000, boolean>;
+    readonly icon: import("element-plus/es/utils").EpPropFinalized<(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, boolean>;
+    readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly message: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)) | (() => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)) | ((new (...args: any[]) => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)) | (() => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)))[], unknown, unknown, "", boolean>;
+    readonly onClose: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => () => void) | (() => () => void) | {
+        (): () => void;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => () => void) | (() => () => void) | {
+        (): () => void;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, undefined, boolean>;
+    readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "error" | "primary" | "success" | "warning" | "info", unknown, "info", boolean>;
+    readonly plain: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 16, boolean>;
+    readonly placement: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right", unknown, undefined, boolean>;
+    readonly zIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly grouping: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly repeatNum: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+}, {
+    visible: import("vue").Ref<boolean>;
+    bottom: import("vue").ComputedRef<number>;
+    close: typeof close;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    destroy: () => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly customClass: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly dangerouslyUseHTMLString: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly duration: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 3000, boolean>;
+    readonly icon: import("element-plus/es/utils").EpPropFinalized<(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, boolean>;
+    readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly message: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)) | (() => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)) | ((new (...args: any[]) => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)) | (() => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)))[], unknown, unknown, "", boolean>;
+    readonly onClose: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => () => void) | (() => () => void) | {
+        (): () => void;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => () => void) | (() => () => void) | {
+        (): () => void;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, undefined, boolean>;
+    readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "error" | "primary" | "success" | "warning" | "info", unknown, "info", boolean>;
+    readonly plain: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 16, boolean>;
+    readonly placement: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right", unknown, undefined, boolean>;
+    readonly zIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly grouping: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly repeatNum: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+}>> & {
+    onDestroy?: (() => any) | undefined;
+}, {
+    readonly zIndex: number;
+    readonly offset: number;
+    readonly 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>;
+    readonly id: string;
+    readonly type: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "error" | "primary" | "success" | "warning" | "info", unknown>;
+    readonly message: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)) | (() => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)) | ((new (...args: any[]) => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)) | (() => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => import("vue").VNode)))[], unknown, unknown>;
+    readonly placement: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right", unknown>;
+    readonly onClose: () => void;
+    readonly duration: number;
+    readonly showClose: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly customClass: string;
+    readonly dangerouslyUseHTMLString: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly plain: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly grouping: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly repeatNum: number;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/element-plus/lib/components/message/src/message2.js

@@ -0,0 +1,122 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('../../../utils/vue/props/runtime.js');
+var icon = require('../../../utils/vue/icon.js');
+var typescript = require('../../../utils/typescript.js');
+var core = require('@vueuse/core');
+
+const messageTypes = [
+  "primary",
+  "success",
+  "info",
+  "warning",
+  "error"
+];
+const messagePlacement = [
+  "top",
+  "top-left",
+  "top-right",
+  "bottom",
+  "bottom-left",
+  "bottom-right"
+];
+const MESSAGE_DEFAULT_PLACEMENT = "top";
+const messageDefaults = typescript.mutable({
+  customClass: "",
+  dangerouslyUseHTMLString: false,
+  duration: 3e3,
+  icon: void 0,
+  id: "",
+  message: "",
+  onClose: void 0,
+  showClose: false,
+  type: "info",
+  plain: false,
+  offset: 16,
+  placement: void 0,
+  zIndex: 0,
+  grouping: false,
+  repeatNum: 1,
+  appendTo: core.isClient ? document.body : void 0
+});
+const messageProps = runtime.buildProps({
+  customClass: {
+    type: String,
+    default: messageDefaults.customClass
+  },
+  dangerouslyUseHTMLString: {
+    type: Boolean,
+    default: messageDefaults.dangerouslyUseHTMLString
+  },
+  duration: {
+    type: Number,
+    default: messageDefaults.duration
+  },
+  icon: {
+    type: icon.iconPropType,
+    default: messageDefaults.icon
+  },
+  id: {
+    type: String,
+    default: messageDefaults.id
+  },
+  message: {
+    type: runtime.definePropType([
+      String,
+      Object,
+      Function
+    ]),
+    default: messageDefaults.message
+  },
+  onClose: {
+    type: runtime.definePropType(Function),
+    default: messageDefaults.onClose
+  },
+  showClose: {
+    type: Boolean,
+    default: messageDefaults.showClose
+  },
+  type: {
+    type: String,
+    values: messageTypes,
+    default: messageDefaults.type
+  },
+  plain: {
+    type: Boolean,
+    default: messageDefaults.plain
+  },
+  offset: {
+    type: Number,
+    default: messageDefaults.offset
+  },
+  placement: {
+    type: String,
+    values: messagePlacement,
+    default: messageDefaults.placement
+  },
+  zIndex: {
+    type: Number,
+    default: messageDefaults.zIndex
+  },
+  grouping: {
+    type: Boolean,
+    default: messageDefaults.grouping
+  },
+  repeatNum: {
+    type: Number,
+    default: messageDefaults.repeatNum
+  }
+});
+const messageEmits = {
+  destroy: () => true
+};
+
+exports.MESSAGE_DEFAULT_PLACEMENT = MESSAGE_DEFAULT_PLACEMENT;
+exports.messageDefaults = messageDefaults;
+exports.messageEmits = messageEmits;
+exports.messagePlacement = messagePlacement;
+exports.messageProps = messageProps;
+exports.messageTypes = messageTypes;
+//# sourceMappingURL=message2.js.map

node_modules/element-plus/lib/components/message/src/method.d.ts

@@ -0,0 +1,5 @@
+import type { Message, MessagePlacement, MessageType } from './message';
+export declare function closeAll(type?: MessageType): void;
+export declare function closeAllByPlacement(placement: MessagePlacement): void;
+declare const _default: Message;
+export default _default;

node_modules/element-plus/lib/components/message/src/method.js

@@ -0,0 +1,165 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var message$2 = require('./message.js');
+var message$1 = require('./message2.js');
+var instance = require('./instance.js');
+var configProvider = require('../../config-provider/src/config-provider.js');
+var core = require('@vueuse/core');
+var types = require('../../../utils/types.js');
+var shared = require('@vue/shared');
+var error = require('../../../utils/error.js');
+
+let seed = 1;
+const normalizeAppendTo = (normalized) => {
+  const appendTo = normalized.appendTo;
+  if (!appendTo) {
+    normalized.appendTo = document.body;
+  } else if (shared.isString(normalized.appendTo)) {
+    let appendTo2 = document.querySelector(normalized.appendTo);
+    if (!types.isElement(appendTo2)) {
+      appendTo2 = document.body;
+    }
+    normalized.appendTo = appendTo2;
+  }
+};
+const normalizePlacement = (normalized) => {
+  if (!normalized.placement && shared.isString(configProvider.messageConfig.placement) && configProvider.messageConfig.placement) {
+    normalized.placement = configProvider.messageConfig.placement;
+  }
+  if (!normalized.placement) {
+    normalized.placement = message$1.MESSAGE_DEFAULT_PLACEMENT;
+  }
+  if (!message$1.messagePlacement.includes(normalized.placement)) {
+    error.debugWarn("ElMessage", `Invalid placement: ${normalized.placement}. Falling back to '${message$1.MESSAGE_DEFAULT_PLACEMENT}'.`);
+    normalized.placement = message$1.MESSAGE_DEFAULT_PLACEMENT;
+  }
+};
+const normalizeOptions = (params) => {
+  const options = !params || shared.isString(params) || vue.isVNode(params) || shared.isFunction(params) ? { message: params } : params;
+  const normalized = {
+    ...message$1.messageDefaults,
+    ...options
+  };
+  normalizeAppendTo(normalized);
+  normalizePlacement(normalized);
+  if (types.isBoolean(configProvider.messageConfig.grouping) && !normalized.grouping) {
+    normalized.grouping = configProvider.messageConfig.grouping;
+  }
+  if (types.isNumber(configProvider.messageConfig.duration) && normalized.duration === 3e3) {
+    normalized.duration = configProvider.messageConfig.duration;
+  }
+  if (types.isNumber(configProvider.messageConfig.offset) && normalized.offset === 16) {
+    normalized.offset = configProvider.messageConfig.offset;
+  }
+  if (types.isBoolean(configProvider.messageConfig.showClose) && !normalized.showClose) {
+    normalized.showClose = configProvider.messageConfig.showClose;
+  }
+  if (types.isBoolean(configProvider.messageConfig.plain) && !normalized.plain) {
+    normalized.plain = configProvider.messageConfig.plain;
+  }
+  return normalized;
+};
+const closeMessage = (instance$1) => {
+  const placement = instance$1.props.placement || message$1.MESSAGE_DEFAULT_PLACEMENT;
+  const instances = instance.placementInstances[placement];
+  const idx = instances.indexOf(instance$1);
+  if (idx === -1)
+    return;
+  instances.splice(idx, 1);
+  const { handler } = instance$1;
+  handler.close();
+};
+const createMessage = ({ appendTo, ...options }, context) => {
+  const id = `message_${seed++}`;
+  const userOnClose = options.onClose;
+  const container = document.createElement("div");
+  const props = {
+    ...options,
+    id,
+    onClose: () => {
+      userOnClose == null ? void 0 : userOnClose();
+      closeMessage(instance);
+    },
+    onDestroy: () => {
+      vue.render(null, container);
+    }
+  };
+  const vnode = vue.createVNode(message$2["default"], props, shared.isFunction(props.message) || vue.isVNode(props.message) ? {
+    default: shared.isFunction(props.message) ? props.message : () => props.message
+  } : null);
+  vnode.appContext = context || message._context;
+  vue.render(vnode, container);
+  appendTo.appendChild(container.firstElementChild);
+  const vm = vnode.component;
+  const handler = {
+    close: () => {
+      vm.exposed.close();
+    }
+  };
+  const instance = {
+    id,
+    vnode,
+    vm,
+    handler,
+    props: vnode.component.props
+  };
+  return instance;
+};
+const message = (options = {}, context) => {
+  if (!core.isClient)
+    return { close: () => void 0 };
+  const normalized = normalizeOptions(options);
+  const instances = instance.getOrCreatePlacementInstances(normalized.placement || message$1.MESSAGE_DEFAULT_PLACEMENT);
+  if (normalized.grouping && instances.length) {
+    const instance2 = instances.find(({ vnode: vm }) => {
+      var _a;
+      return ((_a = vm.props) == null ? void 0 : _a.message) === normalized.message;
+    });
+    if (instance2) {
+      instance2.props.repeatNum += 1;
+      instance2.props.type = normalized.type;
+      return instance2.handler;
+    }
+  }
+  if (types.isNumber(configProvider.messageConfig.max) && instances.length >= configProvider.messageConfig.max) {
+    return { close: () => void 0 };
+  }
+  const instance$1 = createMessage(normalized, context);
+  instances.push(instance$1);
+  return instance$1.handler;
+};
+message$1.messageTypes.forEach((type) => {
+  message[type] = (options = {}, appContext) => {
+    const normalized = normalizeOptions(options);
+    return message({ ...normalized, type }, appContext);
+  };
+});
+function closeAll(type) {
+  for (const placement in instance.placementInstances) {
+    if (shared.hasOwn(instance.placementInstances, placement)) {
+      const instances = [...instance.placementInstances[placement]];
+      for (const instance of instances) {
+        if (!type || type === instance.props.type) {
+          instance.handler.close();
+        }
+      }
+    }
+  }
+}
+function closeAllByPlacement(placement) {
+  if (!instance.placementInstances[placement])
+    return;
+  const instances = [...instance.placementInstances[placement]];
+  instances.forEach((instance) => instance.handler.close());
+}
+message.closeAll = closeAll;
+message.closeAllByPlacement = closeAllByPlacement;
+message._context = null;
+
+exports.closeAll = closeAll;
+exports.closeAllByPlacement = closeAllByPlacement;
+exports["default"] = message;
+//# sourceMappingURL=method.js.map

node_modules/element-plus/lib/components/message/style/css.d.ts

@@ -0,0 +1,3 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/es/components/badge/style/css';
+import 'element-plus/theme-chalk/el-message.css';

node_modules/element-plus/lib/components/message/style/css.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../../base/style/css.js');
+require('../../badge/style/css.js');
+require('element-plus/theme-chalk/el-message.css');
+
+//# sourceMappingURL=css.js.map

node_modules/element-plus/lib/components/message/style/css.js.map

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

node_modules/element-plus/lib/components/message/style/index.d.ts

@@ -0,0 +1,3 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/es/components/badge/style';
+import 'element-plus/theme-chalk/src/message.scss';

node_modules/element-plus/lib/components/message/style/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../../base/style/index.js');
+require('../../badge/style/index.js');
+require('element-plus/theme-chalk/src/message.scss');
+
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/message/style/index.js.map

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