测试

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

@@ -0,0 +1,5 @@
+import Image from './src/image.vue';
+import type { SFCWithInstall } from 'element-plus/es/utils';
+export declare const ElImage: SFCWithInstall<typeof Image>;
+export default ElImage;
+export * from './src/image';

frontend/node_modules/element-plus/es/components/image/index.mjs

@@ -0,0 +1,8 @@
+import Image from './src/image2.mjs';
+export { imageEmits, imageProps } from './src/image.mjs';
+import { withInstall } from '../../utils/vue/install.mjs';
+
+const ElImage = withInstall(Image);
+
+export { ElImage, ElImage as default };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../../packages/components/image/index.ts"],"sourcesContent":["import { withInstall } from '@element-plus/utils'\nimport Image from './src/image.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElImage: SFCWithInstall<typeof Image> = withInstall(Image)\nexport default ElImage\n\nexport * from './src/image'\n"],"names":[],"mappings":";;;;AAEY,MAAC,OAAO,GAAG,WAAW,CAAC,KAAK;;;;"}

frontend/node_modules/element-plus/es/components/image/src/image.d.ts

@@ -0,0 +1,53 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type Image from './image.vue';
+export declare const imageProps: {
+    readonly hideOnClickModal: BooleanConstructor;
+    readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly fit: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "fill" | "contain" | "none" | "cover" | "scale-down", unknown, "", boolean>;
+    readonly loading: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "lazy" | "eager", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly lazy: BooleanConstructor;
+    readonly scrollContainer: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement | undefined) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement | undefined))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly previewSrcList: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
+    readonly previewTeleported: BooleanConstructor;
+    readonly zIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly initialIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly infinite: 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 zoomRate: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1.2, boolean>;
+    readonly scale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+    readonly minScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.2, boolean>;
+    readonly maxScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 7, boolean>;
+    readonly showProgress: BooleanConstructor;
+    readonly crossorigin: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "anonymous" | "use-credentials") | (() => "" | "anonymous" | "use-credentials") | ((new (...args: any[]) => "" | "anonymous" | "use-credentials") | (() => "" | "anonymous" | "use-credentials"))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type ImageProps = ExtractPropTypes<typeof imageProps>;
+export type ImagePropsPublic = __ExtractPublicPropTypes<typeof imageProps>;
+export declare const imageEmits: {
+    load: (evt: Event) => boolean;
+    error: (evt: Event) => boolean;
+    switch: (val: number) => boolean;
+    close: () => boolean;
+    show: () => boolean;
+};
+export type ImageEmits = typeof imageEmits;
+export type ImageInstance = InstanceType<typeof Image> & unknown;

frontend/node_modules/element-plus/es/components/image/src/image.mjs

@@ -0,0 +1,74 @@
+import { buildProps, definePropType } from '../../../utils/vue/props/runtime.mjs';
+import { mutable } from '../../../utils/typescript.mjs';
+import { isNumber } from '../../../utils/types.mjs';
+
+const imageProps = buildProps({
+  hideOnClickModal: Boolean,
+  src: {
+    type: String,
+    default: ""
+  },
+  fit: {
+    type: String,
+    values: ["", "contain", "cover", "fill", "none", "scale-down"],
+    default: ""
+  },
+  loading: {
+    type: String,
+    values: ["eager", "lazy"]
+  },
+  lazy: Boolean,
+  scrollContainer: {
+    type: definePropType([String, Object])
+  },
+  previewSrcList: {
+    type: definePropType(Array),
+    default: () => mutable([])
+  },
+  previewTeleported: Boolean,
+  zIndex: {
+    type: Number
+  },
+  initialIndex: {
+    type: Number,
+    default: 0
+  },
+  infinite: {
+    type: Boolean,
+    default: true
+  },
+  closeOnPressEscape: {
+    type: Boolean,
+    default: true
+  },
+  zoomRate: {
+    type: Number,
+    default: 1.2
+  },
+  scale: {
+    type: Number,
+    default: 1
+  },
+  minScale: {
+    type: Number,
+    default: 0.2
+  },
+  maxScale: {
+    type: Number,
+    default: 7
+  },
+  showProgress: Boolean,
+  crossorigin: {
+    type: definePropType(String)
+  }
+});
+const imageEmits = {
+  load: (evt) => evt instanceof Event,
+  error: (evt) => evt instanceof Event,
+  switch: (val) => isNumber(val),
+  close: () => true,
+  show: () => true
+};
+
+export { imageEmits, imageProps };
+//# sourceMappingURL=image.mjs.map

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

@@ -0,0 +1,138 @@
+declare function clickHandler(): void;
+declare function __VLS_template(): {
+    error?(_: {}): any;
+    placeholder?(_: {}): any;
+    viewer?(_: {}): any;
+    progress?(_: {
+        activeIndex: number;
+        total: number;
+    }): any;
+    toolbar?(_: {
+        actions: (action: import("element-plus/es/components/image-viewer").ImageViewerAction, options?: {}) => void;
+        prev: () => void;
+        next: () => void;
+        reset: () => void;
+        activeIndex: number;
+        setActiveItem: (index: number) => void;
+    }): any;
+    "viewer-error"?(_: {
+        activeIndex: number;
+        src: string;
+    }): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly hideOnClickModal: BooleanConstructor;
+    readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly fit: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "fill" | "contain" | "none" | "cover" | "scale-down", unknown, "", boolean>;
+    readonly loading: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "lazy" | "eager", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly lazy: BooleanConstructor;
+    readonly scrollContainer: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement | undefined) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement | undefined))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly previewSrcList: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
+    readonly previewTeleported: BooleanConstructor;
+    readonly zIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly initialIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly infinite: 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 zoomRate: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1.2, boolean>;
+    readonly scale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+    readonly minScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.2, boolean>;
+    readonly maxScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 7, boolean>;
+    readonly showProgress: BooleanConstructor;
+    readonly crossorigin: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "anonymous" | "use-credentials") | (() => "" | "anonymous" | "use-credentials") | ((new (...args: any[]) => "" | "anonymous" | "use-credentials") | (() => "" | "anonymous" | "use-credentials"))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {
+    /** @description manually open preview */
+    showPreview: typeof clickHandler;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    switch: (val: number) => void;
+    show: () => void;
+    close: () => void;
+    error: (evt: Event) => void;
+    load: (evt: Event) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly hideOnClickModal: BooleanConstructor;
+    readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly fit: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "fill" | "contain" | "none" | "cover" | "scale-down", unknown, "", boolean>;
+    readonly loading: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "lazy" | "eager", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly lazy: BooleanConstructor;
+    readonly scrollContainer: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement | undefined) | ((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement | undefined))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly previewSrcList: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
+    readonly previewTeleported: BooleanConstructor;
+    readonly zIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly initialIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly infinite: 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 zoomRate: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1.2, boolean>;
+    readonly scale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+    readonly minScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.2, boolean>;
+    readonly maxScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 7, boolean>;
+    readonly showProgress: BooleanConstructor;
+    readonly crossorigin: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "anonymous" | "use-credentials") | (() => "" | "anonymous" | "use-credentials") | ((new (...args: any[]) => "" | "anonymous" | "use-credentials") | (() => "" | "anonymous" | "use-credentials"))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & {
+    onShow?: (() => any) | undefined;
+    onLoad?: ((evt: Event) => any) | undefined;
+    onError?: ((evt: Event) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onSwitch?: ((val: number) => any) | undefined;
+}, {
+    readonly scale: number;
+    readonly infinite: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly lazy: boolean;
+    readonly src: string;
+    readonly fit: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "fill" | "contain" | "none" | "cover" | "scale-down", unknown>;
+    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly initialIndex: number;
+    readonly zoomRate: number;
+    readonly minScale: number;
+    readonly maxScale: number;
+    readonly hideOnClickModal: boolean;
+    readonly showProgress: boolean;
+    readonly previewSrcList: string[];
+    readonly previewTeleported: 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/es/components/image/src/image2.mjs

@@ -0,0 +1,239 @@
+import { defineComponent, useAttrs, computed, ref, watch, onMounted, openBlock, createElementBlock, mergeProps, unref, renderSlot, createElementVNode, normalizeClass, toDisplayString, Fragment, createCommentVNode, createBlock, createSlots, withCtx, normalizeProps, guardReactiveProps, nextTick } from 'vue';
+import { isClient, useThrottleFn, useIntersectionObserver } from '@vueuse/core';
+import { fromPairs } from 'lodash-unified';
+import { ElImageViewer } from '../../image-viewer/index.mjs';
+import { imageProps, imageEmits } from './image.mjs';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
+import { isElement, isWindow } from '../../../utils/types.mjs';
+import { useLocale } from '../../../hooks/use-locale/index.mjs';
+import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
+import { useAttrs as useAttrs$1 } from '../../../hooks/use-attrs/index.mjs';
+import { isArray, isString } from '@vue/shared';
+import { getScrollContainer } from '../../../utils/dom/scroll.mjs';
+
+const __default__ = defineComponent({
+  name: "ElImage",
+  inheritAttrs: false
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: imageProps,
+  emits: imageEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const { t } = useLocale();
+    const ns = useNamespace("image");
+    const rawAttrs = useAttrs();
+    const containerAttrs = computed(() => {
+      return fromPairs(Object.entries(rawAttrs).filter(([key]) => /^(data-|on[A-Z])/i.test(key) || ["id", "style"].includes(key)));
+    });
+    const imgAttrs = useAttrs$1({
+      excludeListeners: true,
+      excludeKeys: computed(() => {
+        return Object.keys(containerAttrs.value);
+      })
+    });
+    const imageSrc = ref();
+    const hasLoadError = ref(false);
+    const isLoading = ref(true);
+    const showViewer = ref(false);
+    const container = ref();
+    const _scrollContainer = ref();
+    const supportLoading = isClient && "loading" in HTMLImageElement.prototype;
+    let stopScrollListener;
+    const imageKls = computed(() => [
+      ns.e("inner"),
+      preview.value && ns.e("preview"),
+      isLoading.value && ns.is("loading")
+    ]);
+    const imageStyle = computed(() => {
+      const { fit } = props;
+      if (isClient && fit) {
+        return { objectFit: fit };
+      }
+      return {};
+    });
+    const preview = computed(() => {
+      const { previewSrcList } = props;
+      return isArray(previewSrcList) && previewSrcList.length > 0;
+    });
+    const imageIndex = computed(() => {
+      const { previewSrcList, initialIndex } = props;
+      let previewIndex = initialIndex;
+      if (initialIndex > previewSrcList.length - 1) {
+        previewIndex = 0;
+      }
+      return previewIndex;
+    });
+    const isManual = computed(() => {
+      if (props.loading === "eager")
+        return false;
+      return !supportLoading && props.loading === "lazy" || props.lazy;
+    });
+    const loadImage = () => {
+      if (!isClient)
+        return;
+      isLoading.value = true;
+      hasLoadError.value = false;
+      imageSrc.value = props.src;
+    };
+    function handleLoad(event) {
+      isLoading.value = false;
+      hasLoadError.value = false;
+      emit("load", event);
+    }
+    function handleError(event) {
+      isLoading.value = false;
+      hasLoadError.value = true;
+      emit("error", event);
+    }
+    function handleLazyLoad(isIntersecting) {
+      if (isIntersecting) {
+        loadImage();
+        removeLazyLoadListener();
+      }
+    }
+    const lazyLoadHandler = useThrottleFn(handleLazyLoad, 200, true);
+    async function addLazyLoadListener() {
+      var _a;
+      if (!isClient)
+        return;
+      await nextTick();
+      const { scrollContainer } = props;
+      if (isElement(scrollContainer)) {
+        _scrollContainer.value = scrollContainer;
+      } else if (isString(scrollContainer) && scrollContainer !== "") {
+        _scrollContainer.value = (_a = document.querySelector(scrollContainer)) != null ? _a : void 0;
+      } else if (container.value) {
+        const scrollContainer2 = getScrollContainer(container.value);
+        _scrollContainer.value = isWindow(scrollContainer2) ? void 0 : scrollContainer2;
+      }
+      const { stop } = useIntersectionObserver(container, ([entry]) => {
+        lazyLoadHandler(entry.isIntersecting);
+      }, { root: _scrollContainer });
+      stopScrollListener = stop;
+    }
+    function removeLazyLoadListener() {
+      if (!isClient || !lazyLoadHandler)
+        return;
+      stopScrollListener == null ? void 0 : stopScrollListener();
+      _scrollContainer.value = void 0;
+      stopScrollListener = void 0;
+    }
+    function clickHandler() {
+      if (!preview.value)
+        return;
+      showViewer.value = true;
+      emit("show");
+    }
+    function closeViewer() {
+      showViewer.value = false;
+      emit("close");
+    }
+    function switchViewer(val) {
+      emit("switch", val);
+    }
+    watch(() => props.src, () => {
+      if (isManual.value) {
+        isLoading.value = true;
+        hasLoadError.value = false;
+        removeLazyLoadListener();
+        addLazyLoadListener();
+      } else {
+        loadImage();
+      }
+    });
+    onMounted(() => {
+      if (isManual.value) {
+        addLazyLoadListener();
+      } else {
+        loadImage();
+      }
+    });
+    expose({
+      showPreview: clickHandler
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", mergeProps({
+        ref_key: "container",
+        ref: container
+      }, unref(containerAttrs), {
+        class: [unref(ns).b(), _ctx.$attrs.class]
+      }), [
+        hasLoadError.value ? renderSlot(_ctx.$slots, "error", { key: 0 }, () => [
+          createElementVNode("div", {
+            class: normalizeClass(unref(ns).e("error"))
+          }, toDisplayString(unref(t)("el.image.error")), 3)
+        ]) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+          imageSrc.value !== void 0 ? (openBlock(), createElementBlock("img", mergeProps({ key: 0 }, unref(imgAttrs), {
+            src: imageSrc.value,
+            loading: _ctx.loading,
+            style: unref(imageStyle),
+            class: unref(imageKls),
+            crossorigin: _ctx.crossorigin,
+            onClick: clickHandler,
+            onLoad: handleLoad,
+            onError: handleError
+          }), null, 16, ["src", "loading", "crossorigin"])) : createCommentVNode("v-if", true),
+          isLoading.value ? (openBlock(), createElementBlock("div", {
+            key: 1,
+            class: normalizeClass(unref(ns).e("wrapper"))
+          }, [
+            renderSlot(_ctx.$slots, "placeholder", {}, () => [
+              createElementVNode("div", {
+                class: normalizeClass(unref(ns).e("placeholder"))
+              }, null, 2)
+            ])
+          ], 2)) : createCommentVNode("v-if", true)
+        ], 64)),
+        unref(preview) ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
+          showViewer.value ? (openBlock(), createBlock(unref(ElImageViewer), {
+            key: 0,
+            "z-index": _ctx.zIndex,
+            "initial-index": unref(imageIndex),
+            infinite: _ctx.infinite,
+            "zoom-rate": _ctx.zoomRate,
+            "min-scale": _ctx.minScale,
+            "max-scale": _ctx.maxScale,
+            "show-progress": _ctx.showProgress,
+            "url-list": _ctx.previewSrcList,
+            scale: _ctx.scale,
+            crossorigin: _ctx.crossorigin,
+            "hide-on-click-modal": _ctx.hideOnClickModal,
+            teleported: _ctx.previewTeleported,
+            "close-on-press-escape": _ctx.closeOnPressEscape,
+            onClose: closeViewer,
+            onSwitch: switchViewer
+          }, createSlots({
+            toolbar: withCtx((toolbar) => [
+              renderSlot(_ctx.$slots, "toolbar", normalizeProps(guardReactiveProps(toolbar)))
+            ]),
+            default: withCtx(() => [
+              _ctx.$slots.viewer ? (openBlock(), createElementBlock("div", { key: 0 }, [
+                renderSlot(_ctx.$slots, "viewer")
+              ])) : createCommentVNode("v-if", true)
+            ]),
+            _: 2
+          }, [
+            _ctx.$slots.progress ? {
+              name: "progress",
+              fn: withCtx((progress) => [
+                renderSlot(_ctx.$slots, "progress", normalizeProps(guardReactiveProps(progress)))
+              ])
+            } : void 0,
+            _ctx.$slots["viewer-error"] ? {
+              name: "viewer-error",
+              fn: withCtx((viewerError) => [
+                renderSlot(_ctx.$slots, "viewer-error", normalizeProps(guardReactiveProps(viewerError)))
+              ])
+            } : void 0
+          ]), 1032, ["z-index", "initial-index", "infinite", "zoom-rate", "min-scale", "max-scale", "show-progress", "url-list", "scale", "crossorigin", "hide-on-click-modal", "teleported", "close-on-press-escape"])) : createCommentVNode("v-if", true)
+        ], 64)) : createCommentVNode("v-if", true)
+      ], 16);
+    };
+  }
+});
+var Image = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "image.vue"]]);
+
+export { Image as default };
+//# sourceMappingURL=image2.mjs.map

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

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

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

@@ -0,0 +1,4 @@
+import '../../base/style/css.mjs';
+import 'element-plus/theme-chalk/el-image.css';
+import '../../image-viewer/style/css.mjs';
+//# sourceMappingURL=css.mjs.map

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

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

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

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

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

@@ -0,0 +1,4 @@
+import '../../base/style/index.mjs';
+import 'element-plus/theme-chalk/src/image.scss';
+import '../../image-viewer/style/index.mjs';
+//# sourceMappingURL=index.mjs.map

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

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