first commit

node_modules/vant/lib/uploader/Uploader.d.ts

@@ -0,0 +1,217 @@
+import { type PropType, type ExtractPropTypes } from 'vue';
+import { Interceptor, type Numeric } from '../utils';
+import { type ImagePreviewOptions } from '../image-preview';
+import type { UploaderMaxSize, UploaderAfterRead, UploaderBeforeRead, UploaderResultType, UploaderFileListItem } from './types';
+export declare const uploaderProps: {
+    name: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    accept: {
+        type: PropType<string>;
+        default: string;
+    };
+    capture: StringConstructor;
+    multiple: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    lazyLoad: BooleanConstructor;
+    maxCount: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    imageFit: {
+        type: PropType<import("csstype").Property.ObjectFit | undefined>;
+        default: import("csstype").Property.ObjectFit | undefined;
+    };
+    resultType: {
+        type: PropType<UploaderResultType>;
+        default: UploaderResultType;
+    };
+    uploadIcon: {
+        type: PropType<string>;
+        default: string;
+    };
+    uploadText: StringConstructor;
+    deletable: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    reupload: BooleanConstructor;
+    afterRead: PropType<UploaderAfterRead>;
+    showUpload: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    modelValue: {
+        type: PropType<UploaderFileListItem[]>;
+        default: () => never[];
+    };
+    beforeRead: PropType<UploaderBeforeRead>;
+    beforeDelete: PropType<Interceptor>;
+    previewSize: PropType<Numeric | [Numeric, Numeric]>;
+    previewImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    previewOptions: PropType<Partial<ImagePreviewOptions>>;
+    previewFullImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    maxSize: {
+        type: PropType<UploaderMaxSize>;
+        default: number;
+    };
+};
+export type UploaderProps = ExtractPropTypes<typeof uploaderProps>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    name: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    accept: {
+        type: PropType<string>;
+        default: string;
+    };
+    capture: StringConstructor;
+    multiple: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    lazyLoad: BooleanConstructor;
+    maxCount: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    imageFit: {
+        type: PropType<import("csstype").Property.ObjectFit | undefined>;
+        default: import("csstype").Property.ObjectFit | undefined;
+    };
+    resultType: {
+        type: PropType<UploaderResultType>;
+        default: UploaderResultType;
+    };
+    uploadIcon: {
+        type: PropType<string>;
+        default: string;
+    };
+    uploadText: StringConstructor;
+    deletable: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    reupload: BooleanConstructor;
+    afterRead: PropType<UploaderAfterRead>;
+    showUpload: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    modelValue: {
+        type: PropType<UploaderFileListItem[]>;
+        default: () => never[];
+    };
+    beforeRead: PropType<UploaderBeforeRead>;
+    beforeDelete: PropType<Interceptor>;
+    previewSize: PropType<Numeric | [Numeric, Numeric]>;
+    previewImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    previewOptions: PropType<Partial<ImagePreviewOptions>>;
+    previewFullImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    maxSize: {
+        type: PropType<UploaderMaxSize>;
+        default: number;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("delete" | "update:modelValue" | "oversize" | "clickUpload" | "closePreview" | "clickPreview" | "clickReupload")[], "delete" | "update:modelValue" | "oversize" | "clickUpload" | "closePreview" | "clickPreview" | "clickReupload", import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    name: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    accept: {
+        type: PropType<string>;
+        default: string;
+    };
+    capture: StringConstructor;
+    multiple: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    lazyLoad: BooleanConstructor;
+    maxCount: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    imageFit: {
+        type: PropType<import("csstype").Property.ObjectFit | undefined>;
+        default: import("csstype").Property.ObjectFit | undefined;
+    };
+    resultType: {
+        type: PropType<UploaderResultType>;
+        default: UploaderResultType;
+    };
+    uploadIcon: {
+        type: PropType<string>;
+        default: string;
+    };
+    uploadText: StringConstructor;
+    deletable: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    reupload: BooleanConstructor;
+    afterRead: PropType<UploaderAfterRead>;
+    showUpload: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    modelValue: {
+        type: PropType<UploaderFileListItem[]>;
+        default: () => never[];
+    };
+    beforeRead: PropType<UploaderBeforeRead>;
+    beforeDelete: PropType<Interceptor>;
+    previewSize: PropType<Numeric | [Numeric, Numeric]>;
+    previewImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    previewOptions: PropType<Partial<ImagePreviewOptions>>;
+    previewFullImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    maxSize: {
+        type: PropType<UploaderMaxSize>;
+        default: number;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onDelete?: ((...args: any[]) => any) | undefined;
+    onOversize?: ((...args: any[]) => any) | undefined;
+    onClickUpload?: ((...args: any[]) => any) | undefined;
+    onClosePreview?: ((...args: any[]) => any) | undefined;
+    onClickPreview?: ((...args: any[]) => any) | undefined;
+    onClickReupload?: ((...args: any[]) => any) | undefined;
+}>, {
+    name: string | number;
+    accept: string;
+    disabled: boolean;
+    multiple: boolean;
+    modelValue: UploaderFileListItem[];
+    readonly: boolean;
+    lazyLoad: boolean;
+    maxCount: string | number;
+    imageFit: import("csstype").Property.ObjectFit | undefined;
+    resultType: UploaderResultType;
+    uploadIcon: string;
+    deletable: boolean;
+    reupload: boolean;
+    showUpload: boolean;
+    previewImage: boolean;
+    previewFullImage: boolean;
+    maxSize: UploaderMaxSize;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

node_modules/vant/lib/uploader/Uploader.js

@@ -0,0 +1,301 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  default: () => stdin_default,
+  uploaderProps: () => uploaderProps
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_utils = require("../utils");
+var import_utils2 = require("./utils");
+var import_use = require("@vant/use");
+var import_use_expose = require("../composables/use-expose");
+var import_icon = require("../icon");
+var import_image_preview = require("../image-preview");
+var import_UploaderPreviewItem = __toESM(require("./UploaderPreviewItem"));
+const uploaderProps = {
+  name: (0, import_utils.makeNumericProp)(""),
+  accept: (0, import_utils.makeStringProp)("image/*"),
+  capture: String,
+  multiple: Boolean,
+  disabled: Boolean,
+  readonly: Boolean,
+  lazyLoad: Boolean,
+  maxCount: (0, import_utils.makeNumericProp)(Infinity),
+  imageFit: (0, import_utils.makeStringProp)("cover"),
+  resultType: (0, import_utils.makeStringProp)("dataUrl"),
+  uploadIcon: (0, import_utils.makeStringProp)("photograph"),
+  uploadText: String,
+  deletable: import_utils.truthProp,
+  reupload: Boolean,
+  afterRead: Function,
+  showUpload: import_utils.truthProp,
+  modelValue: (0, import_utils.makeArrayProp)(),
+  beforeRead: Function,
+  beforeDelete: Function,
+  previewSize: [Number, String, Array],
+  previewImage: import_utils.truthProp,
+  previewOptions: Object,
+  previewFullImage: import_utils.truthProp,
+  maxSize: {
+    type: [Number, String, Function],
+    default: Infinity
+  }
+};
+var stdin_default = (0, import_vue.defineComponent)({
+  name: import_utils2.name,
+  props: uploaderProps,
+  emits: ["delete", "oversize", "clickUpload", "closePreview", "clickPreview", "clickReupload", "update:modelValue"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const inputRef = (0, import_vue.ref)();
+    const urls = [];
+    const reuploadIndex = (0, import_vue.ref)(-1);
+    const isReuploading = (0, import_vue.ref)(false);
+    const getDetail = (index = props.modelValue.length) => ({
+      name: props.name,
+      index
+    });
+    const resetInput = () => {
+      if (inputRef.value) {
+        inputRef.value.value = "";
+      }
+    };
+    const onAfterRead = (items) => {
+      resetInput();
+      if ((0, import_utils2.isOversize)(items, props.maxSize)) {
+        if (Array.isArray(items)) {
+          const result = (0, import_utils2.filterFiles)(items, props.maxSize);
+          items = result.valid;
+          emit("oversize", result.invalid, getDetail());
+          if (!items.length) {
+            return;
+          }
+        } else {
+          emit("oversize", items, getDetail());
+          return;
+        }
+      }
+      items = (0, import_vue.reactive)(items);
+      if (reuploadIndex.value > -1) {
+        const arr = [...props.modelValue];
+        arr.splice(reuploadIndex.value, 1, items);
+        emit("update:modelValue", arr);
+        reuploadIndex.value = -1;
+      } else {
+        emit("update:modelValue", [...props.modelValue, ...(0, import_utils.toArray)(items)]);
+      }
+      if (props.afterRead) {
+        props.afterRead(items, getDetail());
+      }
+    };
+    const readFile = (files) => {
+      const {
+        maxCount,
+        modelValue,
+        resultType
+      } = props;
+      if (Array.isArray(files)) {
+        const remainCount = +maxCount - modelValue.length;
+        if (files.length > remainCount) {
+          files = files.slice(0, remainCount);
+        }
+        Promise.all(files.map((file) => (0, import_utils2.readFileContent)(file, resultType))).then((contents) => {
+          const fileList = files.map((file, index) => {
+            const result = {
+              file,
+              status: "",
+              message: "",
+              objectUrl: URL.createObjectURL(file)
+            };
+            if (contents[index]) {
+              result.content = contents[index];
+            }
+            return result;
+          });
+          onAfterRead(fileList);
+        });
+      } else {
+        (0, import_utils2.readFileContent)(files, resultType).then((content) => {
+          const result = {
+            file: files,
+            status: "",
+            message: "",
+            objectUrl: URL.createObjectURL(files)
+          };
+          if (content) {
+            result.content = content;
+          }
+          onAfterRead(result);
+        });
+      }
+    };
+    const onChange = (event) => {
+      const {
+        files
+      } = event.target;
+      if (props.disabled || !files || !files.length) {
+        return;
+      }
+      const file = files.length === 1 ? files[0] : [].slice.call(files);
+      if (props.beforeRead) {
+        const response = props.beforeRead(file, getDetail());
+        if (!response) {
+          resetInput();
+          return;
+        }
+        if ((0, import_utils.isPromise)(response)) {
+          response.then((data) => {
+            if (data) {
+              readFile(data);
+            } else {
+              readFile(file);
+            }
+          }).catch(resetInput);
+          return;
+        }
+      }
+      readFile(file);
+    };
+    let imagePreview;
+    const onClosePreview = () => emit("closePreview");
+    const previewImage = (item) => {
+      if (props.previewFullImage) {
+        const imageFiles = props.modelValue.filter(import_utils2.isImageFile);
+        const images = imageFiles.map((item2) => {
+          if (item2.objectUrl && !item2.url && item2.status !== "failed") {
+            item2.url = item2.objectUrl;
+            urls.push(item2.url);
+          }
+          return item2.url;
+        }).filter(Boolean);
+        imagePreview = (0, import_image_preview.showImagePreview)((0, import_utils.extend)({
+          images,
+          startPosition: imageFiles.indexOf(item),
+          onClose: onClosePreview
+        }, props.previewOptions));
+      }
+    };
+    const closeImagePreview = () => {
+      if (imagePreview) {
+        imagePreview.close();
+      }
+    };
+    const deleteFile = (item, index) => {
+      const fileList = props.modelValue.slice(0);
+      fileList.splice(index, 1);
+      emit("update:modelValue", fileList);
+      emit("delete", item, getDetail(index));
+    };
+    const reuploadFile = (index) => {
+      isReuploading.value = true;
+      reuploadIndex.value = index;
+      (0, import_vue.nextTick)(() => chooseFile());
+    };
+    const onInputClick = () => {
+      if (!isReuploading.value) {
+        reuploadIndex.value = -1;
+      }
+      isReuploading.value = false;
+    };
+    const renderPreviewItem = (item, index) => {
+      const needPickData = ["imageFit", "deletable", "reupload", "previewSize", "beforeDelete"];
+      const previewData = (0, import_utils.extend)((0, import_utils.pick)(props, needPickData), (0, import_utils.pick)(item, needPickData, true));
+      return (0, import_vue.createVNode)(import_UploaderPreviewItem.default, (0, import_vue.mergeProps)({
+        "item": item,
+        "index": index,
+        "onClick": () => emit(props.reupload ? "clickReupload" : "clickPreview", item, getDetail(index)),
+        "onDelete": () => deleteFile(item, index),
+        "onPreview": () => previewImage(item),
+        "onReupload": () => reuploadFile(index)
+      }, (0, import_utils.pick)(props, ["name", "lazyLoad"]), previewData), (0, import_utils.pick)(slots, ["preview-cover", "preview-delete"]));
+    };
+    const renderPreviewList = () => {
+      if (props.previewImage) {
+        return props.modelValue.map(renderPreviewItem);
+      }
+    };
+    const onClickUpload = (event) => emit("clickUpload", event);
+    const renderUpload = () => {
+      const lessThanMax = props.modelValue.length < +props.maxCount;
+      const Input = props.readonly ? null : (0, import_vue.createVNode)("input", {
+        "ref": inputRef,
+        "type": "file",
+        "class": (0, import_utils2.bem)("input"),
+        "accept": props.accept,
+        "capture": props.capture,
+        "multiple": props.multiple && reuploadIndex.value === -1,
+        "disabled": props.disabled,
+        "onChange": onChange,
+        "onClick": onInputClick
+      }, null);
+      if (slots.default) {
+        return (0, import_vue.withDirectives)((0, import_vue.createVNode)("div", {
+          "class": (0, import_utils2.bem)("input-wrapper"),
+          "onClick": onClickUpload
+        }, [slots.default(), Input]), [[import_vue.vShow, lessThanMax]]);
+      }
+      return (0, import_vue.withDirectives)((0, import_vue.createVNode)("div", {
+        "class": (0, import_utils2.bem)("upload", {
+          readonly: props.readonly
+        }),
+        "style": (0, import_utils.getSizeStyle)(props.previewSize),
+        "onClick": onClickUpload
+      }, [(0, import_vue.createVNode)(import_icon.Icon, {
+        "name": props.uploadIcon,
+        "class": (0, import_utils2.bem)("upload-icon")
+      }, null), props.uploadText && (0, import_vue.createVNode)("span", {
+        "class": (0, import_utils2.bem)("upload-text")
+      }, [props.uploadText]), Input]), [[import_vue.vShow, props.showUpload && lessThanMax]]);
+    };
+    const chooseFile = () => {
+      if (inputRef.value && !props.disabled) {
+        inputRef.value.click();
+      }
+    };
+    (0, import_vue.onBeforeUnmount)(() => {
+      urls.forEach((url) => URL.revokeObjectURL(url));
+    });
+    (0, import_use_expose.useExpose)({
+      chooseFile,
+      reuploadFile,
+      closeImagePreview
+    });
+    (0, import_use.useCustomFieldValue)(() => props.modelValue);
+    return () => (0, import_vue.createVNode)("div", {
+      "class": (0, import_utils2.bem)()
+    }, [(0, import_vue.createVNode)("div", {
+      "class": (0, import_utils2.bem)("wrapper", {
+        disabled: props.disabled
+      })
+    }, [renderPreviewList(), renderUpload()])]);
+  }
+});

node_modules/vant/lib/uploader/UploaderPreviewItem.d.ts

@@ -0,0 +1,40 @@
+import { type PropType } from 'vue';
+import { type Numeric, type Interceptor } from '../utils';
+import { ImageFit } from '../image';
+import type { UploaderFileListItem } from './types';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: (NumberConstructor | StringConstructor)[];
+    item: {
+        type: PropType<UploaderFileListItem>;
+        required: true;
+    };
+    index: NumberConstructor;
+    imageFit: PropType<ImageFit>;
+    lazyLoad: BooleanConstructor;
+    deletable: BooleanConstructor;
+    reupload: BooleanConstructor;
+    previewSize: PropType<Numeric | [Numeric, Numeric]>;
+    beforeDelete: PropType<Interceptor>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("delete" | "reupload" | "preview")[], "delete" | "reupload" | "preview", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: (NumberConstructor | StringConstructor)[];
+    item: {
+        type: PropType<UploaderFileListItem>;
+        required: true;
+    };
+    index: NumberConstructor;
+    imageFit: PropType<ImageFit>;
+    lazyLoad: BooleanConstructor;
+    deletable: BooleanConstructor;
+    reupload: BooleanConstructor;
+    previewSize: PropType<Numeric | [Numeric, Numeric]>;
+    beforeDelete: PropType<Interceptor>;
+}>> & Readonly<{
+    onDelete?: ((...args: any[]) => any) | undefined;
+    onReupload?: ((...args: any[]) => any) | undefined;
+    onPreview?: ((...args: any[]) => any) | undefined;
+}>, {
+    lazyLoad: boolean;
+    deletable: boolean;
+    reupload: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

node_modules/vant/lib/uploader/UploaderPreviewItem.js

@@ -0,0 +1,149 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  default: () => stdin_default
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_utils = require("./utils");
+var import_utils2 = require("../utils");
+var import_icon = require("../icon");
+var import_image = require("../image");
+var import_loading = require("../loading");
+var stdin_default = (0, import_vue.defineComponent)({
+  props: {
+    name: import_utils2.numericProp,
+    item: (0, import_utils2.makeRequiredProp)(Object),
+    index: Number,
+    imageFit: String,
+    lazyLoad: Boolean,
+    deletable: Boolean,
+    reupload: Boolean,
+    previewSize: [Number, String, Array],
+    beforeDelete: Function
+  },
+  emits: ["delete", "preview", "reupload"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const renderMask = () => {
+      const {
+        status,
+        message
+      } = props.item;
+      if (status === "uploading" || status === "failed") {
+        const MaskIcon = status === "failed" ? (0, import_vue.createVNode)(import_icon.Icon, {
+          "name": "close",
+          "class": (0, import_utils.bem)("mask-icon")
+        }, null) : (0, import_vue.createVNode)(import_loading.Loading, {
+          "class": (0, import_utils.bem)("loading")
+        }, null);
+        const showMessage = (0, import_utils2.isDef)(message) && message !== "";
+        return (0, import_vue.createVNode)("div", {
+          "class": (0, import_utils.bem)("mask")
+        }, [MaskIcon, showMessage && (0, import_vue.createVNode)("div", {
+          "class": (0, import_utils.bem)("mask-message")
+        }, [message])]);
+      }
+    };
+    const onDelete = (event) => {
+      const {
+        name,
+        item,
+        index,
+        beforeDelete
+      } = props;
+      event.stopPropagation();
+      (0, import_utils2.callInterceptor)(beforeDelete, {
+        args: [item, {
+          name,
+          index
+        }],
+        done: () => emit("delete")
+      });
+    };
+    const onPreview = () => emit("preview");
+    const onReupload = () => emit("reupload");
+    const renderDeleteIcon = () => {
+      if (props.deletable && props.item.status !== "uploading") {
+        const slot = slots["preview-delete"];
+        return (0, import_vue.createVNode)("div", {
+          "role": "button",
+          "class": (0, import_utils.bem)("preview-delete", {
+            shadow: !slot
+          }),
+          "tabindex": 0,
+          "aria-label": (0, import_utils.t)("delete"),
+          "onClick": onDelete
+        }, [slot ? slot() : (0, import_vue.createVNode)(import_icon.Icon, {
+          "name": "cross",
+          "class": (0, import_utils.bem)("preview-delete-icon")
+        }, null)]);
+      }
+    };
+    const renderCover = () => {
+      if (slots["preview-cover"]) {
+        const {
+          index,
+          item
+        } = props;
+        return (0, import_vue.createVNode)("div", {
+          "class": (0, import_utils.bem)("preview-cover")
+        }, [slots["preview-cover"]((0, import_utils2.extend)({
+          index
+        }, item))]);
+      }
+    };
+    const renderPreview = () => {
+      const {
+        item,
+        lazyLoad,
+        imageFit,
+        previewSize,
+        reupload
+      } = props;
+      if ((0, import_utils.isImageFile)(item)) {
+        return (0, import_vue.createVNode)(import_image.Image, {
+          "fit": imageFit,
+          "src": item.objectUrl || item.content || item.url,
+          "class": (0, import_utils.bem)("preview-image"),
+          "width": Array.isArray(previewSize) ? previewSize[0] : previewSize,
+          "height": Array.isArray(previewSize) ? previewSize[1] : previewSize,
+          "lazyLoad": lazyLoad,
+          "onClick": reupload ? onReupload : onPreview
+        }, {
+          default: renderCover
+        });
+      }
+      return (0, import_vue.createVNode)("div", {
+        "class": (0, import_utils.bem)("file"),
+        "style": (0, import_utils2.getSizeStyle)(props.previewSize)
+      }, [(0, import_vue.createVNode)(import_icon.Icon, {
+        "class": (0, import_utils.bem)("file-icon"),
+        "name": "description"
+      }, null), (0, import_vue.createVNode)("div", {
+        "class": [(0, import_utils.bem)("file-name"), "van-ellipsis"]
+      }, [item.file ? item.file.name : item.url]), renderCover()]);
+    };
+    return () => (0, import_vue.createVNode)("div", {
+      "class": (0, import_utils.bem)("preview")
+    }, [renderPreview(), renderMask(), renderDeleteIcon()]);
+  }
+});

node_modules/vant/lib/uploader/index.css

@@ -0,0 +1 @@
+:root,:host{--van-uploader-size: 80px;--van-uploader-icon-size: 24px;--van-uploader-icon-color: var(--van-gray-4);--van-uploader-text-color: var(--van-text-color-2);--van-uploader-text-font-size: var(--van-font-size-sm);--van-uploader-upload-background: var(--van-gray-1);--van-uploader-upload-active-color: var(--van-active-color);--van-uploader-delete-color: var(--van-white);--van-uploader-delete-icon-size: 14px;--van-uploader-delete-background: rgba(0, 0, 0, .7);--van-uploader-file-background: var(--van-background);--van-uploader-file-icon-size: 20px;--van-uploader-file-icon-color: var(--van-gray-7);--van-uploader-file-name-padding: 0 var(--van-padding-base);--van-uploader-file-name-margin-top: var(--van-padding-xs);--van-uploader-file-name-font-size: var(--van-font-size-sm);--van-uploader-file-name-text-color: var(--van-gray-7);--van-uploader-mask-text-color: var(--van-white);--van-uploader-mask-background: rgba(50, 50, 51, .88);--van-uploader-mask-icon-size: 22px;--van-uploader-mask-message-font-size: var(--van-font-size-sm);--van-uploader-mask-message-line-height: var(--van-line-height-xs);--van-uploader-loading-icon-size: 22px;--van-uploader-loading-icon-color: var(--van-white);--van-uploader-disabled-opacity: var(--van-disabled-opacity);--van-uploader-border-radius: 0px}.van-uploader{position:relative;display:inline-block}.van-uploader__wrapper{display:flex;flex-wrap:wrap}.van-uploader__wrapper--disabled{opacity:var(--van-uploader-disabled-opacity)}.van-uploader__input{position:absolute;top:0;left:0;width:100%;height:100%;overflow:hidden;cursor:pointer;opacity:0}.van-uploader__input-wrapper{position:relative}.van-uploader__input:disabled{cursor:not-allowed}.van-uploader__upload{position:relative;display:flex;flex-direction:column;align-items:center;justify-content:center;box-sizing:border-box;width:var(--van-uploader-size);height:var(--van-uploader-size);margin:0 var(--van-padding-xs) var(--van-padding-xs) 0;background:var(--van-uploader-upload-background);border-radius:var(--van-uploader-border-radius)}.van-uploader__upload:active{background-color:var(--van-uploader-upload-active-color)}.van-uploader__upload--readonly:active{background-color:var(--van-uploader-upload-background)}.van-uploader__upload-icon{color:var(--van-uploader-icon-color);font-size:var(--van-uploader-icon-size)}.van-uploader__upload-text{margin-top:var(--van-padding-xs);color:var(--van-uploader-text-color);font-size:var(--van-uploader-text-font-size)}.van-uploader__preview{position:relative;margin:0 var(--van-padding-xs) var(--van-padding-xs) 0;cursor:pointer}.van-uploader__preview-image{display:block;width:var(--van-uploader-size);height:var(--van-uploader-size);overflow:hidden;border-radius:var(--van-uploader-border-radius)}.van-uploader__preview-delete{position:absolute;top:0;right:0}.van-uploader__preview-delete--shadow{width:var(--van-uploader-delete-icon-size);height:var(--van-uploader-delete-icon-size);background:var(--van-uploader-delete-background);border-radius:0 0 0 12px}.van-uploader__preview-delete-icon{position:absolute;top:0;right:0;color:var(--van-uploader-delete-color);font-size:var(--van-uploader-delete-icon-size);transform:scale(.7) translate(10%,-10%)}.van-uploader__preview-cover{position:absolute;top:0;right:0;bottom:0;left:0}.van-uploader__mask{position:absolute;top:0;right:0;bottom:0;left:0;display:flex;flex-direction:column;align-items:center;justify-content:center;color:var(--van-uploader-mask-text-color);background:var(--van-uploader-mask-background);border-radius:var(--van-uploader-border-radius)}.van-uploader__mask-icon{font-size:var(--van-uploader-mask-icon-size)}.van-uploader__mask-message{margin-top:6px;padding:0 var(--van-padding-base);font-size:var(--van-uploader-mask-message-font-size);line-height:var(--van-uploader-mask-message-line-height)}.van-uploader__loading{width:var(--van-uploader-loading-icon-size);height:var(--van-uploader-loading-icon-size);color:var(--van-uploader-loading-icon-color)}.van-uploader__file{display:flex;flex-direction:column;align-items:center;justify-content:center;width:var(--van-uploader-size);height:var(--van-uploader-size);background:var(--van-uploader-file-background)}.van-uploader__file-icon{color:var(--van-uploader-file-icon-color);font-size:var(--van-uploader-file-icon-size)}.van-uploader__file-name{box-sizing:border-box;width:100%;margin-top:var(--van-uploader-file-name-margin-top);padding:var(--van-uploader-file-name-padding);color:var(--van-uploader-file-name-text-color);font-size:var(--van-uploader-file-name-font-size);text-align:center}

node_modules/vant/lib/uploader/index.d.ts

@@ -0,0 +1,159 @@
+import { UploaderProps } from './Uploader';
+export declare const Uploader: import("../utils").WithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    accept: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    capture: StringConstructor;
+    multiple: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    lazyLoad: BooleanConstructor;
+    maxCount: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    imageFit: {
+        type: import("vue").PropType<import("csstype").Property.ObjectFit | undefined>;
+        default: import("csstype").Property.ObjectFit | undefined;
+    };
+    resultType: {
+        type: import("vue").PropType<import("./types").UploaderResultType>;
+        default: import("./types").UploaderResultType;
+    };
+    uploadIcon: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    uploadText: StringConstructor;
+    deletable: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    reupload: BooleanConstructor;
+    afterRead: import("vue").PropType<import("./types").UploaderAfterRead>;
+    showUpload: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    modelValue: {
+        type: import("vue").PropType<import("./types").UploaderFileListItem[]>;
+        default: () => never[];
+    };
+    beforeRead: import("vue").PropType<import("./types").UploaderBeforeRead>;
+    beforeDelete: import("vue").PropType<import("../utils").Interceptor>;
+    previewSize: import("vue").PropType<import("../utils").Numeric | [import("../utils").Numeric, import("../utils").Numeric]>;
+    previewImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    previewOptions: import("vue").PropType<Partial<import("..").ImagePreviewOptions>>;
+    previewFullImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    maxSize: {
+        type: import("vue").PropType<import("./types").UploaderMaxSize>;
+        default: number;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("delete" | "update:modelValue" | "oversize" | "clickUpload" | "closePreview" | "clickPreview" | "clickReupload")[], "delete" | "update:modelValue" | "oversize" | "clickUpload" | "closePreview" | "clickPreview" | "clickReupload", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    accept: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    capture: StringConstructor;
+    multiple: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    lazyLoad: BooleanConstructor;
+    maxCount: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    imageFit: {
+        type: import("vue").PropType<import("csstype").Property.ObjectFit | undefined>;
+        default: import("csstype").Property.ObjectFit | undefined;
+    };
+    resultType: {
+        type: import("vue").PropType<import("./types").UploaderResultType>;
+        default: import("./types").UploaderResultType;
+    };
+    uploadIcon: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    uploadText: StringConstructor;
+    deletable: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    reupload: BooleanConstructor;
+    afterRead: import("vue").PropType<import("./types").UploaderAfterRead>;
+    showUpload: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    modelValue: {
+        type: import("vue").PropType<import("./types").UploaderFileListItem[]>;
+        default: () => never[];
+    };
+    beforeRead: import("vue").PropType<import("./types").UploaderBeforeRead>;
+    beforeDelete: import("vue").PropType<import("../utils").Interceptor>;
+    previewSize: import("vue").PropType<import("../utils").Numeric | [import("../utils").Numeric, import("../utils").Numeric]>;
+    previewImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    previewOptions: import("vue").PropType<Partial<import("..").ImagePreviewOptions>>;
+    previewFullImage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    maxSize: {
+        type: import("vue").PropType<import("./types").UploaderMaxSize>;
+        default: number;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onDelete?: ((...args: any[]) => any) | undefined;
+    onOversize?: ((...args: any[]) => any) | undefined;
+    onClickUpload?: ((...args: any[]) => any) | undefined;
+    onClosePreview?: ((...args: any[]) => any) | undefined;
+    onClickPreview?: ((...args: any[]) => any) | undefined;
+    onClickReupload?: ((...args: any[]) => any) | undefined;
+}>, {
+    name: string | number;
+    accept: string;
+    disabled: boolean;
+    multiple: boolean;
+    modelValue: import("./types").UploaderFileListItem[];
+    readonly: boolean;
+    lazyLoad: boolean;
+    maxCount: string | number;
+    imageFit: import("csstype").Property.ObjectFit | undefined;
+    resultType: import("./types").UploaderResultType;
+    uploadIcon: string;
+    deletable: boolean;
+    reupload: boolean;
+    showUpload: boolean;
+    previewImage: boolean;
+    previewFullImage: boolean;
+    maxSize: import("./types").UploaderMaxSize;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export default Uploader;
+export { uploaderProps } from './Uploader';
+export type { UploaderProps };
+export type { UploaderInstance, UploaderThemeVars, UploaderResultType, UploaderFileListItem, UploaderBeforeRead, UploaderAfterRead, } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        VanUploader: typeof Uploader;
+    }
+}

node_modules/vant/lib/uploader/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  Uploader: () => Uploader,
+  default: () => stdin_default,
+  uploaderProps: () => import_Uploader2.uploaderProps
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+var import_Uploader = __toESM(require("./Uploader"));
+var import_Uploader2 = require("./Uploader");
+const Uploader = (0, import_utils.withInstall)(import_Uploader.default);
+var stdin_default = Uploader;

node_modules/vant/lib/uploader/style/index.d.ts

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

node_modules/vant/lib/uploader/style/index.js

@@ -0,0 +1,11 @@
+require("../../style/base.css");
+require("../../badge/index.css");
+require("../../icon/index.css");
+require("../../image/index.css");
+require("../../loading/index.css");
+require("../../overlay/index.css");
+require("../../popup/index.css");
+require("../../swipe/index.css");
+require("../../swipe-item/index.css");
+require("../../image-preview/index.css");
+require("../index.css");

node_modules/vant/lib/uploader/types.d.ts

@@ -0,0 +1,61 @@
+import type { ComponentPublicInstance } from 'vue';
+import type { ImageFit } from '../image';
+import type { Numeric, Interceptor } from '../utils';
+import type { UploaderProps } from './Uploader';
+export type UploaderResultType = 'dataUrl' | 'text' | 'file';
+export type UploaderFileListItem = {
+    url?: string;
+    file?: File;
+    objectUrl?: string;
+    content?: string;
+    isImage?: boolean;
+    status?: '' | 'uploading' | 'done' | 'failed';
+    message?: string;
+    imageFit?: ImageFit;
+    deletable?: boolean;
+    reupload?: boolean;
+    previewSize?: Numeric;
+    beforeDelete?: Interceptor;
+};
+export type UploaderMaxSize = Numeric | ((file: File) => boolean);
+export type UploaderBeforeRead = (file: File | File[], detail: {
+    name: Numeric;
+    index: number;
+}) => boolean | undefined | Promise<File | File[] | undefined>;
+export type UploaderAfterRead = (items: UploaderFileListItem | UploaderFileListItem[], detail: {
+    name: Numeric;
+    index: number;
+}) => void;
+export type UploaderExpose = {
+    chooseFile: () => void;
+    closeImagePreview: () => void;
+    reuploadFile: (index: number) => void;
+};
+export type UploaderInstance = ComponentPublicInstance<UploaderProps, UploaderExpose>;
+export type UploaderThemeVars = {
+    uploaderSize?: string;
+    uploaderIconSize?: string;
+    uploaderIconColor?: string;
+    uploaderTextColor?: string;
+    uploaderTextFontSize?: string;
+    uploaderUploadBackground?: string;
+    uploaderUploadActiveColor?: string;
+    uploaderDeleteColor?: string;
+    uploaderDeleteIconSize?: string;
+    uploaderDeleteBackground?: string;
+    uploaderFileBackground?: string;
+    uploaderFileIconSize?: string;
+    uploaderFileIconColor?: string;
+    uploaderFileNamePadding?: string;
+    uploaderFileNameMarginTop?: string;
+    uploaderFileNameFontSize?: string;
+    uploaderFileNameTextColor?: string;
+    uploaderMaskTextColor?: string;
+    uploaderMaskBackground?: string;
+    uploaderMaskIconSize?: string;
+    uploaderMaskMessageFontSize?: string;
+    uploaderMaskMessageLineHeight?: number | string;
+    uploaderLoadingIconSize?: string;
+    uploaderLoadingIconColor?: string;
+    uploaderDisabledOpacity?: number | string;
+};

node_modules/vant/lib/uploader/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);

node_modules/vant/lib/uploader/utils.d.ts

@@ -0,0 +1,11 @@
+import type { UploaderMaxSize, UploaderResultType, UploaderFileListItem } from './types';
+declare const name: string, bem: (el?: import("../utils").Mods, mods?: import("../utils").Mods) => import("../utils").Mods, t: (path: string, ...args: unknown[]) => any;
+export { name, bem, t };
+export declare function readFileContent(file: File, resultType: UploaderResultType): Promise<string | void>;
+export declare function isOversize(items: UploaderFileListItem | UploaderFileListItem[], maxSize: UploaderMaxSize): boolean;
+export declare function filterFiles(items: UploaderFileListItem[], maxSize: UploaderMaxSize): {
+    valid: UploaderFileListItem[];
+    invalid: UploaderFileListItem[];
+};
+export declare const isImageUrl: (url: string) => boolean;
+export declare function isImageFile(item: UploaderFileListItem): boolean;

node_modules/vant/lib/uploader/utils.js

@@ -0,0 +1,88 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  bem: () => bem,
+  filterFiles: () => filterFiles,
+  isImageFile: () => isImageFile,
+  isImageUrl: () => isImageUrl,
+  isOversize: () => isOversize,
+  name: () => name,
+  readFileContent: () => readFileContent,
+  t: () => t
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+const [name, bem, t] = (0, import_utils.createNamespace)("uploader");
+function readFileContent(file, resultType) {
+  return new Promise((resolve) => {
+    if (resultType === "file") {
+      resolve();
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = (event) => {
+      resolve(event.target.result);
+    };
+    if (resultType === "dataUrl") {
+      reader.readAsDataURL(file);
+    } else if (resultType === "text") {
+      reader.readAsText(file);
+    }
+  });
+}
+function isOversize(items, maxSize) {
+  return (0, import_utils.toArray)(items).some((item) => {
+    if (item.file) {
+      if ((0, import_utils.isFunction)(maxSize)) {
+        return maxSize(item.file);
+      }
+      return item.file.size > +maxSize;
+    }
+    return false;
+  });
+}
+function filterFiles(items, maxSize) {
+  const valid = [];
+  const invalid = [];
+  items.forEach((item) => {
+    if (isOversize(item, maxSize)) {
+      invalid.push(item);
+    } else {
+      valid.push(item);
+    }
+  });
+  return { valid, invalid };
+}
+const IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg|avif)/i;
+const isImageUrl = (url) => IMAGE_REGEXP.test(url);
+function isImageFile(item) {
+  if (item.isImage) {
+    return true;
+  }
+  if (item.file && item.file.type) {
+    return item.file.type.indexOf("image") === 0;
+  }
+  if (item.url) {
+    return isImageUrl(item.url);
+  }
+  if (typeof item.content === "string") {
+    return item.content.indexOf("data:image") === 0;
+  }
+  return false;
+}