测试

frontend/node_modules/element-plus/lib/components/dialog/index.d.ts

@@ -0,0 +1,7 @@
+import Dialog from './src/dialog.vue';
+import type { SFCWithInstall } from 'element-plus/es/utils';
+export declare const ElDialog: SFCWithInstall<typeof Dialog>;
+export default ElDialog;
+export * from './src/use-dialog';
+export * from './src/dialog';
+export * from './src/constants';

frontend/node_modules/element-plus/lib/components/dialog/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dialog$1 = require('./src/dialog2.js');
+var useDialog = require('./src/use-dialog.js');
+var dialog = require('./src/dialog.js');
+var constants = require('./src/constants.js');
+var install = require('../../utils/vue/install.js');
+
+const ElDialog = install.withInstall(dialog$1["default"]);
+
+exports.useDialog = useDialog.useDialog;
+exports.dialogContextKey = dialog.dialogContextKey;
+exports.dialogEmits = dialog.dialogEmits;
+exports.dialogProps = dialog.dialogProps;
+exports.DEFAULT_DIALOG_TRANSITION = constants.DEFAULT_DIALOG_TRANSITION;
+exports.dialogInjectionKey = constants.dialogInjectionKey;
+exports.ElDialog = ElDialog;
+exports["default"] = ElDialog;
+//# sourceMappingURL=index.js.map

frontend/node_modules/element-plus/lib/components/dialog/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../packages/components/dialog/index.ts"],"sourcesContent":["import { withInstall } from '@element-plus/utils'\nimport Dialog from './src/dialog.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElDialog: SFCWithInstall<typeof Dialog> = withInstall(Dialog)\nexport default ElDialog\n\nexport * from './src/use-dialog'\nexport * from './src/dialog'\nexport * from './src/constants'\n"],"names":["withInstall","Dialog"],"mappings":";;;;;;;;;;AAEY,MAAC,QAAQ,GAAGA,mBAAW,CAACC,mBAAM;;;;;;;;;;;"}

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

@@ -0,0 +1,12 @@
+import type { CSSProperties, ComputedRef, InjectionKey, Ref } from 'vue';
+import type { UseNamespaceReturn } from 'element-plus/es/hooks';
+export type DialogContext = {
+    dialogRef: Ref<HTMLElement | undefined>;
+    headerRef: Ref<HTMLElement | undefined>;
+    bodyId: Ref<string>;
+    ns: UseNamespaceReturn;
+    rendered: Ref<boolean>;
+    style: ComputedRef<CSSProperties>;
+};
+export declare const dialogInjectionKey: InjectionKey<DialogContext>;
+export declare const DEFAULT_DIALOG_TRANSITION = "dialog-fade";

frontend/node_modules/element-plus/lib/components/dialog/src/constants.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const dialogInjectionKey = Symbol("dialogInjectionKey");
+const DEFAULT_DIALOG_TRANSITION = "dialog-fade";
+
+exports.DEFAULT_DIALOG_TRANSITION = DEFAULT_DIALOG_TRANSITION;
+exports.dialogInjectionKey = dialogInjectionKey;
+//# sourceMappingURL=constants.js.map

frontend/node_modules/element-plus/lib/components/dialog/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../../../packages/components/dialog/src/constants.ts"],"sourcesContent":["import type { CSSProperties, ComputedRef, InjectionKey, Ref } from 'vue'\nimport type { UseNamespaceReturn } from '@element-plus/hooks'\n\nexport type DialogContext = {\n  dialogRef: Ref<HTMLElement | undefined>\n  headerRef: Ref<HTMLElement | undefined>\n  bodyId: Ref<string>\n  ns: UseNamespaceReturn\n  rendered: Ref<boolean>\n  style: ComputedRef<CSSProperties>\n}\n\nexport const dialogInjectionKey: InjectionKey<DialogContext> =\n  Symbol('dialogInjectionKey')\n\nexport const DEFAULT_DIALOG_TRANSITION = 'dialog-fade'\n"],"names":[],"mappings":";;;;AAAY,MAAC,kBAAkB,GAAG,MAAM,CAAC,oBAAoB,EAAE;AACnD,MAAC,yBAAyB,GAAG;;;;;"}

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

@@ -0,0 +1,22 @@
+export declare const dialogContentProps: {
+    readonly center: BooleanConstructor;
+    readonly alignCenter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly closeIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly draggable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly overflow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly fullscreen: BooleanConstructor;
+    readonly headerClass: StringConstructor;
+    readonly bodyClass: StringConstructor;
+    readonly footerClass: StringConstructor;
+    readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+};
+export declare const dialogContentEmits: {
+    close: () => boolean;
+};

frontend/node_modules/element-plus/lib/components/dialog/src/dialog-content.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('../../../utils/vue/props/runtime.js');
+var icon = require('../../../utils/vue/icon.js');
+
+const dialogContentProps = runtime.buildProps({
+  center: Boolean,
+  alignCenter: {
+    type: Boolean,
+    default: void 0
+  },
+  closeIcon: {
+    type: icon.iconPropType
+  },
+  draggable: {
+    type: Boolean,
+    default: void 0
+  },
+  overflow: {
+    type: Boolean,
+    default: void 0
+  },
+  fullscreen: Boolean,
+  headerClass: String,
+  bodyClass: String,
+  footerClass: String,
+  showClose: {
+    type: Boolean,
+    default: true
+  },
+  title: {
+    type: String,
+    default: ""
+  },
+  ariaLevel: {
+    type: String,
+    default: "2"
+  }
+});
+const dialogContentEmits = {
+  close: () => true
+};
+
+exports.dialogContentEmits = dialogContentEmits;
+exports.dialogContentProps = dialogContentProps;
+//# sourceMappingURL=dialog-content.js.map

frontend/node_modules/element-plus/lib/components/dialog/src/dialog-content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog-content.js","sources":["../../../../../../packages/components/dialog/src/dialog-content.ts"],"sourcesContent":["import { buildProps, iconPropType } from '@element-plus/utils'\n\nexport const dialogContentProps = buildProps({\n  /**\n   * @description whether to align the header and footer in center\n   */\n  center: Boolean,\n  /**\n   * @description whether to align the dialog both horizontally and vertically\n   */\n  alignCenter: {\n    type: Boolean,\n    default: undefined,\n  },\n  /**\n   * @description custom close icon, default is Close\n   */\n  closeIcon: {\n    type: iconPropType,\n  },\n  /**\n   * @description enable dragging feature for Dialog\n   */\n  draggable: {\n    type: Boolean,\n    default: undefined,\n  },\n  /**\n   * @description draggable Dialog can overflow the viewport\n   */\n  overflow: {\n    type: Boolean,\n    default: undefined,\n  },\n  /**\n   * @description whether the Dialog takes up full screen\n   */\n  fullscreen: Boolean,\n  /**\n   * @description custom class names for header wrapper\n   */\n  headerClass: String,\n  /**\n   * @description custom class names for body wrapper\n   */\n  bodyClass: String,\n  /**\n   * @description custom class names for footer wrapper\n   */\n  footerClass: String,\n  /**\n   * @description whether to show a close button\n   */\n  showClose: {\n    type: Boolean,\n    default: true,\n  },\n  /**\n   * @description title of Dialog. Can also be passed with a named slot (see the following table)\n   */\n  title: {\n    type: String,\n    default: '',\n  },\n  /**\n   * @description header's aria-level attribute\n   */\n  ariaLevel: {\n    type: String,\n    default: '2',\n  },\n} as const)\n\nexport const dialogContentEmits = {\n  close: () => true,\n}\n"],"names":["buildProps","iconPropType"],"mappings":";;;;;;;AACY,MAAC,kBAAkB,GAAGA,kBAAU,CAAC;AAC7C,EAAE,MAAM,EAAE,OAAO;AACjB,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,KAAK,CAAC;AACnB,GAAG;AACH,EAAE,SAAS,EAAE;AACb,IAAI,IAAI,EAAEC,iBAAY;AACtB,GAAG;AACH,EAAE,SAAS,EAAE;AACb,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,KAAK,CAAC;AACnB,GAAG;AACH,EAAE,QAAQ,EAAE;AACZ,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,KAAK,CAAC;AACnB,GAAG;AACH,EAAE,UAAU,EAAE,OAAO;AACrB,EAAE,WAAW,EAAE,MAAM;AACrB,EAAE,SAAS,EAAE,MAAM;AACnB,EAAE,WAAW,EAAE,MAAM;AACrB,EAAE,SAAS,EAAE;AACb,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,KAAK,EAAE;AACT,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,EAAE,SAAS,EAAE;AACb,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,OAAO,EAAE,GAAG;AAChB,GAAG;AACH,CAAC,EAAE;AACS,MAAC,kBAAkB,GAAG;AAClC,EAAE,KAAK,EAAE,MAAM,IAAI;AACnB;;;;;"}

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

@@ -0,0 +1,65 @@
+declare function __VLS_template(): {
+    header?(_: {}): any;
+    default?(_: {}): any;
+    footer?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly center: BooleanConstructor;
+    readonly alignCenter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly closeIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly draggable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly overflow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly fullscreen: BooleanConstructor;
+    readonly headerClass: StringConstructor;
+    readonly bodyClass: StringConstructor;
+    readonly footerClass: StringConstructor;
+    readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+}, {
+    resetPosition: () => void;
+    updatePosition: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly center: BooleanConstructor;
+    readonly alignCenter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly closeIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly draggable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly overflow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly fullscreen: BooleanConstructor;
+    readonly headerClass: StringConstructor;
+    readonly bodyClass: StringConstructor;
+    readonly footerClass: StringConstructor;
+    readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+}>> & {
+    onClose?: (() => any) | undefined;
+}, {
+    readonly title: string;
+    readonly center: boolean;
+    readonly overflow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly ariaLevel: string;
+    readonly alignCenter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly draggable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showClose: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly fullscreen: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

frontend/node_modules/element-plus/lib/components/dialog/src/dialog-content2.js

@@ -0,0 +1,98 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index$2 = require('../../icon/index.js');
+var constants = require('./constants.js');
+var dialogContent = require('./dialog-content.js');
+var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+var tokens = require('../../focus-trap/src/tokens.js');
+var index$1 = require('../../../hooks/use-draggable/index.js');
+var icon = require('../../../utils/vue/icon.js');
+var refs = require('../../../utils/vue/refs.js');
+var index = require('../../../hooks/use-locale/index.js');
+
+const __default__ = vue.defineComponent({ name: "ElDialogContent" });
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: dialogContent.dialogContentProps,
+  emits: dialogContent.dialogContentEmits,
+  setup(__props, { expose }) {
+    const props = __props;
+    const { t } = index.useLocale();
+    const { Close } = icon.CloseComponents;
+    const { dialogRef, headerRef, bodyId, ns, style } = vue.inject(constants.dialogInjectionKey);
+    const { focusTrapRef } = vue.inject(tokens.FOCUS_TRAP_INJECTION_KEY);
+    const composedDialogRef = refs.composeRefs(focusTrapRef, dialogRef);
+    const draggable = vue.computed(() => !!props.draggable);
+    const overflow = vue.computed(() => !!props.overflow);
+    const { resetPosition, updatePosition, isDragging } = index$1.useDraggable(dialogRef, headerRef, draggable, overflow);
+    const dialogKls = vue.computed(() => [
+      ns.b(),
+      ns.is("fullscreen", props.fullscreen),
+      ns.is("draggable", draggable.value),
+      ns.is("dragging", isDragging.value),
+      ns.is("align-center", !!props.alignCenter),
+      { [ns.m("center")]: props.center }
+    ]);
+    expose({
+      resetPosition,
+      updatePosition
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        ref: vue.unref(composedDialogRef),
+        class: vue.normalizeClass(vue.unref(dialogKls)),
+        style: vue.normalizeStyle(vue.unref(style)),
+        tabindex: "-1"
+      }, [
+        vue.createElementVNode("header", {
+          ref_key: "headerRef",
+          ref: headerRef,
+          class: vue.normalizeClass([vue.unref(ns).e("header"), _ctx.headerClass, { "show-close": _ctx.showClose }])
+        }, [
+          vue.renderSlot(_ctx.$slots, "header", {}, () => [
+            vue.createElementVNode("span", {
+              role: "heading",
+              "aria-level": _ctx.ariaLevel,
+              class: vue.normalizeClass(vue.unref(ns).e("title"))
+            }, vue.toDisplayString(_ctx.title), 11, ["aria-level"])
+          ]),
+          _ctx.showClose ? (vue.openBlock(), vue.createElementBlock("button", {
+            key: 0,
+            "aria-label": vue.unref(t)("el.dialog.close"),
+            class: vue.normalizeClass(vue.unref(ns).e("headerbtn")),
+            type: "button",
+            onClick: ($event) => _ctx.$emit("close")
+          }, [
+            vue.createVNode(vue.unref(index$2.ElIcon), {
+              class: vue.normalizeClass(vue.unref(ns).e("close"))
+            }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.closeIcon || vue.unref(Close))))
+              ]),
+              _: 1
+            }, 8, ["class"])
+          ], 10, ["aria-label", "onClick"])) : vue.createCommentVNode("v-if", true)
+        ], 2),
+        vue.createElementVNode("div", {
+          id: vue.unref(bodyId),
+          class: vue.normalizeClass([vue.unref(ns).e("body"), _ctx.bodyClass])
+        }, [
+          vue.renderSlot(_ctx.$slots, "default")
+        ], 10, ["id"]),
+        _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("footer", {
+          key: 0,
+          class: vue.normalizeClass([vue.unref(ns).e("footer"), _ctx.footerClass])
+        }, [
+          vue.renderSlot(_ctx.$slots, "footer")
+        ], 2)) : vue.createCommentVNode("v-if", true)
+      ], 6);
+    };
+  }
+});
+var ElDialogContent = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "dialog-content.vue"]]);
+
+exports["default"] = ElDialogContent;
+//# sourceMappingURL=dialog-content2.js.map

frontend/node_modules/element-plus/lib/components/dialog/src/dialog-content2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog-content2.js","sources":["../../../../../../packages/components/dialog/src/dialog-content.vue"],"sourcesContent":["<template>\n  <div :ref=\"composedDialogRef\" :class=\"dialogKls\" :style=\"style\" tabindex=\"-1\">\n    <header\n      ref=\"headerRef\"\n      :class=\"[ns.e('header'), headerClass, { 'show-close': showClose }]\"\n    >\n      <slot name=\"header\">\n        <span role=\"heading\" :aria-level=\"ariaLevel\" :class=\"ns.e('title')\">\n          {{ title }}\n        </span>\n      </slot>\n      <button\n        v-if=\"showClose\"\n        :aria-label=\"t('el.dialog.close')\"\n        :class=\"ns.e('headerbtn')\"\n        type=\"button\"\n        @click=\"$emit('close')\"\n      >\n        <el-icon :class=\"ns.e('close')\">\n          <component :is=\"closeIcon || Close\" />\n        </el-icon>\n      </button>\n    </header>\n    <div :id=\"bodyId\" :class=\"[ns.e('body'), bodyClass]\">\n      <slot />\n    </div>\n    <footer v-if=\"$slots.footer\" :class=\"[ns.e('footer'), footerClass]\">\n      <slot name=\"footer\" />\n    </footer>\n  </div>\n</template>\n\n<script lang=\"ts\" setup>\nimport { computed, inject } from 'vue'\nimport { ElIcon } from '@element-plus/components/icon'\nimport { FOCUS_TRAP_INJECTION_KEY } from '@element-plus/components/focus-trap'\nimport { useDraggable, useLocale } from '@element-plus/hooks'\nimport { CloseComponents, composeRefs } from '@element-plus/utils'\nimport { dialogInjectionKey } from './constants'\nimport { dialogContentEmits, dialogContentProps } from './dialog-content'\n\nconst { t } = useLocale()\nconst { Close } = CloseComponents\n\ndefineOptions({ name: 'ElDialogContent' })\nconst props = defineProps(dialogContentProps)\ndefineEmits(dialogContentEmits)\n\nconst { dialogRef, headerRef, bodyId, ns, style } = inject(dialogInjectionKey)!\nconst { focusTrapRef } = inject(FOCUS_TRAP_INJECTION_KEY)!\n\nconst composedDialogRef = composeRefs(focusTrapRef, dialogRef)\n\nconst draggable = computed(() => !!props.draggable)\nconst overflow = computed(() => !!props.overflow)\nconst { resetPosition, updatePosition, isDragging } = useDraggable(\n  dialogRef,\n  headerRef,\n  draggable,\n  overflow\n)\n\nconst dialogKls = computed(() => [\n  ns.b(),\n  ns.is('fullscreen', props.fullscreen),\n  ns.is('draggable', draggable.value),\n  ns.is('dragging', isDragging.value),\n  ns.is('align-center', !!props.alignCenter),\n  { [ns.m('center')]: props.center },\n])\n\ndefineExpose({\n  resetPosition,\n  updatePosition,\n})\n</script>\n"],"names":["useLocale","CloseComponents","inject","dialogInjectionKey","FOCUS_TRAP_INJECTION_KEY","composeRefs","computed","useDraggable","_openBlock","_createElementBlock","_unref","_normalizeClass","_normalizeStyle"],"mappings":";;;;;;;;;;;;;;;uCA4Cc,CAAA,EAAE,IAAM,EAAA,iBAAA,EAAkB,CAAA,CAAA;;;;;;;AAHxC,IAAM,MAAA,EAAE,CAAE,EAAA,GAAIA,eAAU,EAAA,CAAA;AACxB,IAAM,MAAA,EAAE,OAAU,GAAAC,oBAAA,CAAA;AAMlB,IAAM,MAAA,EAAE,WAAW,SAAW,EAAA,MAAA,EAAQ,IAAI,KAAM,EAAA,GAAIC,WAAOC,4BAAkB,CAAA,CAAA;AAC7E,IAAA,MAAM,EAAE,YAAA,EAAiB,GAAAD,UAAA,CAAOE,+BAAwB,CAAA,CAAA;AAExD,IAAM,MAAA,iBAAA,GAAoBC,gBAAY,CAAA,YAAA,EAAc,SAAS,CAAA,CAAA;AAE7D,IAAA,MAAM,YAAYC,YAAS,CAAA,MAAM,CAAC,CAAC,MAAM,SAAS,CAAA,CAAA;AAClD,IAAA,MAAM,WAAWA,YAAS,CAAA,MAAM,CAAC,CAAC,MAAM,QAAQ,CAAA,CAAA;AAChD,IAAA,MAAM,EAAE,aAAA,EAAe,cAAgB,EAAA,UAAA,EAAe,GAAAC,oBAAA,CAAA,SAAA,EAAA,SAAA,EAAA,SAAA,EAAA,QAAA,CAAA,CAAA;AAAA,IACpD,MAAA,SAAA,GAAAD,YAAA,CAAA,MAAA;AAAA,MACA,EAAA,CAAA,CAAA,EAAA;AAAA,MACA,EAAA,CAAA,EAAA,CAAA,YAAA,EAAA,KAAA,CAAA,UAAA,CAAA;AAAA,MACA,EAAA,CAAA,EAAA,CAAA,WAAA,EAAA,SAAA,CAAA,KAAA,CAAA;AAAA,MACF,EAAA,CAAA,EAAA,CAAA,UAAA,EAAA,UAAA,CAAA,KAAA,CAAA;AAEA,MAAM,EAAA,CAAA,EAAA,CAAA,uBAA2B,CAAA,WAAA,CAAA;AAAA,MAC/B,GAAG,EAAE,CAAA,CAAA,CAAA,QAAA,CAAA,GAAA,KAAA,CAAA,MAAA,EAAA;AAAA,KAAA,CACL,CAAG;AAAiC,IAAA,MACjC,CAAA;AAA+B,MAClC,aAAkB;AAAgB,MAClC,cAAM;AAAmC,KACzC,CAAA,CAAA;AAAiC,IACnC,OAAC,CAAA,IAAA,EAAA,MAAA,KAAA;AAED,MAAa,OAAAE,aAAA,EAAA,EAAAC,sBAAA,CAAA,KAAA,EAAA;AAAA,QACX,GAAA,EAAAC,SAAA,CAAA,iBAAA,CAAA;AAAA,QACA,KAAA,EAAAC,kBAAA,CAAAD,SAAA,CAAA,SAAA,CAAA,CAAA;AAAA,QACD,KAAA,EAAAE,kBAAA,CAAAF,SAAA,CAAA,KAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,84 @@
+import type { ExtractPropTypes, InjectionKey, TransitionProps, __ExtractPublicPropTypes } from 'vue';
+import type Dialog from './dialog.vue';
+type DoneFn = (cancel?: boolean) => void;
+export type DialogBeforeCloseFn = (done: DoneFn) => void;
+export type DialogTransition = string | TransitionProps;
+export declare const dialogProps: {
+    readonly appendToBody: BooleanConstructor;
+    readonly appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | HTMLElement) | (() => import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement))[], unknown, unknown>) | ((new (...args: any[]) => string | HTMLElement) | (() => import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement))[], unknown, unknown>))[], unknown, unknown, "body", boolean>;
+    readonly beforeClose: {
+        readonly type: import("vue").PropType<DialogBeforeCloseFn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly destroyOnClose: BooleanConstructor;
+    readonly closeOnClickModal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly lockScroll: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly modal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly modalPenetrable: BooleanConstructor;
+    readonly openDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly closeDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly top: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly modelValue: BooleanConstructor;
+    readonly modalClass: StringConstructor;
+    readonly headerClass: StringConstructor;
+    readonly bodyClass: StringConstructor;
+    readonly footerClass: StringConstructor;
+    readonly width: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly zIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly trapFocus: BooleanConstructor;
+    readonly headerAriaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+    readonly transition: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | TransitionProps) | (() => DialogTransition) | ((new (...args: any[]) => string | TransitionProps) | (() => DialogTransition))[], unknown, unknown, undefined, boolean>;
+    readonly center: BooleanConstructor;
+    readonly alignCenter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly closeIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly draggable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly overflow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly fullscreen: BooleanConstructor;
+    readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+};
+export type DialogProps = ExtractPropTypes<typeof dialogProps>;
+export type DialogPropsPublic = __ExtractPublicPropTypes<typeof dialogProps>;
+export declare const dialogEmits: {
+    open: () => boolean;
+    opened: () => boolean;
+    close: () => boolean;
+    closed: () => boolean;
+    "update:modelValue": (value: boolean) => boolean;
+    openAutoFocus: () => boolean;
+    closeAutoFocus: () => boolean;
+};
+export type DialogEmits = typeof dialogEmits;
+export type DialogInstance = InstanceType<typeof Dialog> & unknown;
+export interface DialogConfigContext {
+    alignCenter?: boolean;
+    draggable?: boolean;
+    overflow?: boolean;
+    transition?: DialogTransition;
+}
+export declare const dialogContextKey: InjectionKey<DialogConfigContext>;
+export {};

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

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dialogContent = require('./dialog-content.js');
+var runtime = require('../../../utils/vue/props/runtime.js');
+var teleport = require('../../teleport/src/teleport.js');
+var event = require('../../../constants/event.js');
+var types = require('../../../utils/types.js');
+
+const dialogProps = runtime.buildProps({
+  ...dialogContent.dialogContentProps,
+  appendToBody: Boolean,
+  appendTo: {
+    type: teleport.teleportProps.to.type,
+    default: "body"
+  },
+  beforeClose: {
+    type: runtime.definePropType(Function)
+  },
+  destroyOnClose: Boolean,
+  closeOnClickModal: {
+    type: Boolean,
+    default: true
+  },
+  closeOnPressEscape: {
+    type: Boolean,
+    default: true
+  },
+  lockScroll: {
+    type: Boolean,
+    default: true
+  },
+  modal: {
+    type: Boolean,
+    default: true
+  },
+  modalPenetrable: Boolean,
+  openDelay: {
+    type: Number,
+    default: 0
+  },
+  closeDelay: {
+    type: Number,
+    default: 0
+  },
+  top: {
+    type: String
+  },
+  modelValue: Boolean,
+  modalClass: String,
+  headerClass: String,
+  bodyClass: String,
+  footerClass: String,
+  width: {
+    type: [String, Number]
+  },
+  zIndex: {
+    type: Number
+  },
+  trapFocus: Boolean,
+  headerAriaLevel: {
+    type: String,
+    default: "2"
+  },
+  transition: {
+    type: runtime.definePropType([String, Object]),
+    default: void 0
+  }
+});
+const dialogEmits = {
+  open: () => true,
+  opened: () => true,
+  close: () => true,
+  closed: () => true,
+  [event.UPDATE_MODEL_EVENT]: (value) => types.isBoolean(value),
+  openAutoFocus: () => true,
+  closeAutoFocus: () => true
+};
+const dialogContextKey = Symbol("dialogContextKey");
+
+exports.dialogContextKey = dialogContextKey;
+exports.dialogEmits = dialogEmits;
+exports.dialogProps = dialogProps;
+//# sourceMappingURL=dialog.js.map

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

@@ -0,0 +1,177 @@
+declare function __VLS_template(): {
+    header?(_: {
+        close: () => void;
+        titleId: string;
+        titleClass: string;
+    }): any;
+    title?(_: {}): any;
+    default?(_: {}): any;
+    footer?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly appendToBody: BooleanConstructor;
+    readonly appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | HTMLElement) | (() => import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement))[], unknown, unknown>) | ((new (...args: any[]) => string | HTMLElement) | (() => import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement))[], unknown, unknown>))[], unknown, unknown, "body", boolean>;
+    readonly beforeClose: {
+        readonly type: import("vue").PropType<import("./dialog").DialogBeforeCloseFn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly destroyOnClose: BooleanConstructor;
+    readonly closeOnClickModal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly lockScroll: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly modal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly modalPenetrable: BooleanConstructor;
+    readonly openDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly closeDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly top: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly modelValue: BooleanConstructor;
+    readonly modalClass: StringConstructor;
+    readonly headerClass: StringConstructor;
+    readonly bodyClass: StringConstructor;
+    readonly footerClass: StringConstructor;
+    readonly width: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly zIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly trapFocus: BooleanConstructor;
+    readonly headerAriaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+    readonly transition: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | import("vue").TransitionProps) | (() => import("./dialog").DialogTransition) | ((new (...args: any[]) => string | import("vue").TransitionProps) | (() => import("./dialog").DialogTransition))[], unknown, unknown, undefined, boolean>;
+    readonly center: BooleanConstructor;
+    readonly alignCenter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly closeIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly draggable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly overflow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly fullscreen: BooleanConstructor;
+    readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+}, {
+    /** @description whether the dialog is visible */
+    visible: import("vue").Ref<boolean>;
+    dialogContentRef: import("vue").Ref<any>;
+    resetPosition: () => void;
+    handleClose: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => void;
+    open: () => void;
+    close: () => void;
+    opened: () => void;
+    closed: () => void;
+    openAutoFocus: () => void;
+    closeAutoFocus: () => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly appendToBody: BooleanConstructor;
+    readonly appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | HTMLElement) | (() => import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement))[], unknown, unknown>) | ((new (...args: any[]) => string | HTMLElement) | (() => import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement))[], unknown, unknown>))[], unknown, unknown, "body", boolean>;
+    readonly beforeClose: {
+        readonly type: import("vue").PropType<import("./dialog").DialogBeforeCloseFn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly destroyOnClose: BooleanConstructor;
+    readonly closeOnClickModal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly lockScroll: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly modal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly modalPenetrable: BooleanConstructor;
+    readonly openDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly closeDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly top: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly modelValue: BooleanConstructor;
+    readonly modalClass: StringConstructor;
+    readonly headerClass: StringConstructor;
+    readonly bodyClass: StringConstructor;
+    readonly footerClass: StringConstructor;
+    readonly width: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly zIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly trapFocus: BooleanConstructor;
+    readonly headerAriaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+    readonly transition: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | import("vue").TransitionProps) | (() => import("./dialog").DialogTransition) | ((new (...args: any[]) => string | import("vue").TransitionProps) | (() => import("./dialog").DialogTransition))[], unknown, unknown, undefined, boolean>;
+    readonly center: BooleanConstructor;
+    readonly alignCenter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly closeIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly draggable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly overflow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly fullscreen: BooleanConstructor;
+    readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+}>> & {
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+    onOpenAutoFocus?: (() => any) | undefined;
+    onCloseAutoFocus?: (() => any) | undefined;
+}, {
+    readonly title: string;
+    readonly center: boolean;
+    readonly overflow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly transition: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").TransitionProps) | (() => import("./dialog").DialogTransition) | ((new (...args: any[]) => string | import("vue").TransitionProps) | (() => import("./dialog").DialogTransition))[], unknown, unknown>;
+    readonly modelValue: boolean;
+    readonly ariaLevel: string;
+    readonly appendTo: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement))[], unknown, unknown>) | ((new (...args: any[]) => string | HTMLElement) | (() => import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement))[], unknown, unknown>))[], unknown, unknown>;
+    readonly alignCenter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly draggable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showClose: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly fullscreen: boolean;
+    readonly closeOnClickModal: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly lockScroll: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly modal: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly openDelay: number;
+    readonly closeDelay: number;
+    readonly headerAriaLevel: string;
+    readonly appendToBody: boolean;
+    readonly destroyOnClose: boolean;
+    readonly modalPenetrable: boolean;
+    readonly trapFocus: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

frontend/node_modules/element-plus/lib/components/dialog/src/dialog2.js

@@ -0,0 +1,183 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index$3 = require('../../overlay/index.js');
+var focusTrap = require('../../focus-trap/src/focus-trap.js');
+var index$2 = require('../../teleport/index.js');
+var dialogContent = require('./dialog-content2.js');
+var constants = require('./constants.js');
+var dialog = require('./dialog.js');
+var useDialog = require('./use-dialog.js');
+var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+var index = require('../../../hooks/use-deprecated/index.js');
+var index$1 = require('../../../hooks/use-namespace/index.js');
+var index$4 = require('../../../hooks/use-same-target/index.js');
+
+const __default__ = vue.defineComponent({
+  name: "ElDialog",
+  inheritAttrs: false
+});
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: dialog.dialogProps,
+  emits: dialog.dialogEmits,
+  setup(__props, { expose }) {
+    const props = __props;
+    const slots = vue.useSlots();
+    index.useDeprecated({
+      scope: "el-dialog",
+      from: "the title slot",
+      replacement: "the header slot",
+      version: "3.0.0",
+      ref: "https://element-plus.org/en-US/component/dialog.html#slots"
+    }, vue.computed(() => !!slots.title));
+    const ns = index$1.useNamespace("dialog");
+    const dialogRef = vue.ref();
+    const headerRef = vue.ref();
+    const dialogContentRef = vue.ref();
+    const {
+      visible,
+      titleId,
+      bodyId,
+      style,
+      overlayDialogStyle,
+      rendered,
+      transitionConfig,
+      zIndex,
+      _draggable,
+      _alignCenter,
+      _overflow,
+      handleClose,
+      onModalClick,
+      onOpenAutoFocus,
+      onCloseAutoFocus,
+      onCloseRequested,
+      onFocusoutPrevented
+    } = useDialog.useDialog(props, dialogRef);
+    vue.provide(constants.dialogInjectionKey, {
+      dialogRef,
+      headerRef,
+      bodyId,
+      ns,
+      rendered,
+      style
+    });
+    const overlayEvent = index$4.useSameTarget(onModalClick);
+    const penetrable = vue.computed(() => props.modalPenetrable && !props.modal && !props.fullscreen);
+    const resetPosition = () => {
+      var _a;
+      (_a = dialogContentRef.value) == null ? void 0 : _a.resetPosition();
+    };
+    expose({
+      visible,
+      dialogContentRef,
+      resetPosition,
+      handleClose
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(index$2.ElTeleport), {
+        to: _ctx.appendTo,
+        disabled: _ctx.appendTo !== "body" ? false : !_ctx.appendToBody
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.Transition, vue.mergeProps(vue.unref(transitionConfig), { persisted: "" }), {
+            default: vue.withCtx(() => {
+              var _a;
+              return [
+                vue.withDirectives(vue.createVNode(vue.unref(index$3.ElOverlay), {
+                  "custom-mask-event": "",
+                  mask: _ctx.modal,
+                  "overlay-class": [
+                    (_a = _ctx.modalClass) != null ? _a : "",
+                    `${vue.unref(ns).namespace.value}-modal-dialog`,
+                    vue.unref(ns).is("penetrable", vue.unref(penetrable))
+                  ],
+                  "z-index": vue.unref(zIndex)
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createElementVNode("div", {
+                      role: "dialog",
+                      "aria-modal": "true",
+                      "aria-label": _ctx.title || void 0,
+                      "aria-labelledby": !_ctx.title ? vue.unref(titleId) : void 0,
+                      "aria-describedby": vue.unref(bodyId),
+                      class: vue.normalizeClass(`${vue.unref(ns).namespace.value}-overlay-dialog`),
+                      style: vue.normalizeStyle(vue.unref(overlayDialogStyle)),
+                      onClick: vue.unref(overlayEvent).onClick,
+                      onMousedown: vue.unref(overlayEvent).onMousedown,
+                      onMouseup: vue.unref(overlayEvent).onMouseup
+                    }, [
+                      vue.createVNode(vue.unref(focusTrap["default"]), {
+                        loop: "",
+                        trapped: vue.unref(visible),
+                        "focus-start-el": "container",
+                        onFocusAfterTrapped: vue.unref(onOpenAutoFocus),
+                        onFocusAfterReleased: vue.unref(onCloseAutoFocus),
+                        onFocusoutPrevented: vue.unref(onFocusoutPrevented),
+                        onReleaseRequested: vue.unref(onCloseRequested)
+                      }, {
+                        default: vue.withCtx(() => [
+                          vue.unref(rendered) ? (vue.openBlock(), vue.createBlock(dialogContent["default"], vue.mergeProps({
+                            key: 0,
+                            ref_key: "dialogContentRef",
+                            ref: dialogContentRef
+                          }, _ctx.$attrs, {
+                            center: _ctx.center,
+                            "align-center": vue.unref(_alignCenter),
+                            "close-icon": _ctx.closeIcon,
+                            draggable: vue.unref(_draggable),
+                            overflow: vue.unref(_overflow),
+                            fullscreen: _ctx.fullscreen,
+                            "header-class": _ctx.headerClass,
+                            "body-class": _ctx.bodyClass,
+                            "footer-class": _ctx.footerClass,
+                            "show-close": _ctx.showClose,
+                            title: _ctx.title,
+                            "aria-level": _ctx.headerAriaLevel,
+                            onClose: vue.unref(handleClose)
+                          }), vue.createSlots({
+                            header: vue.withCtx(() => [
+                              !_ctx.$slots.title ? vue.renderSlot(_ctx.$slots, "header", {
+                                key: 0,
+                                close: vue.unref(handleClose),
+                                titleId: vue.unref(titleId),
+                                titleClass: vue.unref(ns).e("title")
+                              }) : vue.renderSlot(_ctx.$slots, "title", { key: 1 })
+                            ]),
+                            default: vue.withCtx(() => [
+                              vue.renderSlot(_ctx.$slots, "default")
+                            ]),
+                            _: 2
+                          }, [
+                            _ctx.$slots.footer ? {
+                              name: "footer",
+                              fn: vue.withCtx(() => [
+                                vue.renderSlot(_ctx.$slots, "footer")
+                              ])
+                            } : void 0
+                          ]), 1040, ["center", "align-center", "close-icon", "draggable", "overflow", "fullscreen", "header-class", "body-class", "footer-class", "show-close", "title", "aria-level", "onClose"])) : vue.createCommentVNode("v-if", true)
+                        ]),
+                        _: 3
+                      }, 8, ["trapped", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusoutPrevented", "onReleaseRequested"])
+                    ], 46, ["aria-label", "aria-labelledby", "aria-describedby", "onClick", "onMousedown", "onMouseup"])
+                  ]),
+                  _: 3
+                }, 8, ["mask", "overlay-class", "z-index"]), [
+                  [vue.vShow, vue.unref(visible)]
+                ])
+              ];
+            }),
+            _: 3
+          }, 16)
+        ]),
+        _: 3
+      }, 8, ["to", "disabled"]);
+    };
+  }
+});
+var Dialog = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "dialog.vue"]]);
+
+exports["default"] = Dialog;
+//# sourceMappingURL=dialog2.js.map

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

@@ -0,0 +1,32 @@
+import type { CSSProperties, Ref, TransitionProps } from 'vue';
+import type { DialogProps } from './dialog';
+export declare const useDialog: (props: DialogProps, targetRef: Ref<HTMLElement | undefined>) => {
+    afterEnter: () => void;
+    afterLeave: () => void;
+    beforeLeave: () => void;
+    handleClose: () => void;
+    onModalClick: () => void;
+    close: () => void;
+    doClose: () => void;
+    onOpenAutoFocus: () => void;
+    onCloseAutoFocus: () => void;
+    onCloseRequested: () => void;
+    onFocusoutPrevented: (event: CustomEvent) => void;
+    titleId: Ref<string>;
+    bodyId: Ref<string>;
+    closed: Ref<boolean>;
+    style: import("vue").ComputedRef<CSSProperties>;
+    overlayDialogStyle: import("vue").ComputedRef<CSSProperties>;
+    rendered: Ref<boolean>;
+    visible: Ref<boolean>;
+    zIndex: Ref<number>;
+    transitionConfig: import("vue").ComputedRef<TransitionProps | {
+        name: string | TransitionProps;
+        onAfterEnter: () => void;
+        onBeforeLeave: () => void;
+        onAfterLeave: () => void;
+    }>;
+    _draggable: import("vue").ComputedRef<boolean>;
+    _alignCenter: import("vue").ComputedRef<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
+    _overflow: import("vue").ComputedRef<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
+};

frontend/node_modules/element-plus/lib/components/dialog/src/use-dialog.js

@@ -0,0 +1,252 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var core = require('@vueuse/core');
+var constants = require('./constants.js');
+var index$3 = require('../../../hooks/use-lockscreen/index.js');
+var index = require('../../../hooks/use-z-index/index.js');
+var index$1 = require('../../../hooks/use-id/index.js');
+var useGlobalConfig = require('../../config-provider/src/hooks/use-global-config.js');
+var index$2 = require('../../../hooks/use-namespace/index.js');
+var style = require('../../../utils/dom/style.js');
+var shared = require('@vue/shared');
+var event = require('../../../constants/event.js');
+
+const useDialog = (props, targetRef) => {
+  var _a;
+  const instance = vue.getCurrentInstance();
+  const emit = instance.emit;
+  const { nextZIndex } = index.useZIndex();
+  let lastPosition = "";
+  const titleId = index$1.useId();
+  const bodyId = index$1.useId();
+  const visible = vue.ref(false);
+  const closed = vue.ref(false);
+  const rendered = vue.ref(false);
+  const zIndex = vue.ref((_a = props.zIndex) != null ? _a : nextZIndex());
+  let openTimer = void 0;
+  let closeTimer = void 0;
+  const config = useGlobalConfig.useGlobalConfig();
+  const namespace = vue.computed(() => {
+    var _a2, _b;
+    return (_b = (_a2 = config.value) == null ? void 0 : _a2.namespace) != null ? _b : index$2.defaultNamespace;
+  });
+  const globalConfig = vue.computed(() => {
+    var _a2;
+    return (_a2 = config.value) == null ? void 0 : _a2.dialog;
+  });
+  const style$1 = vue.computed(() => {
+    const style2 = {};
+    const varPrefix = `--${namespace.value}-dialog`;
+    if (!props.fullscreen) {
+      if (props.top) {
+        style2[`${varPrefix}-margin-top`] = props.top;
+      }
+      if (props.width) {
+        style2[`${varPrefix}-width`] = style.addUnit(props.width);
+      }
+    }
+    return style2;
+  });
+  const _draggable = vue.computed(() => {
+    var _a2, _b, _c;
+    return ((_c = (_b = props.draggable) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.draggable) != null ? _c : false) && !props.fullscreen;
+  });
+  const _alignCenter = vue.computed(() => {
+    var _a2, _b, _c;
+    return (_c = (_b = props.alignCenter) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.alignCenter) != null ? _c : false;
+  });
+  const _overflow = vue.computed(() => {
+    var _a2, _b, _c;
+    return (_c = (_b = props.overflow) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.overflow) != null ? _c : false;
+  });
+  const overlayDialogStyle = vue.computed(() => {
+    if (_alignCenter.value) {
+      return { display: "flex" };
+    }
+    return {};
+  });
+  const transitionConfig = vue.computed(() => {
+    var _a2, _b, _c;
+    const transition = (_c = (_b = props.transition) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.transition) != null ? _c : constants.DEFAULT_DIALOG_TRANSITION;
+    const baseConfig = {
+      name: transition,
+      onAfterEnter: afterEnter,
+      onBeforeLeave: beforeLeave,
+      onAfterLeave: afterLeave
+    };
+    if (shared.isObject(transition)) {
+      const config2 = { ...transition };
+      const _mergeHook = (userHook, defaultHook) => {
+        return (el) => {
+          if (shared.isArray(userHook)) {
+            userHook.forEach((fn) => {
+              if (shared.isFunction(fn))
+                fn(el);
+            });
+          } else if (shared.isFunction(userHook)) {
+            userHook(el);
+          }
+          defaultHook();
+        };
+      };
+      config2.onAfterEnter = _mergeHook(config2.onAfterEnter, afterEnter);
+      config2.onBeforeLeave = _mergeHook(config2.onBeforeLeave, beforeLeave);
+      config2.onAfterLeave = _mergeHook(config2.onAfterLeave, afterLeave);
+      if (!config2.name) {
+        config2.name = constants.DEFAULT_DIALOG_TRANSITION;
+      }
+      return config2;
+    }
+    return baseConfig;
+  });
+  function afterEnter() {
+    emit("opened");
+  }
+  function afterLeave() {
+    emit("closed");
+    emit(event.UPDATE_MODEL_EVENT, false);
+    if (props.destroyOnClose) {
+      rendered.value = false;
+    }
+  }
+  function beforeLeave() {
+    emit("close");
+  }
+  function open() {
+    closeTimer == null ? void 0 : closeTimer();
+    openTimer == null ? void 0 : openTimer();
+    if (props.openDelay && props.openDelay > 0) {
+      ({ stop: openTimer } = core.useTimeoutFn(() => doOpen(), props.openDelay));
+    } else {
+      doOpen();
+    }
+  }
+  function close() {
+    openTimer == null ? void 0 : openTimer();
+    closeTimer == null ? void 0 : closeTimer();
+    if (props.closeDelay && props.closeDelay > 0) {
+      ({ stop: closeTimer } = core.useTimeoutFn(() => doClose(), props.closeDelay));
+    } else {
+      doClose();
+    }
+  }
+  function handleClose() {
+    function hide(shouldCancel) {
+      if (shouldCancel)
+        return;
+      closed.value = true;
+      visible.value = false;
+    }
+    if (props.beforeClose) {
+      props.beforeClose(hide);
+    } else {
+      close();
+    }
+  }
+  function onModalClick() {
+    if (props.closeOnClickModal) {
+      handleClose();
+    }
+  }
+  function doOpen() {
+    if (!core.isClient)
+      return;
+    visible.value = true;
+  }
+  function doClose() {
+    visible.value = false;
+  }
+  function onOpenAutoFocus() {
+    emit("openAutoFocus");
+  }
+  function onCloseAutoFocus() {
+    emit("closeAutoFocus");
+  }
+  function onFocusoutPrevented(event) {
+    var _a2;
+    if (((_a2 = event.detail) == null ? void 0 : _a2.focusReason) === "pointer") {
+      event.preventDefault();
+    }
+  }
+  if (props.lockScroll) {
+    index$3.useLockscreen(visible);
+  }
+  function onCloseRequested() {
+    if (props.closeOnPressEscape) {
+      handleClose();
+    }
+  }
+  vue.watch(() => props.zIndex, () => {
+    var _a2;
+    zIndex.value = (_a2 = props.zIndex) != null ? _a2 : nextZIndex();
+  });
+  vue.watch(() => props.modelValue, (val) => {
+    var _a2;
+    if (val) {
+      closed.value = false;
+      open();
+      rendered.value = true;
+      zIndex.value = (_a2 = props.zIndex) != null ? _a2 : nextZIndex();
+      vue.nextTick(() => {
+        emit("open");
+        if (targetRef.value) {
+          targetRef.value.parentElement.scrollTop = 0;
+          targetRef.value.parentElement.scrollLeft = 0;
+          targetRef.value.scrollTop = 0;
+        }
+      });
+    } else {
+      if (visible.value) {
+        close();
+      }
+    }
+  });
+  vue.watch(() => props.fullscreen, (val) => {
+    if (!targetRef.value)
+      return;
+    if (val) {
+      lastPosition = targetRef.value.style.transform;
+      targetRef.value.style.transform = "";
+    } else {
+      targetRef.value.style.transform = lastPosition;
+    }
+  });
+  vue.onMounted(() => {
+    if (props.modelValue) {
+      visible.value = true;
+      rendered.value = true;
+      open();
+    }
+  });
+  return {
+    afterEnter,
+    afterLeave,
+    beforeLeave,
+    handleClose,
+    onModalClick,
+    close,
+    doClose,
+    onOpenAutoFocus,
+    onCloseAutoFocus,
+    onCloseRequested,
+    onFocusoutPrevented,
+    titleId,
+    bodyId,
+    closed,
+    style: style$1,
+    overlayDialogStyle,
+    rendered,
+    visible,
+    zIndex,
+    transitionConfig,
+    _draggable,
+    _alignCenter,
+    _overflow
+  };
+};
+
+exports.useDialog = useDialog;
+//# sourceMappingURL=use-dialog.js.map

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

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

frontend/node_modules/element-plus/lib/components/dialog/style/css.js

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

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

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

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

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

frontend/node_modules/element-plus/lib/components/dialog/style/index.js

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

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

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