完全跑通1.0版本

frontend/node_modules/element-plus/es/components/message-box/index.d.ts

@@ -0,0 +1,8 @@
+import { SFCWithInstall } from "../../utils/vue/typescript.js";
+import { Action, Callback, CloseFn, ElMessageBoxOptions, ElMessageBoxShortcutMethod, IElMessageBox, MessageBoxActionHandlers, MessageBoxData, MessageBoxInputData, MessageBoxInputValidator, MessageBoxState, MessageBoxType } from "./src/message-box.type.js";
+import _default from "./src/messageBox.js";
+//#region ../../packages/components/message-box/index.d.ts
+declare const _MessageBox: SFCWithInstall<typeof _default>;
+declare const ElMessageBox: SFCWithInstall<IElMessageBox>;
+//#endregion
+export { Action, Callback, CloseFn, ElMessageBox, ElMessageBoxOptions, ElMessageBoxShortcutMethod, IElMessageBox, MessageBoxActionHandlers, MessageBoxData, MessageBoxInputData, MessageBoxInputValidator, MessageBoxState, MessageBoxType, _MessageBox as default };

frontend/node_modules/element-plus/es/components/message-box/index.mjs

@@ -0,0 +1,16 @@
+import MessageBox from "./src/messageBox.mjs";
+//#region ../../packages/components/message-box/index.ts
+const _MessageBox = MessageBox;
+_MessageBox.install = (app) => {
+	_MessageBox._context = app._context;
+	app.config.globalProperties.$msgbox = _MessageBox;
+	app.config.globalProperties.$messageBox = _MessageBox;
+	app.config.globalProperties.$alert = _MessageBox.alert;
+	app.config.globalProperties.$confirm = _MessageBox.confirm;
+	app.config.globalProperties.$prompt = _MessageBox.prompt;
+};
+const ElMessageBox = _MessageBox;
+//#endregion
+export { ElMessageBox, _MessageBox as default };
+
+//# sourceMappingURL=index.mjs.map

frontend/node_modules/element-plus/es/components/message-box/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../packages/components/message-box/index.ts"],"sourcesContent":["import MessageBox from './src/messageBox'\n\nimport type { App } from 'vue'\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nconst _MessageBox = MessageBox as SFCWithInstall<typeof MessageBox>\n\n_MessageBox.install = (app: App) => {\n  _MessageBox._context = app._context\n  app.config.globalProperties.$msgbox = _MessageBox\n  app.config.globalProperties.$messageBox = _MessageBox\n  app.config.globalProperties.$alert = _MessageBox.alert\n  app.config.globalProperties.$confirm = _MessageBox.confirm\n  app.config.globalProperties.$prompt = _MessageBox.prompt\n}\n\nexport default _MessageBox\nexport const ElMessageBox = _MessageBox\n\nexport * from './src/message-box.type'\n"],"mappings":";;AAKA,MAAM,cAAc;AAEpB,YAAY,WAAW,QAAa;CAClC,YAAY,WAAW,IAAI;CAC3B,IAAI,OAAO,iBAAiB,UAAU;CACtC,IAAI,OAAO,iBAAiB,cAAc;CAC1C,IAAI,OAAO,iBAAiB,SAAS,YAAY;CACjD,IAAI,OAAO,iBAAiB,WAAW,YAAY;CACnD,IAAI,OAAO,iBAAiB,UAAU,YAAY;;AAIpD,MAAa,eAAe"}

frontend/node_modules/element-plus/es/components/message-box/src/index.mjs

@@ -0,0 +1,184 @@
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.mjs";
+import index_vue_vue_type_script_lang_default from "./index.vue_vue_type_script_lang.mjs";
+import { Transition, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, normalizeClass, normalizeStyle, openBlock, renderSlot, resolveComponent, resolveDynamicComponent, toDisplayString, vShow, withCtx, withDirectives, withKeys, withModifiers } from "vue";
+//#region ../../packages/components/message-box/src/index.vue
+const _hoisted_1 = ["aria-label", "aria-describedby"];
+const _hoisted_2 = ["aria-label"];
+const _hoisted_3 = ["id"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	const _component_el_icon = resolveComponent("el-icon");
+	const _component_el_input = resolveComponent("el-input");
+	const _component_el_button = resolveComponent("el-button");
+	const _component_el_focus_trap = resolveComponent("el-focus-trap");
+	const _component_el_overlay = resolveComponent("el-overlay");
+	return openBlock(), createBlock(Transition, {
+		name: "fade-in-linear",
+		onAfterLeave: _cache[11] || (_cache[11] = ($event) => _ctx.$emit("vanish")),
+		persisted: ""
+	}, {
+		default: withCtx(() => [withDirectives(createVNode(_component_el_overlay, {
+			"z-index": _ctx.zIndex,
+			"overlay-class": [_ctx.ns.is("message-box"), _ctx.modalClass],
+			mask: _ctx.modal
+		}, {
+			default: withCtx(() => [createElementVNode("div", {
+				role: "dialog",
+				"aria-label": _ctx.title,
+				"aria-modal": "true",
+				"aria-describedby": !_ctx.showInput ? _ctx.contentId : void 0,
+				class: normalizeClass(`${_ctx.ns.namespace.value}-overlay-message-box`),
+				onClick: _cache[8] || (_cache[8] = (...args) => _ctx.overlayEvent.onClick && _ctx.overlayEvent.onClick(...args)),
+				onMousedown: _cache[9] || (_cache[9] = (...args) => _ctx.overlayEvent.onMousedown && _ctx.overlayEvent.onMousedown(...args)),
+				onMouseup: _cache[10] || (_cache[10] = (...args) => _ctx.overlayEvent.onMouseup && _ctx.overlayEvent.onMouseup(...args))
+			}, [createVNode(_component_el_focus_trap, {
+				loop: "",
+				trapped: _ctx.visible,
+				"focus-trap-el": _ctx.rootRef,
+				"focus-start-el": _ctx.focusStartRef,
+				onReleaseRequested: _ctx.onCloseRequested
+			}, {
+				default: withCtx(() => [createElementVNode("div", {
+					ref: "rootRef",
+					class: normalizeClass([
+						_ctx.ns.b(),
+						_ctx.customClass,
+						_ctx.ns.is("draggable", _ctx.draggable),
+						_ctx.ns.is("dragging", _ctx.isDragging),
+						{ [_ctx.ns.m("center")]: _ctx.center }
+					]),
+					style: normalizeStyle(_ctx.customStyle),
+					tabindex: "-1",
+					onClick: _cache[7] || (_cache[7] = withModifiers(() => {}, ["stop"]))
+				}, [
+					_ctx.title !== null && _ctx.title !== void 0 ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						ref: "headerRef",
+						class: normalizeClass([_ctx.ns.e("header"), { "show-close": _ctx.showClose }])
+					}, [createElementVNode("div", { class: normalizeClass(_ctx.ns.e("title")) }, [_ctx.iconComponent && _ctx.center ? (openBlock(), createBlock(_component_el_icon, {
+						key: 0,
+						class: normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
+					}, {
+						default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))]),
+						_: 1
+					}, 8, ["class"])) : createCommentVNode("v-if", true), createElementVNode("span", null, toDisplayString(_ctx.title), 1)], 2), _ctx.showClose ? (openBlock(), createElementBlock("button", {
+						key: 0,
+						type: "button",
+						class: normalizeClass(_ctx.ns.e("headerbtn")),
+						"aria-label": _ctx.t("el.messagebox.close"),
+						onClick: _cache[0] || (_cache[0] = ($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel")),
+						onKeydown: _cache[1] || (_cache[1] = withKeys(withModifiers(($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel"), ["prevent"]), ["enter"]))
+					}, [createVNode(_component_el_icon, { class: normalizeClass(_ctx.ns.e("close")) }, {
+						default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.closeIcon || "close")))]),
+						_: 1
+					}, 8, ["class"])], 42, _hoisted_2)) : createCommentVNode("v-if", true)], 2)) : createCommentVNode("v-if", true),
+					createElementVNode("div", {
+						id: _ctx.contentId,
+						class: normalizeClass(_ctx.ns.e("content"))
+					}, [createElementVNode("div", { class: normalizeClass(_ctx.ns.e("container")) }, [_ctx.iconComponent && !_ctx.center && _ctx.hasMessage ? (openBlock(), createBlock(_component_el_icon, {
+						key: 0,
+						class: normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
+					}, {
+						default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))]),
+						_: 1
+					}, 8, ["class"])) : createCommentVNode("v-if", true), _ctx.hasMessage ? (openBlock(), createElementBlock("div", {
+						key: 1,
+						class: normalizeClass(_ctx.ns.e("message"))
+					}, [renderSlot(_ctx.$slots, "default", {}, () => [!_ctx.dangerouslyUseHTMLString ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
+						key: 0,
+						for: _ctx.showInput ? _ctx.inputId : void 0,
+						textContent: toDisplayString(_ctx.message)
+					}, null, 8, ["for", "textContent"])) : (openBlock(), createBlock(resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
+						key: 1,
+						for: _ctx.showInput ? _ctx.inputId : void 0,
+						innerHTML: _ctx.message
+					}, null, 8, ["for", "innerHTML"]))])], 2)) : createCommentVNode("v-if", true)], 2), withDirectives(createElementVNode("div", { class: normalizeClass(_ctx.ns.e("input")) }, [createVNode(_component_el_input, {
+						id: _ctx.inputId,
+						ref: "inputRef",
+						modelValue: _ctx.inputValue,
+						"onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => _ctx.inputValue = $event),
+						type: _ctx.inputType,
+						placeholder: _ctx.inputPlaceholder,
+						"aria-invalid": _ctx.validateError,
+						class: normalizeClass({ invalid: _ctx.validateError }),
+						onKeydown: withKeys(_ctx.handleInputEnter, ["enter"])
+					}, null, 8, [
+						"id",
+						"modelValue",
+						"type",
+						"placeholder",
+						"aria-invalid",
+						"class",
+						"onKeydown"
+					]), createElementVNode("div", {
+						class: normalizeClass(_ctx.ns.e("errormsg")),
+						style: normalizeStyle({ visibility: !!_ctx.editorErrorMessage ? "visible" : "hidden" })
+					}, toDisplayString(_ctx.editorErrorMessage), 7)], 2), [[vShow, _ctx.showInput]])], 10, _hoisted_3),
+					createElementVNode("div", { class: normalizeClass(_ctx.ns.e("btns")) }, [_ctx.showCancelButton ? (openBlock(), createBlock(_component_el_button, {
+						key: 0,
+						type: _ctx.cancelButtonType === "text" ? "" : _ctx.cancelButtonType,
+						text: _ctx.cancelButtonType === "text",
+						loading: _ctx.cancelButtonLoading,
+						"loading-icon": _ctx.cancelButtonLoadingIcon,
+						class: normalizeClass([_ctx.cancelButtonClass]),
+						round: _ctx.roundButton,
+						size: _ctx.btnSize,
+						onClick: _cache[3] || (_cache[3] = ($event) => _ctx.handleAction("cancel")),
+						onKeydown: _cache[4] || (_cache[4] = withKeys(withModifiers(($event) => _ctx.handleAction("cancel"), ["prevent"]), ["enter"]))
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(_ctx.cancelButtonText || _ctx.t("el.messagebox.cancel")), 1)]),
+						_: 1
+					}, 8, [
+						"type",
+						"text",
+						"loading",
+						"loading-icon",
+						"class",
+						"round",
+						"size"
+					])) : createCommentVNode("v-if", true), withDirectives(createVNode(_component_el_button, {
+						ref: "confirmRef",
+						type: _ctx.confirmButtonType === "text" ? "" : _ctx.confirmButtonType,
+						text: _ctx.confirmButtonType === "text",
+						loading: _ctx.confirmButtonLoading,
+						"loading-icon": _ctx.confirmButtonLoadingIcon,
+						class: normalizeClass([_ctx.confirmButtonClasses]),
+						round: _ctx.roundButton,
+						disabled: _ctx.confirmButtonDisabled,
+						size: _ctx.btnSize,
+						onClick: _cache[5] || (_cache[5] = ($event) => _ctx.handleAction("confirm")),
+						onKeydown: _cache[6] || (_cache[6] = withKeys(withModifiers(($event) => _ctx.handleAction("confirm"), ["prevent"]), ["enter"]))
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(_ctx.confirmButtonText || _ctx.t("el.messagebox.confirm")), 1)]),
+						_: 1
+					}, 8, [
+						"type",
+						"text",
+						"loading",
+						"loading-icon",
+						"class",
+						"round",
+						"disabled",
+						"size"
+					]), [[vShow, _ctx.showConfirmButton]])], 2)
+				], 6)]),
+				_: 3
+			}, 8, [
+				"trapped",
+				"focus-trap-el",
+				"focus-start-el",
+				"onReleaseRequested"
+			])], 42, _hoisted_1)]),
+			_: 3
+		}, 8, [
+			"z-index",
+			"overlay-class",
+			"mask"
+		]), [[vShow, _ctx.visible]])]),
+		_: 3
+	});
+}
+var src_default = /* @__PURE__ */ _plugin_vue_export_helper_default(index_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
+//#endregion
+export { src_default as default };
+
+//# sourceMappingURL=index.mjs.map

frontend/node_modules/element-plus/es/components/message-box/src/index.vue_vue_type_script_lang.mjs

@@ -0,0 +1,255 @@
+import { isFunction, isString } from "../../../utils/types.mjs";
+import { TypeComponents, TypeComponentsMap } from "../../../utils/vue/icon.mjs";
+import { isValidComponentSize } from "../../../utils/vue/validator.mjs";
+import { useDraggable } from "../../../hooks/use-draggable/index.mjs";
+import { useLockscreen } from "../../../hooks/use-lockscreen/index.mjs";
+import { useSameTarget } from "../../../hooks/use-same-target/index.mjs";
+import { useId } from "../../../hooks/use-id/index.mjs";
+import { ElIcon } from "../../icon/index.mjs";
+import focus_trap_default from "../../focus-trap/index.mjs";
+import { ElInput } from "../../input/index.mjs";
+import { useGlobalComponentSettings } from "../../config-provider/src/hooks/use-global-config.mjs";
+import { ElButton } from "../../button/index.mjs";
+import TrapFocus from "../../../directives/trap-focus/index.mjs";
+import { ElOverlay } from "../../overlay/index.mjs";
+import { Loading } from "@element-plus/icons-vue";
+import { computed, defineComponent, markRaw, nextTick, onBeforeUnmount, onMounted, reactive, ref, toRefs, watch } from "vue";
+//#region ../../packages/components/message-box/src/index.vue?vue&type=script&lang.ts
+var index_vue_vue_type_script_lang_default = defineComponent({
+	name: "ElMessageBox",
+	directives: { TrapFocus },
+	components: {
+		ElButton,
+		ElFocusTrap: focus_trap_default,
+		ElInput,
+		ElOverlay,
+		ElIcon,
+		...TypeComponents
+	},
+	inheritAttrs: false,
+	props: {
+		buttonSize: {
+			type: String,
+			validator: isValidComponentSize
+		},
+		modal: {
+			type: Boolean,
+			default: true
+		},
+		lockScroll: {
+			type: Boolean,
+			default: true
+		},
+		showClose: {
+			type: Boolean,
+			default: true
+		},
+		closeOnClickModal: {
+			type: Boolean,
+			default: true
+		},
+		closeOnPressEscape: {
+			type: Boolean,
+			default: true
+		},
+		closeOnHashChange: {
+			type: Boolean,
+			default: true
+		},
+		center: Boolean,
+		draggable: Boolean,
+		overflow: Boolean,
+		roundButton: Boolean,
+		container: {
+			type: String,
+			default: "body"
+		},
+		boxType: {
+			type: String,
+			default: ""
+		}
+	},
+	emits: ["vanish", "action"],
+	setup(props, { emit }) {
+		const { locale, zIndex, ns, size: btnSize } = useGlobalComponentSettings("message-box", computed(() => props.buttonSize));
+		const { t } = locale;
+		const { nextZIndex } = zIndex;
+		const visible = ref(false);
+		const state = reactive({
+			autofocus: true,
+			beforeClose: null,
+			callback: null,
+			cancelButtonText: "",
+			cancelButtonClass: "",
+			confirmButtonText: "",
+			confirmButtonClass: "",
+			cancelButtonType: "",
+			confirmButtonType: "primary",
+			customClass: "",
+			customStyle: {},
+			dangerouslyUseHTMLString: false,
+			distinguishCancelAndClose: false,
+			icon: "",
+			closeIcon: "",
+			inputPattern: null,
+			inputPlaceholder: "",
+			inputType: "text",
+			inputValue: "",
+			inputValidator: void 0,
+			inputErrorMessage: "",
+			message: "",
+			modalFade: true,
+			modalClass: "",
+			showCancelButton: false,
+			showConfirmButton: true,
+			type: "",
+			title: void 0,
+			showInput: false,
+			action: "",
+			confirmButtonLoading: false,
+			cancelButtonLoading: false,
+			confirmButtonLoadingIcon: markRaw(Loading),
+			cancelButtonLoadingIcon: markRaw(Loading),
+			confirmButtonDisabled: false,
+			editorErrorMessage: "",
+			validateError: false,
+			zIndex: nextZIndex()
+		});
+		const typeClass = computed(() => {
+			const type = state.type;
+			return { [ns.bm("icon", type)]: type && TypeComponentsMap[type] };
+		});
+		const contentId = useId();
+		const inputId = useId();
+		const iconComponent = computed(() => {
+			const type = state.type;
+			return state.icon || type && TypeComponentsMap[type] || "";
+		});
+		const hasMessage = computed(() => !!state.message);
+		const rootRef = ref();
+		const headerRef = ref();
+		const focusStartRef = ref();
+		const inputRef = ref();
+		const confirmRef = ref();
+		const confirmButtonClasses = computed(() => state.confirmButtonClass);
+		watch(() => state.inputValue, async (val) => {
+			await nextTick();
+			if (props.boxType === "prompt" && val) validate();
+		}, { immediate: true });
+		watch(() => visible.value, (val) => {
+			if (val) {
+				if (props.boxType !== "prompt") if (state.autofocus) focusStartRef.value = confirmRef.value?.$el ?? rootRef.value;
+				else focusStartRef.value = rootRef.value;
+				state.zIndex = nextZIndex();
+			}
+			if (props.boxType !== "prompt") return;
+			if (val) nextTick().then(() => {
+				if (inputRef.value && inputRef.value.$el) if (state.autofocus) focusStartRef.value = getInputElement() ?? rootRef.value;
+				else focusStartRef.value = rootRef.value;
+			});
+			else {
+				state.editorErrorMessage = "";
+				state.validateError = false;
+			}
+		});
+		const { isDragging } = useDraggable(rootRef, headerRef, computed(() => props.draggable), computed(() => props.overflow));
+		onMounted(async () => {
+			await nextTick();
+			if (props.closeOnHashChange) window.addEventListener("hashchange", doClose);
+		});
+		onBeforeUnmount(() => {
+			if (props.closeOnHashChange) window.removeEventListener("hashchange", doClose);
+		});
+		function doClose() {
+			if (!visible.value) return;
+			visible.value = false;
+			nextTick(() => {
+				if (state.action) emit("action", state.action);
+			});
+		}
+		const handleWrapperClick = () => {
+			if (props.closeOnClickModal) handleAction(state.distinguishCancelAndClose ? "close" : "cancel");
+		};
+		const overlayEvent = useSameTarget(handleWrapperClick);
+		const handleInputEnter = (e) => {
+			if (state.inputType !== "textarea" && !inputRef.value?.isComposing) {
+				e.preventDefault();
+				return handleAction("confirm");
+			}
+		};
+		const handleAction = (action) => {
+			if (props.boxType === "prompt" && action === "confirm" && !validate()) return;
+			state.action = action;
+			if (state.beforeClose) state.beforeClose?.(action, state, doClose);
+			else doClose();
+		};
+		const validate = () => {
+			if (props.boxType === "prompt") {
+				const inputPattern = state.inputPattern;
+				if (inputPattern && !inputPattern.test(state.inputValue || "")) {
+					state.editorErrorMessage = state.inputErrorMessage || t("el.messagebox.error");
+					state.validateError = true;
+					return false;
+				}
+				const inputValidator = state.inputValidator;
+				if (isFunction(inputValidator)) {
+					const validateResult = inputValidator(state.inputValue);
+					if (validateResult === false) {
+						state.editorErrorMessage = state.inputErrorMessage || t("el.messagebox.error");
+						state.validateError = true;
+						return false;
+					}
+					if (isString(validateResult)) {
+						state.editorErrorMessage = validateResult;
+						state.validateError = true;
+						return false;
+					}
+				}
+			}
+			state.editorErrorMessage = "";
+			state.validateError = false;
+			return true;
+		};
+		const getInputElement = () => {
+			const inputRefs = inputRef.value?.$refs;
+			return inputRefs?.input ?? inputRefs?.textarea;
+		};
+		const handleClose = () => {
+			handleAction("close");
+		};
+		const onCloseRequested = () => {
+			if (props.closeOnPressEscape) handleClose();
+		};
+		if (props.lockScroll) useLockscreen(visible, { ns });
+		return {
+			...toRefs(state),
+			ns,
+			overlayEvent,
+			visible,
+			hasMessage,
+			typeClass,
+			contentId,
+			inputId,
+			btnSize,
+			iconComponent,
+			confirmButtonClasses,
+			rootRef,
+			focusStartRef,
+			headerRef,
+			inputRef,
+			isDragging,
+			confirmRef,
+			doClose,
+			handleClose,
+			onCloseRequested,
+			handleWrapperClick,
+			handleInputEnter,
+			handleAction,
+			t
+		};
+	}
+});
+//#endregion
+export { index_vue_vue_type_script_lang_default as default };
+
+//# sourceMappingURL=index.vue_vue_type_script_lang.mjs.map

frontend/node_modules/element-plus/es/components/message-box/src/message-box.type.d.ts

@@ -0,0 +1,172 @@
+import { ComponentSize } from "../../../constants/size.js";
+import { CSSProperties as CSSProperties$1 } from "../../../utils/typescript.js";
+import { InputType } from "../../input/src/input.js";
+import { buttonTypes } from "../../button/src/button.js";
+import { AppContext, Component, VNode } from "vue";
+
+//#region ../../packages/components/message-box/src/message-box.type.d.ts
+type MessageType = '' | 'primary' | 'success' | 'warning' | 'info' | 'error';
+type MessageBoxButtonType = (typeof buttonTypes)[number];
+type Action = 'confirm' | 'close' | 'cancel';
+type MessageBoxType = '' | 'prompt' | 'alert' | 'confirm';
+type MessageBoxData = MessageBoxInputData & Action;
+interface MessageBoxInputData {
+  value: string;
+  action: Action;
+}
+type MessageBoxInputValidator = ((value: string) => boolean | string) | undefined;
+type CloseFn = () => void;
+interface MessageBoxActionHandlers {
+  confirm: CloseFn;
+  cancel: CloseFn;
+  close: CloseFn;
+}
+declare interface MessageBoxState {
+  autofocus: boolean;
+  title: string | undefined;
+  message: string;
+  type: MessageType;
+  icon: string | Component;
+  closeIcon: string | Component;
+  customClass: string;
+  customStyle: CSSProperties$1;
+  showInput: boolean;
+  inputValue: string;
+  inputPlaceholder: string;
+  inputType: InputType;
+  inputPattern: RegExp | null;
+  inputValidator: MessageBoxInputValidator;
+  inputErrorMessage: string;
+  showConfirmButton: boolean;
+  showCancelButton: boolean;
+  action: Action;
+  dangerouslyUseHTMLString: boolean;
+  confirmButtonText: string;
+  cancelButtonText: string;
+  confirmButtonType: MessageBoxButtonType;
+  cancelButtonType: MessageBoxButtonType;
+  confirmButtonLoading: boolean;
+  cancelButtonLoading: boolean;
+  confirmButtonLoadingIcon: string | Component;
+  cancelButtonLoadingIcon: string | Component;
+  confirmButtonClass: string;
+  confirmButtonDisabled: boolean;
+  cancelButtonClass: string;
+  editorErrorMessage: string;
+  beforeClose: null | ((action: Action, instance: MessageBoxState, done: () => void) => void);
+  callback: null | Callback;
+  distinguishCancelAndClose: boolean;
+  modalFade: boolean;
+  modalClass: string;
+  validateError: boolean;
+  zIndex: number;
+}
+type Callback = ((value: string, action: Action) => any) | ((action: Action) => any);
+/** Options used in MessageBox */
+interface ElMessageBoxOptions {
+  /**
+   * auto focus when open message-box
+   */
+  autofocus?: boolean;
+  /** Callback before MessageBox closes, and it will prevent MessageBox from closing */
+  beforeClose?: (action: Action, instance: MessageBoxState, done: () => void) => void;
+  /** Custom class name for MessageBox */
+  customClass?: string;
+  /** Custom inline style for MessageBox */
+  customStyle?: CSSProperties$1;
+  /** Whether a mask is displayed */
+  modal?: boolean;
+  /** modal class name for MessageBox */
+  modalClass?: string;
+  /** MessageBox closing callback if you don't prefer Promise */
+  callback?: Callback;
+  /** Text content of cancel button */
+  cancelButtonText?: string;
+  /** Text content of confirm button */
+  confirmButtonText?: string;
+  /** Type of cancel button */
+  cancelButtonType?: MessageBoxButtonType;
+  /** Type of confirm button */
+  confirmButtonType?: MessageBoxButtonType;
+  /** Loading Icon content of cancel button */
+  cancelButtonLoadingIcon?: string | Component;
+  /** Loading Icon content of confirm button */
+  confirmButtonLoadingIcon?: string | Component;
+  /** Custom class name of cancel button */
+  cancelButtonClass?: string;
+  /** Custom class name of confirm button */
+  confirmButtonClass?: string;
+  /** Whether to align the content in center */
+  center?: boolean;
+  /** Whether MessageBox can be drag */
+  draggable?: boolean;
+  /** Draggable MessageBox can overflow the viewport */
+  overflow?: boolean;
+  /** Content of the MessageBox */
+  message?: string | VNode | ((params: MessageBoxActionHandlers) => VNode);
+  /** Title of the MessageBox */
+  title?: string | ElMessageBoxOptions;
+  /** Message type, used for icon display */
+  type?: MessageType;
+  /** Message box type */
+  boxType?: MessageBoxType;
+  /** Custom icon component */
+  icon?: string | Component;
+  /** Custom close icon component */
+  closeIcon?: string | Component;
+  /** Whether message is treated as HTML string */
+  dangerouslyUseHTMLString?: boolean;
+  /** Whether to distinguish canceling and closing */
+  distinguishCancelAndClose?: boolean;
+  /** Whether to lock body scroll when MessageBox prompts */
+  lockScroll?: boolean;
+  /** Whether to show a cancel button */
+  showCancelButton?: boolean;
+  /** Whether to show a confirm button */
+  showConfirmButton?: boolean;
+  /** Whether to show a close button */
+  showClose?: boolean;
+  /** Whether to use round button */
+  roundButton?: boolean;
+  /** Whether MessageBox can be closed by clicking the mask */
+  closeOnClickModal?: boolean;
+  /** Whether MessageBox can be closed by pressing the ESC */
+  closeOnPressEscape?: boolean;
+  /** Whether to close MessageBox when hash changes */
+  closeOnHashChange?: boolean;
+  /** Whether to show an input */
+  showInput?: boolean;
+  /** Placeholder of input */
+  inputPlaceholder?: string;
+  /** Initial value of input */
+  inputValue?: string;
+  /** Regexp for the input */
+  inputPattern?: RegExp;
+  /** type of input, see more in [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types) */
+  inputType?: InputType;
+  /** Validation function for the input. Should returns a boolean or string. If a string is returned, it will be assigned to inputErrorMessage */
+  inputValidator?: MessageBoxInputValidator;
+  /** Error message when validation fails */
+  inputErrorMessage?: string;
+  /** Custom size of confirm and cancel buttons */
+  buttonSize?: ComponentSize;
+  /** Custom element to append the message box to */
+  appendTo?: HTMLElement | string;
+}
+type ElMessageBoxShortcutMethod = ((message: ElMessageBoxOptions['message'], options?: ElMessageBoxOptions, appContext?: AppContext | null) => Promise<MessageBoxData>) & ((message: ElMessageBoxOptions['message'], title: ElMessageBoxOptions['title'], options?: ElMessageBoxOptions, appContext?: AppContext | null) => Promise<MessageBoxData>);
+interface IElMessageBox {
+  _context: AppContext | null;
+  /** Show a message box */
+  /** Show a message box */
+  (options: ElMessageBoxOptions, appContext?: AppContext | null): Promise<MessageBoxData>;
+  /** Show an alert message box */
+  alert: ElMessageBoxShortcutMethod;
+  /** Show a confirm message box */
+  confirm: ElMessageBoxShortcutMethod;
+  /** Show a prompt message box */
+  prompt: ElMessageBoxShortcutMethod;
+  /** Close current message box */
+  close: CloseFn;
+}
+//#endregion
+export { Action, Callback, CloseFn, ElMessageBoxOptions, ElMessageBoxShortcutMethod, IElMessageBox, MessageBoxActionHandlers, MessageBoxData, MessageBoxInputData, MessageBoxInputValidator, MessageBoxState, MessageBoxType };

frontend/node_modules/element-plus/es/components/message-box/src/messageBox.d.ts

@@ -0,0 +1,6 @@
+import { IElMessageBox } from "./message-box.type.js";
+
+//#region ../../packages/components/message-box/src/messageBox.d.ts
+declare const _default: IElMessageBox;
+//#endregion
+export { _default as default };

frontend/node_modules/element-plus/es/components/message-box/src/messageBox.mjs

@@ -0,0 +1,125 @@
+import { isClient } from "../../../utils/browser.mjs";
+import { isElement, isFunction, isObject, isString, isUndefined } from "../../../utils/types.mjs";
+import { hasOwn } from "../../../utils/objects.mjs";
+import { debugWarn } from "../../../utils/error.mjs";
+import src_default from "./index.mjs";
+import { createVNode, isVNode, markRaw, render } from "vue";
+//#region ../../packages/components/message-box/src/messageBox.ts
+const messageInstance = /* @__PURE__ */ new Map();
+const getAppendToElement = (props) => {
+	let appendTo = document.body;
+	if (props.appendTo) {
+		if (isString(props.appendTo)) appendTo = document.querySelector(props.appendTo);
+		if (isElement(props.appendTo)) appendTo = props.appendTo;
+		if (!isElement(appendTo)) {
+			debugWarn("ElMessageBox", "the appendTo option is not an HTMLElement. Falling back to document.body.");
+			appendTo = document.body;
+		}
+	}
+	return appendTo;
+};
+const handleAction = (vnode, action) => {
+	const vm = vnode.component?.proxy;
+	return () => vm.handleAction(action);
+};
+const initInstance = (props, container, appContext = null) => {
+	const vnode = createVNode(src_default, props, isFunction(props.message) || isVNode(props.message) ? { default: isFunction(props.message) ? () => props.message({
+		confirm: handleAction(vnode, "confirm"),
+		cancel: handleAction(vnode, "cancel"),
+		close: handleAction(vnode, "close")
+	}) : () => props.message } : null);
+	vnode.appContext = appContext;
+	render(vnode, container);
+	getAppendToElement(props).appendChild(container.firstElementChild);
+	return vnode.component;
+};
+const genContainer = () => {
+	return document.createElement("div");
+};
+const showMessage = (options, appContext) => {
+	const container = genContainer();
+	options.onVanish = () => {
+		render(null, container);
+		messageInstance.delete(vm);
+	};
+	options.onAction = (action) => {
+		const currentMsg = messageInstance.get(vm);
+		let resolve;
+		if (options.showInput) resolve = {
+			value: vm.inputValue,
+			action
+		};
+		else resolve = action;
+		if (options.callback) options.callback(resolve, instance.proxy);
+		else if (action === "cancel" || action === "close") if (options.distinguishCancelAndClose && action !== "cancel") currentMsg.reject("close");
+		else currentMsg.reject("cancel");
+		else currentMsg.resolve(resolve);
+	};
+	const instance = initInstance(options, container, appContext);
+	const vm = instance.proxy;
+	for (const prop in options) if (hasOwn(options, prop) && !hasOwn(vm.$props, prop)) if (prop === "closeIcon" && isObject(options[prop])) vm[prop] = markRaw(options[prop]);
+	else vm[prop] = options[prop];
+	vm.visible = true;
+	return vm;
+};
+function MessageBox(options, appContext = null) {
+	if (!isClient) return Promise.reject();
+	let callback;
+	if (isString(options) || isVNode(options)) options = { message: options };
+	else callback = options.callback;
+	return new Promise((resolve, reject) => {
+		const vm = showMessage(options, appContext ?? MessageBox._context);
+		messageInstance.set(vm, {
+			options,
+			callback,
+			resolve,
+			reject
+		});
+	});
+}
+const MESSAGE_BOX_VARIANTS = [
+	"alert",
+	"confirm",
+	"prompt"
+];
+const MESSAGE_BOX_DEFAULT_OPTS = {
+	alert: {
+		closeOnPressEscape: false,
+		closeOnClickModal: false
+	},
+	confirm: { showCancelButton: true },
+	prompt: {
+		showCancelButton: true,
+		showInput: true
+	}
+};
+MESSAGE_BOX_VARIANTS.forEach((boxType) => {
+	MessageBox[boxType] = messageBoxFactory(boxType);
+});
+function messageBoxFactory(boxType) {
+	return (message, title, options, appContext) => {
+		let titleOrOpts = "";
+		if (isObject(title)) {
+			options = title;
+			titleOrOpts = "";
+		} else if (isUndefined(title)) titleOrOpts = "";
+		else titleOrOpts = title;
+		return MessageBox(Object.assign({
+			title: titleOrOpts,
+			message,
+			type: "",
+			...MESSAGE_BOX_DEFAULT_OPTS[boxType]
+		}, options, { boxType }), appContext);
+	};
+}
+MessageBox.close = () => {
+	messageInstance.forEach((_, vm) => {
+		vm.doClose();
+	});
+	messageInstance.clear();
+};
+MessageBox._context = null;
+//#endregion
+export { MessageBox as default };
+
+//# sourceMappingURL=messageBox.mjs.map

frontend/node_modules/element-plus/es/components/message-box/style/css.mjs

@@ -0,0 +1,5 @@
+import "../../base/style/css.mjs";
+import "../../input/style/css.mjs";
+import "../../button/style/css.mjs";
+import "../../overlay/style/css.mjs";
+import "element-plus/theme-chalk/el-message-box.css";

frontend/node_modules/element-plus/es/components/message-box/style/index.mjs

@@ -0,0 +1,5 @@
+import "../../base/style/index.mjs";
+import "../../input/style/index.mjs";
+import "../../button/style/index.mjs";
+import "../../overlay/style/index.mjs";
+import "element-plus/theme-chalk/src/message-box.scss";