first commit

node_modules/vant/es/image-preview/ImagePreview.d.ts

@@ -0,0 +1,234 @@
+import { type PropType, type CSSProperties, type ExtractPropTypes, type TeleportProps } from 'vue';
+import { Interceptor } from '../utils';
+import { PopupCloseIconPosition } from '../popup';
+export declare const imagePreviewProps: {
+    show: BooleanConstructor;
+    loop: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    images: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    minZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    maxZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    overlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    vertical: BooleanConstructor;
+    closeable: BooleanConstructor;
+    showIndex: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    className: PropType<unknown>;
+    closeIcon: {
+        type: PropType<string>;
+        default: string;
+    };
+    transition: StringConstructor;
+    beforeClose: PropType<Interceptor>;
+    doubleScale: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    overlayClass: PropType<unknown>;
+    overlayStyle: PropType<CSSProperties>;
+    swipeDuration: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    startPosition: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    showIndicators: BooleanConstructor;
+    closeOnPopstate: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickOverlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeIconPosition: {
+        type: PropType<PopupCloseIconPosition>;
+        default: PopupCloseIconPosition;
+    };
+    teleport: PropType<TeleportProps["to"]>;
+};
+export type ImagePreviewProps = ExtractPropTypes<typeof imagePreviewProps>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    show: BooleanConstructor;
+    loop: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    images: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    minZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    maxZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    overlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    vertical: BooleanConstructor;
+    closeable: BooleanConstructor;
+    showIndex: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    className: PropType<unknown>;
+    closeIcon: {
+        type: PropType<string>;
+        default: string;
+    };
+    transition: StringConstructor;
+    beforeClose: PropType<Interceptor>;
+    doubleScale: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    overlayClass: PropType<unknown>;
+    overlayStyle: PropType<CSSProperties>;
+    swipeDuration: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    startPosition: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    showIndicators: BooleanConstructor;
+    closeOnPopstate: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickOverlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeIconPosition: {
+        type: PropType<PopupCloseIconPosition>;
+        default: PopupCloseIconPosition;
+    };
+    teleport: PropType<TeleportProps["to"]>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "close" | "closed" | "update:show" | "scale" | "longPress")[], "change" | "close" | "closed" | "update:show" | "scale" | "longPress", import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    show: BooleanConstructor;
+    loop: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    images: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    minZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    maxZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    overlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    vertical: BooleanConstructor;
+    closeable: BooleanConstructor;
+    showIndex: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    className: PropType<unknown>;
+    closeIcon: {
+        type: PropType<string>;
+        default: string;
+    };
+    transition: StringConstructor;
+    beforeClose: PropType<Interceptor>;
+    doubleScale: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    overlayClass: PropType<unknown>;
+    overlayStyle: PropType<CSSProperties>;
+    swipeDuration: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    startPosition: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    showIndicators: BooleanConstructor;
+    closeOnPopstate: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickOverlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeIconPosition: {
+        type: PropType<PopupCloseIconPosition>;
+        default: PopupCloseIconPosition;
+    };
+    teleport: PropType<TeleportProps["to"]>;
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+    onClosed?: ((...args: any[]) => any) | undefined;
+    "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+    onScale?: ((...args: any[]) => any) | undefined;
+    onLongPress?: ((...args: any[]) => any) | undefined;
+}>, {
+    loop: boolean;
+    overlay: boolean;
+    show: boolean;
+    vertical: boolean;
+    closeOnClickOverlay: boolean;
+    closeIcon: string;
+    closeable: boolean;
+    closeOnPopstate: boolean;
+    closeIconPosition: PopupCloseIconPosition;
+    swipeDuration: string | number;
+    showIndicators: boolean;
+    startPosition: string | number;
+    minZoom: string | number;
+    maxZoom: string | number;
+    doubleScale: boolean;
+    closeOnClickImage: boolean;
+    images: string[];
+    showIndex: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

node_modules/vant/es/image-preview/ImagePreview.mjs

@@ -0,0 +1,196 @@
+import { ref, watch, nextTick, reactive, onMounted, defineComponent, createVNode as _createVNode, mergeProps as _mergeProps } from "vue";
+import { pick, truthProp, unknownProp, windowWidth, windowHeight, makeArrayProp, makeStringProp, makeNumericProp, callInterceptor, createNamespace, HAPTICS_FEEDBACK } from "../utils/index.mjs";
+import { useRect } from "@vant/use";
+import { useExpose } from "../composables/use-expose.mjs";
+import { Icon } from "../icon/index.mjs";
+import { Swipe } from "../swipe/index.mjs";
+import { Popup } from "../popup/index.mjs";
+import ImagePreviewItem from "./ImagePreviewItem.mjs";
+const [name, bem] = createNamespace("image-preview");
+const popupProps = ["show", "teleport", "transition", "overlayStyle", "closeOnPopstate"];
+const imagePreviewProps = {
+  show: Boolean,
+  loop: truthProp,
+  images: makeArrayProp(),
+  minZoom: makeNumericProp(1 / 3),
+  maxZoom: makeNumericProp(3),
+  overlay: truthProp,
+  vertical: Boolean,
+  closeable: Boolean,
+  showIndex: truthProp,
+  className: unknownProp,
+  closeIcon: makeStringProp("clear"),
+  transition: String,
+  beforeClose: Function,
+  doubleScale: truthProp,
+  overlayClass: unknownProp,
+  overlayStyle: Object,
+  swipeDuration: makeNumericProp(300),
+  startPosition: makeNumericProp(0),
+  showIndicators: Boolean,
+  closeOnPopstate: truthProp,
+  closeOnClickImage: truthProp,
+  closeOnClickOverlay: truthProp,
+  closeIconPosition: makeStringProp("top-right"),
+  teleport: [String, Object]
+};
+var stdin_default = defineComponent({
+  name,
+  props: imagePreviewProps,
+  emits: ["scale", "close", "closed", "change", "longPress", "update:show"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const swipeRef = ref();
+    const activedPreviewItemRef = ref();
+    const state = reactive({
+      active: 0,
+      rootWidth: 0,
+      rootHeight: 0,
+      disableZoom: false
+    });
+    const resize = () => {
+      if (swipeRef.value) {
+        const rect = useRect(swipeRef.value.$el);
+        state.rootWidth = rect.width;
+        state.rootHeight = rect.height;
+        swipeRef.value.resize();
+      }
+    };
+    const emitScale = (args) => emit("scale", args);
+    const updateShow = (show) => emit("update:show", show);
+    const emitClose = () => {
+      callInterceptor(props.beforeClose, {
+        args: [state.active],
+        done: () => updateShow(false)
+      });
+    };
+    const setActive = (active) => {
+      if (active !== state.active) {
+        state.active = active;
+        emit("change", active);
+      }
+    };
+    const renderIndex = () => {
+      if (props.showIndex) {
+        return _createVNode("div", {
+          "class": bem("index")
+        }, [slots.index ? slots.index({
+          index: state.active
+        }) : `${state.active + 1} / ${props.images.length}`]);
+      }
+    };
+    const renderCover = () => {
+      if (slots.cover) {
+        return _createVNode("div", {
+          "class": bem("cover")
+        }, [slots.cover()]);
+      }
+    };
+    const onDragStart = () => {
+      state.disableZoom = true;
+    };
+    const onDragEnd = () => {
+      state.disableZoom = false;
+    };
+    const renderImages = () => _createVNode(Swipe, {
+      "ref": swipeRef,
+      "lazyRender": true,
+      "loop": props.loop,
+      "class": bem("swipe"),
+      "vertical": props.vertical,
+      "duration": props.swipeDuration,
+      "initialSwipe": props.startPosition,
+      "showIndicators": props.showIndicators,
+      "indicatorColor": "white",
+      "onChange": setActive,
+      "onDragEnd": onDragEnd,
+      "onDragStart": onDragStart
+    }, {
+      default: () => [props.images.map((image, index) => _createVNode(ImagePreviewItem, {
+        "ref": (item) => {
+          if (index === state.active) {
+            activedPreviewItemRef.value = item;
+          }
+        },
+        "src": image,
+        "show": props.show,
+        "active": state.active,
+        "maxZoom": props.maxZoom,
+        "minZoom": props.minZoom,
+        "rootWidth": state.rootWidth,
+        "rootHeight": state.rootHeight,
+        "disableZoom": state.disableZoom,
+        "doubleScale": props.doubleScale,
+        "closeOnClickImage": props.closeOnClickImage,
+        "closeOnClickOverlay": props.closeOnClickOverlay,
+        "vertical": props.vertical,
+        "onScale": emitScale,
+        "onClose": emitClose,
+        "onLongPress": () => emit("longPress", {
+          index
+        })
+      }, {
+        image: slots.image
+      }))]
+    });
+    const renderClose = () => {
+      if (props.closeable) {
+        return _createVNode(Icon, {
+          "role": "button",
+          "name": props.closeIcon,
+          "class": [bem("close-icon", props.closeIconPosition), HAPTICS_FEEDBACK],
+          "onClick": emitClose
+        }, null);
+      }
+    };
+    const onClosed = () => emit("closed");
+    const swipeTo = (index, options) => {
+      var _a;
+      return (_a = swipeRef.value) == null ? void 0 : _a.swipeTo(index, options);
+    };
+    useExpose({
+      resetScale: () => {
+        var _a;
+        (_a = activedPreviewItemRef.value) == null ? void 0 : _a.resetScale();
+      },
+      swipeTo
+    });
+    onMounted(resize);
+    watch([windowWidth, windowHeight], resize);
+    watch(() => props.startPosition, (value) => setActive(+value));
+    watch(() => props.show, (value) => {
+      const {
+        images,
+        startPosition
+      } = props;
+      if (value) {
+        setActive(+startPosition);
+        nextTick(() => {
+          resize();
+          swipeTo(+startPosition, {
+            immediate: true
+          });
+        });
+      } else {
+        emit("close", {
+          index: state.active,
+          url: images[state.active]
+        });
+      }
+    });
+    return () => _createVNode(Popup, _mergeProps({
+      "class": [bem(), props.className],
+      "overlayClass": [bem("overlay"), props.overlayClass],
+      "onClosed": onClosed,
+      "onUpdate:show": updateShow
+    }, pick(props, popupProps)), {
+      default: () => [renderClose(), renderImages(), renderIndex(), renderCover()]
+    });
+  }
+});
+export {
+  stdin_default as default,
+  imagePreviewProps
+};

node_modules/vant/es/image-preview/ImagePreviewItem.d.ts

@@ -0,0 +1,91 @@
+import { type ExtractPropTypes } from 'vue';
+declare const imagePreviewItemProps: {
+    src: StringConstructor;
+    show: BooleanConstructor;
+    active: NumberConstructor;
+    minZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: true;
+    };
+    maxZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: true;
+    };
+    rootWidth: {
+        type: NumberConstructor;
+        required: true;
+    };
+    rootHeight: {
+        type: NumberConstructor;
+        required: true;
+    };
+    disableZoom: BooleanConstructor;
+    doubleScale: BooleanConstructor;
+    closeOnClickImage: BooleanConstructor;
+    closeOnClickOverlay: BooleanConstructor;
+    vertical: BooleanConstructor;
+};
+export type ImagePreviewItemProps = ExtractPropTypes<typeof imagePreviewItemProps>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    src: StringConstructor;
+    show: BooleanConstructor;
+    active: NumberConstructor;
+    minZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: true;
+    };
+    maxZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: true;
+    };
+    rootWidth: {
+        type: NumberConstructor;
+        required: true;
+    };
+    rootHeight: {
+        type: NumberConstructor;
+        required: true;
+    };
+    disableZoom: BooleanConstructor;
+    doubleScale: BooleanConstructor;
+    closeOnClickImage: BooleanConstructor;
+    closeOnClickOverlay: BooleanConstructor;
+    vertical: BooleanConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "scale" | "longPress")[], "close" | "scale" | "longPress", import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    src: StringConstructor;
+    show: BooleanConstructor;
+    active: NumberConstructor;
+    minZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: true;
+    };
+    maxZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: true;
+    };
+    rootWidth: {
+        type: NumberConstructor;
+        required: true;
+    };
+    rootHeight: {
+        type: NumberConstructor;
+        required: true;
+    };
+    disableZoom: BooleanConstructor;
+    doubleScale: BooleanConstructor;
+    closeOnClickImage: BooleanConstructor;
+    closeOnClickOverlay: BooleanConstructor;
+    vertical: BooleanConstructor;
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+    onScale?: ((...args: any[]) => any) | undefined;
+    onLongPress?: ((...args: any[]) => any) | undefined;
+}>, {
+    show: boolean;
+    vertical: boolean;
+    closeOnClickOverlay: boolean;
+    disableZoom: boolean;
+    doubleScale: boolean;
+    closeOnClickImage: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

node_modules/vant/es/image-preview/ImagePreviewItem.mjs

@@ -0,0 +1,338 @@
+import { ref, watch, computed, reactive, defineComponent, createVNode as _createVNode } from "vue";
+import { clamp, numericProp, preventDefault, createNamespace, makeRequiredProp, LONG_PRESS_START_TIME } from "../utils/index.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { useTouch } from "../composables/use-touch.mjs";
+import { raf, useEventListener, useRect } from "@vant/use";
+import { Image } from "../image/index.mjs";
+import { Loading } from "../loading/index.mjs";
+import { SwipeItem } from "../swipe-item/index.mjs";
+const getDistance = (touches) => Math.sqrt((touches[0].clientX - touches[1].clientX) ** 2 + (touches[0].clientY - touches[1].clientY) ** 2);
+const getCenter = (touches) => ({
+  x: (touches[0].clientX + touches[1].clientX) / 2,
+  y: (touches[0].clientY + touches[1].clientY) / 2
+});
+const bem = createNamespace("image-preview")[1];
+const longImageRatio = 2.6;
+const imagePreviewItemProps = {
+  src: String,
+  show: Boolean,
+  active: Number,
+  minZoom: makeRequiredProp(numericProp),
+  maxZoom: makeRequiredProp(numericProp),
+  rootWidth: makeRequiredProp(Number),
+  rootHeight: makeRequiredProp(Number),
+  disableZoom: Boolean,
+  doubleScale: Boolean,
+  closeOnClickImage: Boolean,
+  closeOnClickOverlay: Boolean,
+  vertical: Boolean
+};
+var stdin_default = defineComponent({
+  props: imagePreviewItemProps,
+  emits: ["scale", "close", "longPress"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const state = reactive({
+      scale: 1,
+      moveX: 0,
+      moveY: 0,
+      moving: false,
+      zooming: false,
+      initializing: false,
+      imageRatio: 0
+    });
+    const touch = useTouch();
+    const imageRef = ref();
+    const swipeItem = ref();
+    const vertical = ref(false);
+    const isLongImage = ref(false);
+    let initialMoveY = 0;
+    const imageStyle = computed(() => {
+      const {
+        scale,
+        moveX,
+        moveY,
+        moving,
+        zooming,
+        initializing
+      } = state;
+      const style = {
+        transitionDuration: zooming || moving || initializing ? "0s" : ".3s"
+      };
+      if (scale !== 1 || isLongImage.value) {
+        style.transform = `matrix(${scale}, 0, 0, ${scale}, ${moveX}, ${moveY})`;
+      }
+      return style;
+    });
+    const maxMoveX = computed(() => {
+      if (state.imageRatio) {
+        const {
+          rootWidth,
+          rootHeight
+        } = props;
+        const displayWidth = vertical.value ? rootHeight / state.imageRatio : rootWidth;
+        return Math.max(0, (state.scale * displayWidth - rootWidth) / 2);
+      }
+      return 0;
+    });
+    const maxMoveY = computed(() => {
+      if (state.imageRatio) {
+        const {
+          rootWidth,
+          rootHeight
+        } = props;
+        const displayHeight = vertical.value ? rootHeight : rootWidth * state.imageRatio;
+        return Math.max(0, (state.scale * displayHeight - rootHeight) / 2);
+      }
+      return 0;
+    });
+    const setScale = (scale, center) => {
+      var _a;
+      scale = clamp(scale, +props.minZoom, +props.maxZoom + 1);
+      if (scale !== state.scale) {
+        const ratio = scale / state.scale;
+        state.scale = scale;
+        if (center) {
+          const imageRect = useRect((_a = imageRef.value) == null ? void 0 : _a.$el);
+          const origin = {
+            x: imageRect.width * 0.5,
+            y: imageRect.height * 0.5
+          };
+          const moveX = state.moveX - (center.x - imageRect.left - origin.x) * (ratio - 1);
+          const moveY = state.moveY - (center.y - imageRect.top - origin.y) * (ratio - 1);
+          state.moveX = clamp(moveX, -maxMoveX.value, maxMoveX.value);
+          state.moveY = clamp(moveY, -maxMoveY.value, maxMoveY.value);
+        } else {
+          state.moveX = 0;
+          state.moveY = isLongImage.value ? initialMoveY : 0;
+        }
+        emit("scale", {
+          scale,
+          index: props.active
+        });
+      }
+    };
+    const resetScale = () => {
+      setScale(1);
+    };
+    const toggleScale = () => {
+      const scale = state.scale > 1 ? 1 : 2;
+      setScale(scale, scale === 2 || isLongImage.value ? {
+        x: touch.startX.value,
+        y: touch.startY.value
+      } : void 0);
+    };
+    let fingerNum;
+    let startMoveX;
+    let startMoveY;
+    let startScale;
+    let startDistance;
+    let lastCenter;
+    let doubleTapTimer;
+    let touchStartTime;
+    let isImageMoved = false;
+    const onTouchStart = (event) => {
+      const {
+        touches
+      } = event;
+      fingerNum = touches.length;
+      if (fingerNum === 2 && props.disableZoom) {
+        return;
+      }
+      const {
+        offsetX
+      } = touch;
+      touch.start(event);
+      startMoveX = state.moveX;
+      startMoveY = state.moveY;
+      touchStartTime = Date.now();
+      isImageMoved = false;
+      state.moving = fingerNum === 1 && (state.scale !== 1 || isLongImage.value);
+      state.zooming = fingerNum === 2 && !offsetX.value;
+      if (state.zooming) {
+        startScale = state.scale;
+        startDistance = getDistance(touches);
+      }
+    };
+    const onTouchMove = (event) => {
+      const {
+        touches
+      } = event;
+      touch.move(event);
+      if (state.moving) {
+        const {
+          deltaX,
+          deltaY
+        } = touch;
+        const moveX = deltaX.value + startMoveX;
+        const moveY = deltaY.value + startMoveY;
+        if ((props.vertical ? touch.isVertical() && Math.abs(moveY) > maxMoveY.value : touch.isHorizontal() && Math.abs(moveX) > maxMoveX.value) && !isImageMoved) {
+          state.moving = false;
+          return;
+        }
+        isImageMoved = true;
+        preventDefault(event, true);
+        state.moveX = clamp(moveX, -maxMoveX.value, maxMoveX.value);
+        state.moveY = clamp(moveY, -maxMoveY.value, maxMoveY.value);
+      }
+      if (state.zooming) {
+        preventDefault(event, true);
+        if (touches.length === 2) {
+          const distance = getDistance(touches);
+          const scale = startScale * distance / startDistance;
+          lastCenter = getCenter(touches);
+          setScale(scale, lastCenter);
+        }
+      }
+    };
+    const checkClose = (event) => {
+      var _a;
+      const swipeItemEl = (_a = swipeItem.value) == null ? void 0 : _a.$el;
+      if (!swipeItemEl) return;
+      const imageEl = swipeItemEl.firstElementChild;
+      const isClickOverlay = event.target === swipeItemEl;
+      const isClickImage = imageEl == null ? void 0 : imageEl.contains(event.target);
+      if (!props.closeOnClickImage && isClickImage) return;
+      if (!props.closeOnClickOverlay && isClickOverlay) return;
+      emit("close");
+    };
+    const checkTap = (event) => {
+      if (fingerNum > 1) {
+        return;
+      }
+      const deltaTime = Date.now() - touchStartTime;
+      const TAP_TIME = 250;
+      if (touch.isTap.value) {
+        if (deltaTime < TAP_TIME) {
+          if (props.doubleScale) {
+            if (doubleTapTimer) {
+              clearTimeout(doubleTapTimer);
+              doubleTapTimer = null;
+              toggleScale();
+            } else {
+              doubleTapTimer = setTimeout(() => {
+                checkClose(event);
+                doubleTapTimer = null;
+              }, TAP_TIME);
+            }
+          } else {
+            checkClose(event);
+          }
+        } else if (deltaTime > LONG_PRESS_START_TIME) {
+          emit("longPress");
+        }
+      }
+    };
+    const onTouchEnd = (event) => {
+      let stopPropagation = false;
+      if (state.moving || state.zooming) {
+        stopPropagation = true;
+        if (state.moving && startMoveX === state.moveX && startMoveY === state.moveY) {
+          stopPropagation = false;
+        }
+        if (!event.touches.length) {
+          if (state.zooming) {
+            state.moveX = clamp(state.moveX, -maxMoveX.value, maxMoveX.value);
+            state.moveY = clamp(state.moveY, -maxMoveY.value, maxMoveY.value);
+            state.zooming = false;
+          }
+          state.moving = false;
+          startMoveX = 0;
+          startMoveY = 0;
+          startScale = 1;
+          if (state.scale < 1) {
+            resetScale();
+          }
+          const maxZoom = +props.maxZoom;
+          if (state.scale > maxZoom) {
+            setScale(maxZoom, lastCenter);
+          }
+        }
+      }
+      preventDefault(event, stopPropagation);
+      checkTap(event);
+      touch.reset();
+    };
+    const resize = () => {
+      const {
+        rootWidth,
+        rootHeight
+      } = props;
+      const rootRatio = rootHeight / rootWidth;
+      const {
+        imageRatio
+      } = state;
+      vertical.value = state.imageRatio > rootRatio && imageRatio < longImageRatio;
+      isLongImage.value = state.imageRatio > rootRatio && imageRatio >= longImageRatio;
+      if (isLongImage.value) {
+        initialMoveY = (imageRatio * rootWidth - rootHeight) / 2;
+        state.moveY = initialMoveY;
+        state.initializing = true;
+        raf(() => {
+          state.initializing = false;
+        });
+      }
+      resetScale();
+    };
+    const onLoad = (event) => {
+      const {
+        naturalWidth,
+        naturalHeight
+      } = event.target;
+      state.imageRatio = naturalHeight / naturalWidth;
+      resize();
+    };
+    watch(() => props.active, resetScale);
+    watch(() => props.show, (value) => {
+      if (!value) {
+        resetScale();
+      }
+    });
+    watch(() => [props.rootWidth, props.rootHeight], resize);
+    useEventListener("touchmove", onTouchMove, {
+      target: computed(() => {
+        var _a;
+        return (_a = swipeItem.value) == null ? void 0 : _a.$el;
+      })
+    });
+    useExpose({
+      resetScale
+    });
+    return () => {
+      const imageSlots = {
+        loading: () => _createVNode(Loading, {
+          "type": "spinner"
+        }, null)
+      };
+      return _createVNode(SwipeItem, {
+        "ref": swipeItem,
+        "class": bem("swipe-item"),
+        "onTouchstartPassive": onTouchStart,
+        "onTouchend": onTouchEnd,
+        "onTouchcancel": onTouchEnd
+      }, {
+        default: () => [slots.image ? _createVNode("div", {
+          "class": bem("image-wrap")
+        }, [slots.image({
+          src: props.src,
+          onLoad,
+          style: imageStyle.value
+        })]) : _createVNode(Image, {
+          "ref": imageRef,
+          "src": props.src,
+          "fit": "contain",
+          "class": bem("image", {
+            vertical: vertical.value
+          }),
+          "style": imageStyle.value,
+          "onLoad": onLoad
+        }, imageSlots)]
+      });
+    };
+  }
+});
+export {
+  stdin_default as default
+};

node_modules/vant/es/image-preview/function-call.d.ts

@@ -0,0 +1,6 @@
+import { ComponentInstance } from '../utils';
+import type { ImagePreviewOptions } from './types';
+/**
+ * Display a full-screen image preview component
+ */
+export declare const showImagePreview: (options: string[] | ImagePreviewOptions, startPosition?: number) => ComponentInstance | undefined;

node_modules/vant/es/image-preview/function-call.mjs

@@ -0,0 +1,67 @@
+import { mergeProps as _mergeProps, createVNode as _createVNode } from "vue";
+import { extend, inBrowser } from "../utils/index.mjs";
+import { mountComponent, usePopupState } from "../utils/mount-component.mjs";
+import VanImagePreview from "./ImagePreview.mjs";
+let instance;
+const defaultConfig = {
+  loop: true,
+  images: [],
+  maxZoom: 3,
+  minZoom: 1 / 3,
+  onScale: void 0,
+  onClose: void 0,
+  onChange: void 0,
+  vertical: false,
+  teleport: "body",
+  className: "",
+  showIndex: true,
+  closeable: false,
+  closeIcon: "clear",
+  transition: void 0,
+  beforeClose: void 0,
+  doubleScale: true,
+  overlayStyle: void 0,
+  overlayClass: void 0,
+  startPosition: 0,
+  swipeDuration: 300,
+  showIndicators: false,
+  closeOnPopstate: true,
+  closeOnClickOverlay: true,
+  closeIconPosition: "top-right"
+};
+function initInstance() {
+  ({
+    instance
+  } = mountComponent({
+    setup() {
+      const {
+        state,
+        toggle
+      } = usePopupState();
+      const onClosed = () => {
+        state.images = [];
+      };
+      return () => _createVNode(VanImagePreview, _mergeProps(state, {
+        "onClosed": onClosed,
+        "onUpdate:show": toggle
+      }), null);
+    }
+  }));
+}
+const showImagePreview = (options, startPosition = 0) => {
+  if (!inBrowser) {
+    return;
+  }
+  if (!instance) {
+    initInstance();
+  }
+  options = Array.isArray(options) ? {
+    images: options,
+    startPosition
+  } : options;
+  instance.open(extend({}, defaultConfig, options));
+  return instance;
+};
+export {
+  showImagePreview
+};

node_modules/vant/es/image-preview/index.css

@@ -0,0 +1 @@
+:root,:host{--van-image-preview-index-text-color: var(--van-white);--van-image-preview-index-font-size: var(--van-font-size-md);--van-image-preview-index-line-height: var(--van-line-height-md);--van-image-preview-index-text-shadow: 0 1px 1px var(--van-gray-8);--van-image-preview-overlay-background: rgba(0, 0, 0, .9);--van-image-preview-close-icon-size: 22px;--van-image-preview-close-icon-color: var(--van-gray-5);--van-image-preview-close-icon-margin: var(--van-padding-md);--van-image-preview-close-icon-z-index: 1}.van-image-preview{position:fixed;top:0;left:0;width:100%;height:100%;max-width:none;background-color:transparent;transform:none}.van-image-preview__swipe{height:100%}.van-image-preview__swipe-item{display:flex;align-items:center;justify-content:center;overflow:hidden}.van-image-preview__cover{position:absolute;top:0;left:0}.van-image-preview__image,.van-image-preview__image-wrap{width:100%;transition-property:transform}.van-image-preview__image--vertical,.van-image-preview__image-wrap--vertical{width:auto;height:100%}.van-image-preview__image img,.van-image-preview__image-wrap img,.van-image-preview__image video,.van-image-preview__image-wrap video{-webkit-user-drag:none}.van-image-preview__image .van-image__error,.van-image-preview__image-wrap .van-image__error{top:30%;height:40%}.van-image-preview__image .van-image__error-icon,.van-image-preview__image-wrap .van-image__error-icon{font-size:36px}.van-image-preview__image .van-image__loading,.van-image-preview__image-wrap .van-image__loading{background-color:transparent}.van-image-preview__index{position:absolute;top:var(--van-padding-md);left:50%;color:var(--van-image-preview-index-text-color);font-size:var(--van-image-preview-index-font-size);line-height:var(--van-image-preview-index-line-height);text-shadow:var(--van-image-preview-index-text-shadow);transform:translate(-50%)}.van-image-preview__overlay{background:var(--van-image-preview-overlay-background)}.van-image-preview__close-icon{position:absolute;z-index:var(--van-image-preview-close-icon-z-index);color:var(--van-image-preview-close-icon-color);font-size:var(--van-image-preview-close-icon-size)}.van-image-preview__close-icon--top-left{top:var(--van-image-preview-close-icon-margin);left:var(--van-image-preview-close-icon-margin)}.van-image-preview__close-icon--top-right{top:var(--van-image-preview-close-icon-margin);right:var(--van-image-preview-close-icon-margin)}.van-image-preview__close-icon--bottom-left{bottom:var(--van-image-preview-close-icon-margin);left:var(--van-image-preview-close-icon-margin)}.van-image-preview__close-icon--bottom-right{right:var(--van-image-preview-close-icon-margin);bottom:var(--van-image-preview-close-icon-margin)}

node_modules/vant/es/image-preview/index.d.ts

@@ -0,0 +1,172 @@
+import type { ImagePreviewProps } from './ImagePreview';
+export declare const ImagePreview: import("../utils").WithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    show: BooleanConstructor;
+    loop: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    images: {
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+    minZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    maxZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    overlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    vertical: BooleanConstructor;
+    closeable: BooleanConstructor;
+    showIndex: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    className: import("vue").PropType<unknown>;
+    closeIcon: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    transition: StringConstructor;
+    beforeClose: import("vue").PropType<import("../utils").Interceptor>;
+    doubleScale: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    overlayClass: import("vue").PropType<unknown>;
+    overlayStyle: import("vue").PropType<import("vue").CSSProperties>;
+    swipeDuration: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    startPosition: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    showIndicators: BooleanConstructor;
+    closeOnPopstate: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickOverlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeIconPosition: {
+        type: import("vue").PropType<import("..").PopupCloseIconPosition>;
+        default: import("..").PopupCloseIconPosition;
+    };
+    teleport: import("vue").PropType<import("vue").TeleportProps["to"]>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "close" | "closed" | "update:show" | "scale" | "longPress")[], "change" | "close" | "closed" | "update:show" | "scale" | "longPress", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    show: BooleanConstructor;
+    loop: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    images: {
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+    minZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    maxZoom: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    overlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    vertical: BooleanConstructor;
+    closeable: BooleanConstructor;
+    showIndex: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    className: import("vue").PropType<unknown>;
+    closeIcon: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    transition: StringConstructor;
+    beforeClose: import("vue").PropType<import("../utils").Interceptor>;
+    doubleScale: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    overlayClass: import("vue").PropType<unknown>;
+    overlayStyle: import("vue").PropType<import("vue").CSSProperties>;
+    swipeDuration: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    startPosition: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    showIndicators: BooleanConstructor;
+    closeOnPopstate: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeOnClickOverlay: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    closeIconPosition: {
+        type: import("vue").PropType<import("..").PopupCloseIconPosition>;
+        default: import("..").PopupCloseIconPosition;
+    };
+    teleport: import("vue").PropType<import("vue").TeleportProps["to"]>;
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+    onClosed?: ((...args: any[]) => any) | undefined;
+    "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+    onScale?: ((...args: any[]) => any) | undefined;
+    onLongPress?: ((...args: any[]) => any) | undefined;
+}>, {
+    loop: boolean;
+    overlay: boolean;
+    show: boolean;
+    vertical: boolean;
+    closeOnClickOverlay: boolean;
+    closeIcon: string;
+    closeable: boolean;
+    closeOnPopstate: boolean;
+    closeIconPosition: import("..").PopupCloseIconPosition;
+    swipeDuration: string | number;
+    showIndicators: boolean;
+    startPosition: string | number;
+    minZoom: string | number;
+    maxZoom: string | number;
+    doubleScale: boolean;
+    closeOnClickImage: boolean;
+    images: string[];
+    showIndex: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export default ImagePreview;
+export { imagePreviewProps } from './ImagePreview';
+export { showImagePreview } from './function-call';
+export type { ImagePreviewProps };
+export type { ImagePreviewOptions, ImagePreviewInstance, ImagePreviewThemeVars, ImagePreviewScaleEventParams, } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        VanImagePreview: typeof ImagePreview;
+    }
+}

node_modules/vant/es/image-preview/index.mjs

@@ -0,0 +1,12 @@
+import { withInstall } from "../utils/index.mjs";
+import _ImagePreview from "./ImagePreview.mjs";
+const ImagePreview = withInstall(_ImagePreview);
+var stdin_default = ImagePreview;
+import { imagePreviewProps } from "./ImagePreview.mjs";
+import { showImagePreview } from "./function-call.mjs";
+export {
+  ImagePreview,
+  stdin_default as default,
+  imagePreviewProps,
+  showImagePreview
+};

node_modules/vant/es/image-preview/style/index.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/vant/es/image-preview/style/index.mjs

@@ -0,0 +1,10 @@
+import "../../style/base.css";
+import "../../badge/index.css";
+import "../../icon/index.css";
+import "../../image/index.css";
+import "../../loading/index.css";
+import "../../overlay/index.css";
+import "../../popup/index.css";
+import "../../swipe/index.css";
+import "../../swipe-item/index.css";
+import "../index.css";

node_modules/vant/es/image-preview/types.d.ts

@@ -0,0 +1,61 @@
+import type { CSSProperties, TeleportProps, ComponentPublicInstance } from 'vue';
+import type { Interceptor } from '../utils';
+import type { SwipeToOptions } from '../swipe';
+import type { PopupCloseIconPosition } from '../popup';
+import type { ImagePreviewProps } from './ImagePreview';
+import type { ImagePreviewItemProps } from './ImagePreviewItem';
+export type ImagePreviewOptions = {
+    loop?: boolean;
+    images: string[];
+    maxZoom?: number;
+    minZoom?: number;
+    vertical?: boolean;
+    teleport?: TeleportProps['to'];
+    className?: unknown;
+    showIndex?: boolean;
+    closeable?: boolean;
+    closeIcon?: string;
+    transition?: string;
+    beforeClose?: Interceptor;
+    doubleScale?: boolean;
+    overlayStyle?: CSSProperties;
+    overlayClass?: unknown;
+    swipeDuration?: number;
+    startPosition?: number;
+    showIndicators?: boolean;
+    closeOnPopstate?: boolean;
+    closeIconPosition?: PopupCloseIconPosition;
+    closeOnClickImage?: boolean;
+    closeOnClickOverlay?: boolean;
+    onClose?(): void;
+    onScale?(args: {
+        scale: number;
+        index: number;
+    }): void;
+    onChange?(index: number): void;
+};
+export type ImagePreviewScaleEventParams = {
+    scale: number;
+    index: number;
+};
+type ImagePreviewItemExpose = {
+    resetScale: () => void;
+};
+export type ImagePreviewItemInstance = ComponentPublicInstance<ImagePreviewItemProps, ImagePreviewItemExpose>;
+export type ImagePreviewExpose = {
+    resetScale: () => void;
+    swipeTo: (index: number, options?: SwipeToOptions) => void;
+};
+export type ImagePreviewInstance = ComponentPublicInstance<ImagePreviewProps, ImagePreviewExpose>;
+export type ImagePreviewThemeVars = {
+    imagePreviewIndexTextColor?: string;
+    imagePreviewIndexFontSize?: string;
+    imagePreviewIndexLineHeight?: number | string;
+    imagePreviewIndexTextShadow?: string;
+    imagePreviewOverlayBackground?: string;
+    imagePreviewCloseIconSize?: string;
+    imagePreviewCloseIconColor?: string;
+    imagePreviewCloseIconMargin?: string;
+    imagePreviewCloseIconZIndex?: number | string;
+};
+export {};