完全跑通1.0版本

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

@@ -0,0 +1,23 @@
+import { Mutable } from "../../../utils/typescript.js";
+import { MessageHandler, MessagePlacement, MessageProps } from "./message.js";
+import * as _$vue from "vue";
+import { ComponentInternalInstance, VNode } from "vue";
+
+//#region ../../packages/components/message/src/instance.d.ts
+type MessageContext = {
+  id: string;
+  vnode: VNode;
+  handler: MessageHandler;
+  vm: ComponentInternalInstance;
+  props: Mutable<MessageProps>;
+};
+declare const placementInstances: _$vue.ShallowReactive<Record<"top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right", MessageContext[]>>;
+declare const getOrCreatePlacementInstances: (placement: MessagePlacement) => MessageContext[];
+declare const getInstance: (id: string, placement: MessagePlacement) => {
+  current: MessageContext;
+  prev: MessageContext | undefined;
+};
+declare const getLastOffset: (id: string, placement: MessagePlacement) => number;
+declare const getOffsetOrSpace: (id: string, offset: number, placement: MessagePlacement) => number;
+//#endregion
+export { MessageContext, getInstance, getLastOffset, getOffsetOrSpace, getOrCreatePlacementInstances, placementInstances };

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

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../_virtual/_rolldown/runtime.js");
+let vue = require("vue");
+//#region ../../packages/components/message/src/instance.ts
+const placementInstances = (0, vue.shallowReactive)({});
+const getOrCreatePlacementInstances = (placement) => {
+	if (!placementInstances[placement]) placementInstances[placement] = (0, 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) => {
+	return (placementInstances[placement] || []).findIndex((instance) => instance.id === id) > 0 ? 16 : offset;
+};
+//#endregion
+exports.getInstance = getInstance;
+exports.getLastOffset = getLastOffset;
+exports.getOffsetOrSpace = getOffsetOrSpace;
+exports.getOrCreatePlacementInstances = getOrCreatePlacementInstances;
+exports.placementInstances = placementInstances;
+
+//# sourceMappingURL=instance.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instance.js","names":[],"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"],"mappings":";;;;AAcA,MAAa,sBAAA,GAAA,IAAA,iBACX,EAAE,CACH;AAED,MAAa,iCAAiC,cAAgC;CAC5E,IAAI,CAAC,mBAAmB,YACtB,mBAAmB,cAAA,GAAA,IAAA,iBAA6B,EAAE,CAAC;CAErD,OAAO,mBAAmB;;AAG5B,MAAa,eAAe,IAAY,cAAgC;CACtE,MAAM,YAAY,mBAAmB,cAAc,EAAE;CACrD,MAAM,MAAM,UAAU,WAAW,aAAa,SAAS,OAAO,GAAG;CACjE,MAAM,UAAU,UAAU;CAC1B,IAAI;CACJ,IAAI,MAAM,GACR,OAAO,UAAU,MAAM;CAEzB,OAAO;EAAE;EAAS;EAAM;;AAG1B,MAAa,iBACX,IACA,cACW;CACX,MAAM,EAAE,SAAS,YAAY,IAAI,UAAU;CAC3C,IAAI,CAAC,MAAM,OAAO;CAClB,OAAO,KAAK,GAAG,QAAS,OAAO;;AAGjC,MAAa,oBACX,IACA,QACA,cACG;CAGH,QAFkB,mBAAmB,cAAc,EAAE,EAC/B,WAAW,aAAa,SAAS,OAAO,GACpD,GAAG,IAAI,KAAK"}

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

@@ -0,0 +1,182 @@
+import { IconPropType } from "../../../utils/vue/icon.js";
+import { EpPropFinalized } from "../../../utils/vue/props/types.js";
+import { Mutable } from "../../../utils/typescript.js";
+import _default from "./message.vue.js";
+import * as _$vue from "vue";
+import { AppContext, ExtractPublicPropTypes, VNode } from "vue";
+
+//#region ../../packages/components/message/src/message.d.ts
+interface MessageProps {
+  /**
+   * @description custom class name for Message
+   */
+  customClass?: string;
+  /**
+   * @description whether `message` is treated as HTML string
+   */
+  dangerouslyUseHTMLString?: boolean;
+  /**
+   * @description display duration, millisecond. If set to 0, it will not turn off automatically
+   */
+  duration?: number;
+  /**
+   * @description custom icon component, overrides `type`
+   */
+  icon?: IconPropType;
+  /**
+   * @description message dom id
+   */
+  id?: string;
+  /**
+   * @description message text
+   */
+  message?: string | VNode | (() => VNode);
+  /**
+   * @description callback function when closed with the message instance as the parameter
+   */
+  onClose?: () => void;
+  /**
+   * @description whether to show a close button
+   */
+  showClose?: boolean;
+  /**
+   * @description message type
+   */
+  type?: MessageType;
+  /**
+   * @description whether message is plain
+   */
+  plain?: boolean;
+  /**
+   * @description set the distance to the top of viewport
+   */
+  offset?: number;
+  /**
+   * @description message placement position
+   */
+  placement?: MessagePlacement;
+  /**
+   * @description message element zIndex value
+   */
+  zIndex?: number;
+  /**
+   * @description merge messages with the same content, type of VNode message is not supported
+   */
+  grouping?: boolean;
+  /**
+   * @description The number of repetitions, similar to badge, is used as the initial number when used with `grouping`
+   */
+  repeatNum?: number;
+}
+declare const messageTypes: readonly ["primary", "success", "info", "warning", "error"];
+declare const messagePlacement: readonly ["top", "top-left", "top-right", "bottom", "bottom-left", "bottom-right"];
+declare const MESSAGE_DEFAULT_PLACEMENT = "top";
+type MessageType = (typeof messageTypes)[number];
+type MessagePlacement = (typeof messagePlacement)[number];
+/** @deprecated please use `MessageType` instead */
+type messageType = MessageType;
+interface MessageConfigContext {
+  max?: number;
+  grouping?: boolean;
+  duration?: number;
+  offset?: number;
+  showClose?: boolean;
+  plain?: boolean;
+  placement?: string;
+}
+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;
+}>;
+/**
+ * @deprecated Removed after 3.0.0, Use `MessageProps` instead.
+ */
+declare const messageProps: {
+  readonly customClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly dangerouslyUseHTMLString: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+  readonly duration: EpPropFinalized<NumberConstructor, unknown, unknown, 3000, boolean>;
+  readonly icon: EpPropFinalized<(new (...args: any[]) => (string | _$vue.Component) & {}) | (() => string | _$vue.Component) | (((new (...args: any[]) => (string | _$vue.Component) & {}) | (() => string | _$vue.Component)) | null)[], unknown, unknown, undefined, boolean>;
+  readonly id: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly message: EpPropFinalized<(new (...args: any[]) => string | VNode<_$vue.RendererNode, _$vue.RendererElement, {
+    [key: string]: any;
+  }> | (() => VNode)) | (() => string | VNode<_$vue.RendererNode, _$vue.RendererElement, {
+    [key: string]: any;
+  }> | (() => VNode)) | (((new (...args: any[]) => string | VNode<_$vue.RendererNode, _$vue.RendererElement, {
+    [key: string]: any;
+  }> | (() => VNode)) | (() => string | VNode<_$vue.RendererNode, _$vue.RendererElement, {
+    [key: string]: any;
+  }> | (() => VNode))) | null)[], unknown, unknown, "", boolean>;
+  readonly onClose: EpPropFinalized<(new (...args: any[]) => () => void) | (() => () => void) | {
+    (): () => void;
+    new (): any;
+    readonly prototype: any;
+  } | (((new (...args: any[]) => () => void) | (() => () => void) | {
+    (): () => void;
+    new (): any;
+    readonly prototype: any;
+  }) | null)[], unknown, unknown, undefined, boolean>;
+  readonly showClose: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+  readonly type: EpPropFinalized<StringConstructor, "error" | "info" | "primary" | "success" | "warning", unknown, "info", boolean>;
+  readonly plain: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+  readonly offset: EpPropFinalized<NumberConstructor, unknown, unknown, 16, boolean>;
+  readonly placement: EpPropFinalized<StringConstructor, "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right", unknown, undefined, boolean>;
+  readonly zIndex: EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+  readonly grouping: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+  readonly repeatNum: EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `MessageProps` instead.
+ */
+type MessagePropsPublic = ExtractPublicPropTypes<typeof messageProps>;
+declare const messageEmits: {
+  destroy: () => boolean;
+};
+type MessageEmits = typeof messageEmits;
+type MessageInstance = InstanceType<typeof _default> & unknown;
+type MessageOptions = Partial<Mutable<Omit<MessageProps, 'id'> & {
+  appendTo?: HTMLElement | string;
+}>>;
+type MessageParams = MessageOptions | MessageOptions['message'];
+type MessageParamsNormalized = Omit<MessageProps, 'id'> & {
+  /**
+   * @description set the root element for the message, default to `document.body`
+   */
+  appendTo: HTMLElement;
+};
+type MessageOptionsWithType = Omit<MessageOptions, 'type'>;
+type MessageParamsWithType = MessageOptionsWithType | MessageOptions['message'];
+interface MessageHandler {
+  /**
+   * @description close the Message
+   */
+  close: () => void;
+}
+type MessageFn = {
+  (options?: MessageParams, appContext?: null | AppContext): MessageHandler;
+  closeAll(type?: MessageType): void;
+  closeAllByPlacement(position: MessagePlacement): void;
+};
+type MessageTypedFn = (options?: MessageParamsWithType, appContext?: null | AppContext) => MessageHandler;
+type Message = MessageFn & {
+  primary: MessageTypedFn;
+  success: MessageTypedFn;
+  warning: MessageTypedFn;
+  info: MessageTypedFn;
+  error: MessageTypedFn;
+};
+//#endregion
+export { MESSAGE_DEFAULT_PLACEMENT, Message, MessageConfigContext, MessageEmits, MessageFn, MessageHandler, MessageInstance, MessageOptions, MessageOptionsWithType, MessageParams, MessageParamsNormalized, MessageParamsWithType, MessagePlacement, MessageProps, MessagePropsPublic, MessageType, MessageTypedFn, messageDefaults, messageEmits, messagePlacement, messageProps, messageType, messageTypes };

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

@@ -0,0 +1,167 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../_virtual/_rolldown/runtime.js");
+const require_runtime$1 = require("../../../utils/vue/props/runtime.js");
+const require_icon = require("../../../utils/vue/icon.js");
+const require_typescript = require("../../../utils/typescript.js");
+let _vueuse_core = require("@vueuse/core");
+//#region ../../packages/components/message/src/message.ts
+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 = require_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: _vueuse_core.isClient ? document.body : void 0
+});
+/**
+* @deprecated Removed after 3.0.0, Use `MessageProps` instead.
+*/
+const messageProps = require_runtime$1.buildProps({
+	/**
+	* @description custom class name for Message
+	*/
+	customClass: {
+		type: String,
+		default: messageDefaults.customClass
+	},
+	/**
+	* @description whether `message` is treated as HTML string
+	*/
+	dangerouslyUseHTMLString: {
+		type: Boolean,
+		default: messageDefaults.dangerouslyUseHTMLString
+	},
+	/**
+	* @description display duration, millisecond. If set to 0, it will not turn off automatically
+	*/
+	duration: {
+		type: Number,
+		default: messageDefaults.duration
+	},
+	/**
+	* @description custom icon component, overrides `type`
+	*/
+	icon: {
+		type: require_icon.iconPropType,
+		default: messageDefaults.icon
+	},
+	/**
+	* @description message dom id
+	*/
+	id: {
+		type: String,
+		default: messageDefaults.id
+	},
+	/**
+	* @description message text
+	*/
+	message: {
+		type: require_runtime$1.definePropType([
+			String,
+			Object,
+			Function
+		]),
+		default: messageDefaults.message
+	},
+	/**
+	* @description callback function when closed with the message instance as the parameter
+	*/
+	onClose: {
+		type: require_runtime$1.definePropType(Function),
+		default: messageDefaults.onClose
+	},
+	/**
+	* @description whether to show a close button
+	*/
+	showClose: {
+		type: Boolean,
+		default: messageDefaults.showClose
+	},
+	/**
+	* @description message type
+	*/
+	type: {
+		type: String,
+		values: messageTypes,
+		default: messageDefaults.type
+	},
+	/**
+	* @description whether message is plain
+	*/
+	plain: {
+		type: Boolean,
+		default: messageDefaults.plain
+	},
+	/**
+	* @description set the distance to the top of viewport
+	*/
+	offset: {
+		type: Number,
+		default: messageDefaults.offset
+	},
+	/**
+	* @description message placement position
+	*/
+	placement: {
+		type: String,
+		values: messagePlacement,
+		default: messageDefaults.placement
+	},
+	/**
+	* @description message element zIndex value
+	*/
+	zIndex: {
+		type: Number,
+		default: messageDefaults.zIndex
+	},
+	/**
+	* @description merge messages with the same content, type of VNode message is not supported
+	*/
+	grouping: {
+		type: Boolean,
+		default: messageDefaults.grouping
+	},
+	/**
+	* @description The number of repetitions, similar to badge, is used as the initial number when used with `grouping`
+	*/
+	repeatNum: {
+		type: Number,
+		default: messageDefaults.repeatNum
+	}
+});
+const messageEmits = { destroy: () => true };
+//#endregion
+exports.MESSAGE_DEFAULT_PLACEMENT = MESSAGE_DEFAULT_PLACEMENT;
+exports.messageDefaults = messageDefaults;
+exports.messageEmits = messageEmits;
+exports.messagePlacement = messagePlacement;
+exports.messageProps = messageProps;
+exports.messageTypes = messageTypes;
+
+//# sourceMappingURL=message.js.map

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

@@ -0,0 +1,44 @@
+import { IconPropType } from "../../../utils/vue/icon.js";
+import { MessagePlacement, MessageProps, MessageType } from "./message.js";
+import * as _$vue from "vue";
+
+//#region ../../packages/components/message/src/message.vue.d.ts
+declare function close(): void;
+declare var __VLS_27: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_27) => any;
+};
+declare const __VLS_base: _$vue.DefineComponent<MessageProps, {
+  visible: _$vue.Ref<boolean, boolean>;
+  bottom: _$vue.ComputedRef<number>;
+  close: typeof close;
+}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+  destroy: () => void;
+}, string, _$vue.PublicProps, Readonly<MessageProps> & Readonly<{
+  onDestroy?: (() => any) | undefined;
+}>, {
+  type: MessageType;
+  zIndex: number;
+  offset: number;
+  onClose: () => void;
+  duration: number;
+  id: string;
+  icon: IconPropType;
+  placement: MessagePlacement;
+  plain: boolean;
+  message: string | _$vue.VNode | (() => _$vue.VNode);
+  showClose: boolean;
+  customClass: string;
+  dangerouslyUseHTMLString: boolean;
+  grouping: boolean;
+  repeatNum: number;
+}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { _default as default };

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

@@ -0,0 +1,159 @@
+require("../../../_virtual/_rolldown/runtime.js");
+const require_aria = require("../../../constants/aria.js");
+const require_event = require("../../../utils/dom/event.js");
+const require_icon = require("../../../utils/vue/icon.js");
+const require_index = require("../../icon/index.js");
+const require_index$1 = require("../../badge/index.js");
+const require_use_global_config = require("../../config-provider/src/hooks/use-global-config.js");
+const require_message = require("./message.js");
+const require_instance = require("./instance.js");
+let _vueuse_core = require("@vueuse/core");
+let vue = require("vue");
+//#region ../../packages/components/message/src/message.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["id"];
+const _hoisted_2 = ["innerHTML"];
+var message_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	name: "ElMessage",
+	__name: "message",
+	props: require_message.messageProps,
+	emits: require_message.messageEmits,
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const { Close } = require_icon.TypeComponents;
+		const props = __props;
+		const emit = __emit;
+		const isStartTransition = (0, vue.ref)(false);
+		const { ns, zIndex } = require_use_global_config.useGlobalComponentSettings("message");
+		const { currentZIndex, nextZIndex } = zIndex;
+		const messageRef = (0, vue.ref)();
+		const visible = (0, vue.ref)(false);
+		const height = (0, vue.ref)(0);
+		let stopTimer = void 0;
+		const badgeType = (0, vue.computed)(() => props.type ? props.type === "error" ? "danger" : props.type : "info");
+		const typeClass = (0, vue.computed)(() => {
+			const type = props.type;
+			return { [ns.bm("icon", type)]: type && require_icon.TypeComponentsMap[type] };
+		});
+		const iconComponent = (0, vue.computed)(() => props.icon || require_icon.TypeComponentsMap[props.type] || "");
+		const placement = (0, vue.computed)(() => props.placement || "top");
+		const lastOffset = (0, vue.computed)(() => require_instance.getLastOffset(props.id, placement.value));
+		const offset = (0, vue.computed)(() => {
+			return Math.max(require_instance.getOffsetOrSpace(props.id, props.offset, placement.value) + lastOffset.value, props.offset);
+		});
+		const bottom = (0, vue.computed)(() => height.value + offset.value);
+		const horizontalClass = (0, 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 = (0, vue.computed)(() => placement.value.startsWith("top") ? "top" : "bottom");
+		const customStyle = (0, vue.computed)(() => ({
+			[verticalProperty.value]: `${offset.value}px`,
+			zIndex: currentZIndex.value
+		}));
+		function startTimer() {
+			if (props.duration === 0) return;
+			({stop: stopTimer} = (0, _vueuse_core.useTimeoutFn)(() => {
+				close();
+			}, props.duration));
+		}
+		function clearTimer() {
+			stopTimer?.();
+		}
+		function close() {
+			visible.value = false;
+			(0, vue.nextTick)(() => {
+				if (!isStartTransition.value) {
+					props.onClose?.();
+					emit("destroy");
+				}
+			});
+		}
+		function keydown(event) {
+			if (require_event.getEventCode(event) === require_aria.EVENT_CODE.esc) close();
+		}
+		(0, vue.onMounted)(() => {
+			startTimer();
+			nextZIndex();
+			visible.value = true;
+		});
+		(0, vue.watch)(() => props.repeatNum, () => {
+			clearTimer();
+			startTimer();
+		});
+		(0, _vueuse_core.useEventListener)(document, "keydown", keydown);
+		(0, _vueuse_core.useResizeObserver)(messageRef, () => {
+			height.value = messageRef.value.getBoundingClientRect().height;
+		});
+		__expose({
+			visible,
+			bottom,
+			close
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)(vue.Transition, {
+				name: (0, vue.unref)(ns).b("fade"),
+				onBeforeEnter: _cache[0] || (_cache[0] = ($event) => isStartTransition.value = true),
+				onBeforeLeave: __props.onClose,
+				onAfterLeave: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("destroy")),
+				persisted: ""
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.withDirectives)((0, vue.createElementVNode)("div", {
+					id: __props.id,
+					ref_key: "messageRef",
+					ref: messageRef,
+					class: (0, vue.normalizeClass)([
+						(0, vue.unref)(ns).b(),
+						{ [(0, vue.unref)(ns).m(__props.type)]: __props.type },
+						(0, vue.unref)(ns).is("closable", __props.showClose),
+						(0, vue.unref)(ns).is("plain", __props.plain),
+						(0, vue.unref)(ns).is("bottom", verticalProperty.value === "bottom"),
+						horizontalClass.value,
+						__props.customClass
+					]),
+					style: (0, vue.normalizeStyle)(customStyle.value),
+					role: "alert",
+					onMouseenter: clearTimer,
+					onMouseleave: startTimer
+				}, [
+					__props.repeatNum > 1 ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_index$1.ElBadge), {
+						key: 0,
+						value: __props.repeatNum,
+						type: badgeType.value,
+						class: (0, vue.normalizeClass)((0, vue.unref)(ns).e("badge"))
+					}, null, 8, [
+						"value",
+						"type",
+						"class"
+					])) : (0, vue.createCommentVNode)("v-if", true),
+					iconComponent.value ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_index.ElIcon), {
+						key: 1,
+						class: (0, vue.normalizeClass)([(0, vue.unref)(ns).e("icon"), typeClass.value])
+					}, {
+						default: (0, vue.withCtx)(() => [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(iconComponent.value)))]),
+						_: 1
+					}, 8, ["class"])) : (0, vue.createCommentVNode)("v-if", true),
+					!__props.dangerouslyUseHTMLString || _ctx.$slots.default ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("p", {
+						key: 2,
+						class: (0, vue.normalizeClass)((0, vue.unref)(ns).e("content"))
+					}, [(0, vue.renderSlot)(_ctx.$slots, "default", {}, () => [(0, vue.createTextVNode)((0, vue.toDisplayString)(__props.message), 1)])], 2)) : ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 3 }, [(0, vue.createCommentVNode)(" Caution here, message could've been compromised, never use user's input as message "), (0, vue.createElementVNode)("p", {
+						class: (0, vue.normalizeClass)((0, vue.unref)(ns).e("content")),
+						innerHTML: __props.message
+					}, null, 10, _hoisted_2)], 2112)),
+					__props.showClose ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_index.ElIcon), {
+						key: 4,
+						class: (0, vue.normalizeClass)((0, vue.unref)(ns).e("closeBtn")),
+						onClick: (0, vue.withModifiers)(close, ["stop"])
+					}, {
+						default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(Close))]),
+						_: 1
+					}, 8, ["class"])) : (0, vue.createCommentVNode)("v-if", true)
+				], 46, _hoisted_1), [[vue.vShow, visible.value]])]),
+				_: 3
+			}, 8, ["name", "onBeforeLeave"]);
+		};
+	}
+});
+//#endregion
+exports.default = message_vue_vue_type_script_setup_true_lang_default;
+
+//# sourceMappingURL=message.vue_vue_type_script_setup_true_lang.js.map

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

@@ -0,0 +1,10 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region ../../packages/components/message/src/message.vue
+var message_default = require("./message.vue_vue_type_script_setup_true_lang.js").default;
+//#endregion
+exports.default = message_default;
+
+//# sourceMappingURL=message2.js.map

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

@@ -0,0 +1,8 @@
+import { Message, MessagePlacement, MessageType } from "./message.js";
+
+//#region ../../packages/components/message/src/method.d.ts
+declare function closeAll(type?: MessageType): void;
+declare function closeAllByPlacement(placement: MessagePlacement): void;
+declare const _default: Message;
+//#endregion
+export { closeAll, closeAllByPlacement, _default as default };

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

@@ -0,0 +1,133 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../../_virtual/_rolldown/runtime.js");
+const require_types = require("../../../utils/types.js");
+const require_error = require("../../../utils/error.js");
+const require_config_provider = require("../../config-provider/src/config-provider.js");
+const require_message = require("./message.js");
+const require_instance = require("./instance.js");
+const require_message$1 = require("./message2.js");
+let vue = require("vue");
+let _vue_shared = require("@vue/shared");
+let _vueuse_core = require("@vueuse/core");
+//#region ../../packages/components/message/src/method.ts
+let seed = 1;
+const normalizeAppendTo = (normalized) => {
+	if (!normalized.appendTo) normalized.appendTo = document.body;
+	else if ((0, _vue_shared.isString)(normalized.appendTo)) {
+		let appendTo = document.querySelector(normalized.appendTo);
+		if (!require_types.isElement(appendTo)) {
+			require_error.debugWarn("ElMessage", "the appendTo option is not an HTMLElement. Falling back to document.body.");
+			appendTo = document.body;
+		}
+		normalized.appendTo = appendTo;
+	}
+};
+const normalizePlacement = (normalized) => {
+	if (!normalized.placement && (0, _vue_shared.isString)(require_config_provider.messageConfig.placement) && require_config_provider.messageConfig.placement) normalized.placement = require_config_provider.messageConfig.placement;
+	if (!normalized.placement) normalized.placement = "top";
+	if (!require_message.messagePlacement.includes(normalized.placement)) {
+		require_error.debugWarn("ElMessage", `Invalid placement: ${normalized.placement}. Falling back to 'top'.`);
+		normalized.placement = "top";
+	}
+};
+const normalizeOptions = (params) => {
+	const options = !params || (0, _vue_shared.isString)(params) || (0, vue.isVNode)(params) || (0, _vue_shared.isFunction)(params) ? { message: params } : params;
+	const normalized = {
+		...require_message.messageDefaults,
+		...options
+	};
+	normalizeAppendTo(normalized);
+	normalizePlacement(normalized);
+	if (require_types.isBoolean(require_config_provider.messageConfig.grouping) && !normalized.grouping) normalized.grouping = require_config_provider.messageConfig.grouping;
+	if (require_types.isNumber(require_config_provider.messageConfig.duration) && normalized.duration === 3e3) normalized.duration = require_config_provider.messageConfig.duration;
+	if (require_types.isNumber(require_config_provider.messageConfig.offset) && normalized.offset === 16) normalized.offset = require_config_provider.messageConfig.offset;
+	if (require_types.isBoolean(require_config_provider.messageConfig.showClose) && !normalized.showClose) normalized.showClose = require_config_provider.messageConfig.showClose;
+	if (require_types.isBoolean(require_config_provider.messageConfig.plain) && !normalized.plain) normalized.plain = require_config_provider.messageConfig.plain;
+	return normalized;
+};
+const closeMessage = (instance) => {
+	const instances = require_instance.placementInstances[instance.props.placement || "top"];
+	const idx = instances.indexOf(instance);
+	if (idx === -1) return;
+	instances.splice(idx, 1);
+	const { handler } = instance;
+	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?.();
+			closeMessage(instance);
+		},
+		onDestroy: () => {
+			(0, vue.render)(null, container);
+		}
+	};
+	const vnode = (0, vue.createVNode)(require_message$1.default, props, (0, _vue_shared.isFunction)(props.message) || (0, vue.isVNode)(props.message) ? { default: (0, _vue_shared.isFunction)(props.message) ? props.message : () => props.message } : null);
+	vnode.appContext = context || message._context;
+	(0, vue.render)(vnode, container);
+	appendTo.appendChild(container.firstElementChild);
+	const vm = vnode.component;
+	const instance = {
+		id,
+		vnode,
+		vm,
+		handler: { close: () => {
+			vm.exposed.close();
+		} },
+		props: vnode.component.props
+	};
+	return instance;
+};
+const message = (options = {}, context) => {
+	if (!_vueuse_core.isClient) return { close: () => void 0 };
+	const normalized = normalizeOptions(options);
+	const instances = require_instance.getOrCreatePlacementInstances(normalized.placement || "top");
+	if (normalized.grouping && instances.length) {
+		const instance = instances.find(({ vnode: vm }) => vm.props?.message === normalized.message);
+		if (instance) {
+			instance.props.repeatNum += 1;
+			instance.props.type = normalized.type;
+			return instance.handler;
+		}
+	}
+	if (require_types.isNumber(require_config_provider.messageConfig.max) && instances.length >= require_config_provider.messageConfig.max) return { close: () => void 0 };
+	const instance = createMessage(normalized, context);
+	instances.push(instance);
+	return instance.handler;
+};
+require_message.messageTypes.forEach((type) => {
+	message[type] = (options = {}, appContext) => {
+		return message({
+			...normalizeOptions(options),
+			type
+		}, appContext);
+	};
+});
+function closeAll(type) {
+	for (const placement in require_instance.placementInstances) if ((0, _vue_shared.hasOwn)(require_instance.placementInstances, placement)) {
+		const instances = [...require_instance.placementInstances[placement]];
+		for (const instance of instances) if (!type || type === instance.props.type) instance.handler.close();
+	}
+}
+function closeAllByPlacement(placement) {
+	if (!require_instance.placementInstances[placement]) return;
+	[...require_instance.placementInstances[placement]].forEach((instance) => instance.handler.close());
+}
+message.closeAll = closeAll;
+message.closeAllByPlacement = closeAllByPlacement;
+message._context = null;
+//#endregion
+exports.closeAll = closeAll;
+exports.closeAllByPlacement = closeAllByPlacement;
+exports.default = message;
+
+//# sourceMappingURL=method.js.map