widget.qw 1.0.75 → 1.0.77

package/build/widget.qw.umd.js

@@ -4,6 +4,7 @@ var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __pow = Math.pow;
 var __defNormalProp = (obj2, key, value) => key in obj2 ? __defProp(obj2, key, { enumerable: true, configurable: true, writable: true, value }) : obj2[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -1250,13 +1251,13 @@ var __async = (__this, __arguments, generator) => {
   var Axios = Axios_1;
   var mergeConfig = mergeConfig$2;
   var defaults$3 = defaults_1;
-  function createInstance$1(defaultConfig) {
-    var context = new Axios(defaultConfig);
+  function createInstance$1(defaultConfig2) {
+    var context = new Axios(defaultConfig2);
     var instance2 = bind$2(Axios.prototype.request, context);
     utils$3.extend(instance2, Axios.prototype, context);
     utils$3.extend(instance2, context);
     instance2.create = function create(instanceConfig) {
-      return createInstance$1(mergeConfig(defaultConfig, instanceConfig));
+      return createInstance$1(mergeConfig(defaultConfig2, instanceConfig));
     };
     return instance2;
   }
@@ -3381,15 +3382,140 @@ var __async = (__this, __arguments, generator) => {
     type: Boolean,
     default: true
   };
+  const makeRequiredProp = (type) => ({
+    type,
+    required: true
+  });
+  const makeArrayProp = () => ({
+    type: Array,
+    default: () => []
+  });
   const makeNumberProp = (defaultVal) => ({
     type: Number,
     default: defaultVal
   });
+  const makeNumericProp = (defaultVal) => ({
+    type: numericProp,
+    default: defaultVal
+  });
   const makeStringProp = (defaultVal) => ({
     type: String,
     default: defaultVal
   });
   var inBrowser = typeof window !== "undefined";
+  function raf(fn) {
+    return inBrowser ? requestAnimationFrame(fn) : -1;
+  }
+  function doubleRaf(fn) {
+    raf(() => raf(fn));
+  }
+  var isWindow = (val) => val === window;
+  var makeDOMRect = (width2, height2) => ({
+    top: 0,
+    left: 0,
+    right: width2,
+    bottom: height2,
+    width: width2,
+    height: height2
+  });
+  var useRect = (elementOrRef) => {
+    const element = vue.unref(elementOrRef);
+    if (isWindow(element)) {
+      const width2 = element.innerWidth;
+      const height2 = element.innerHeight;
+      return makeDOMRect(width2, height2);
+    }
+    if (element == null ? void 0 : element.getBoundingClientRect) {
+      return element.getBoundingClientRect();
+    }
+    return makeDOMRect(0, 0);
+  };
+  function useParent(key) {
+    const parent = vue.inject(key, null);
+    if (parent) {
+      const instance2 = vue.getCurrentInstance();
+      const { link, unlink, internalChildren } = parent;
+      link(instance2);
+      vue.onUnmounted(() => unlink(instance2));
+      const index = vue.computed(() => internalChildren.indexOf(instance2));
+      return {
+        parent,
+        index
+      };
+    }
+    return {
+      parent: null,
+      index: vue.ref(-1)
+    };
+  }
+  function flattenVNodes(children) {
+    const result = [];
+    const traverse = (children2) => {
+      if (Array.isArray(children2)) {
+        children2.forEach((child) => {
+          var _a;
+          if (vue.isVNode(child)) {
+            result.push(child);
+            if ((_a = child.component) == null ? void 0 : _a.subTree) {
+              result.push(child.component.subTree);
+              traverse(child.component.subTree.children);
+            }
+            if (child.children) {
+              traverse(child.children);
+            }
+          }
+        });
+      }
+    };
+    traverse(children);
+    return result;
+  }
+  var findVNodeIndex = (vnodes, vnode) => {
+    const index = vnodes.indexOf(vnode);
+    if (index === -1) {
+      return vnodes.findIndex((item) => vnode.key !== void 0 && vnode.key !== null && item.type === vnode.type && item.key === vnode.key);
+    }
+    return index;
+  };
+  function sortChildren(parent, publicChildren, internalChildren) {
+    const vnodes = flattenVNodes(parent.subTree.children);
+    internalChildren.sort((a, b) => findVNodeIndex(vnodes, a.vnode) - findVNodeIndex(vnodes, b.vnode));
+    const orderedPublicChildren = internalChildren.map((item) => item.proxy);
+    publicChildren.sort((a, b) => {
+      const indexA = orderedPublicChildren.indexOf(a);
+      const indexB = orderedPublicChildren.indexOf(b);
+      return indexA - indexB;
+    });
+  }
+  function useChildren(key) {
+    const publicChildren = vue.reactive([]);
+    const internalChildren = vue.reactive([]);
+    const parent = vue.getCurrentInstance();
+    const linkChildren = (value) => {
+      const link = (child) => {
+        if (child.proxy) {
+          internalChildren.push(child);
+          publicChildren.push(child.proxy);
+          sortChildren(parent, publicChildren, internalChildren);
+        }
+      };
+      const unlink = (child) => {
+        const index = internalChildren.indexOf(child);
+        publicChildren.splice(index, 1);
+        internalChildren.splice(index, 1);
+      };
+      vue.provide(key, Object.assign({
+        link,
+        unlink,
+        children: publicChildren,
+        internalChildren
+      }, value));
+    };
+    return {
+      children: publicChildren,
+      linkChildren
+    };
+  }
   function onMountedOrActivated(hook) {
     let mounted;
     vue.onMounted(() => {
@@ -3485,6 +3611,20 @@ var __async = (__this, __arguments, generator) => {
     }
     return root;
   }
+  var visibility;
+  function usePageVisibility() {
+    if (!visibility) {
+      visibility = vue.ref("visible");
+      if (inBrowser) {
+        const update = () => {
+          visibility.value = document.hidden ? "hidden" : "visible";
+        };
+        update();
+        window.addEventListener("visibilitychange", update);
+      }
+    }
+    return visibility;
+  }
   isIOS();
   const stopPropagation = (event) => event.stopPropagation();
   function preventDefault(event, isStopPropagation) {
@@ -3495,7 +3635,17 @@ var __async = (__this, __arguments, generator) => {
       stopPropagation(event);
     }
   }
-  useWindowSize();
+  function isHidden(elementRef) {
+    const el = vue.unref(elementRef);
+    if (!el) {
+      return false;
+    }
+    const style = window.getComputedStyle(el);
+    const hidden = style.display === "none";
+    const parentHidden = el.offsetParent === null && style.position !== "fixed";
+    return hidden || parentHidden;
+  }
+  const { width: windowWidth, height: windowHeight } = useWindowSize();
   function addUnit(value) {
     if (isDef$1(value)) {
       return isNumeric(value) ? `${value}px` : String(value);
@@ -3527,6 +3677,7 @@ var __async = (__this, __arguments, generator) => {
   const camelizeRE = /-(\w)/g;
   const camelize = (str) => str.replace(camelizeRE, (_, c) => c.toUpperCase());
   const kebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+  const clamp = (num, min2, max2) => Math.min(Math.max(num, min2), max2);
   const { hasOwnProperty } = Object.prototype;
   function assignKey(to2, from2, key) {
     const val = from2[key];
@@ -3545,7 +3696,7 @@ var __async = (__this, __arguments, generator) => {
     });
     return to2;
   }
-  var stdin_default$8 = {
+  var stdin_default$d = {
     name: "\u59D3\u540D",
     tel: "\u7535\u8BDD",
     save: "\u4FDD\u5B58",
@@ -3609,7 +3760,7 @@ var __async = (__this, __arguments, generator) => {
   };
   const lang$1 = vue.ref("zh-CN");
   const messages = vue.reactive({
-    "zh-CN": stdin_default$8
+    "zh-CN": stdin_default$d
   });
   const Locale$1 = {
     messages() {
@@ -3623,11 +3774,11 @@ var __async = (__this, __arguments, generator) => {
       deepAssign(messages, newMessages);
     }
   };
-  var stdin_default$7 = Locale$1;
+  var stdin_default$c = Locale$1;
   function createTranslate(name2) {
     const prefix = camelize(name2) + ".";
     return (path, ...args) => {
-      const messages2 = stdin_default$7.messages();
+      const messages2 = stdin_default$c.messages();
       const message = get$3(messages2, prefix + path) || get$3(messages2, path);
       return isFunction$1(message) ? message(...args) : message;
     };
@@ -3663,6 +3814,7 @@ var __async = (__this, __arguments, generator) => {
     ];
   }
   const HAPTICS_FEEDBACK = "van-haptics-feedback";
+  const LONG_PRESS_START_TIME = 500;
   const TAP_OFFSET = 5;
   function callInterceptor(interceptor, {
     args = [],
@@ -3700,13 +3852,23 @@ var __async = (__this, __arguments, generator) => {
     return options;
   }
   const POPUP_TOGGLE_KEY = Symbol();
+  function onPopupReopen(callback) {
+    const popupToggleStatus = vue.inject(POPUP_TOGGLE_KEY, null);
+    if (popupToggleStatus) {
+      vue.watch(popupToggleStatus, (show) => {
+        if (show) {
+          callback();
+        }
+      });
+    }
+  }
   function useExpose(apis) {
     const instance2 = vue.getCurrentInstance();
     if (instance2) {
       extend$1(instance2.proxy, apis);
     }
   }
-  const [name$7, bem$7] = createNamespace("badge");
+  const [name$b, bem$c] = createNamespace("badge");
   const badgeProps = {
     dot: Boolean,
     max: numericProp,
@@ -3717,8 +3879,8 @@ var __async = (__this, __arguments, generator) => {
     showZero: truthProp,
     position: makeStringProp("top-right")
   };
-  var stdin_default$6 = vue.defineComponent({
-    name: name$7,
+  var stdin_default$b = vue.defineComponent({
+    name: name$b,
     props: badgeProps,
     setup(props, {
       slots
@@ -3781,7 +3943,7 @@ var __async = (__this, __arguments, generator) => {
       const renderBadge = () => {
         if (hasContent() || props.dot) {
           return vue.createVNode("div", {
-            "class": bem$7([props.position, {
+            "class": bem$c([props.position, {
               dot: props.dot,
               fixed: !!slots.default
             }]),
@@ -3795,7 +3957,7 @@ var __async = (__this, __arguments, generator) => {
             tag
           } = props;
           return vue.createVNode(tag, {
-            "class": bem$7("wrapper")
+            "class": bem$c("wrapper")
           }, {
             default: () => [slots.default(), renderBadge()]
           });
@@ -3804,14 +3966,14 @@ var __async = (__this, __arguments, generator) => {
       };
     }
   });
-  const Badge = withInstall(stdin_default$6);
+  const Badge = withInstall(stdin_default$b);
   let globalZIndex = 2e3;
   const useGlobalZIndex = () => ++globalZIndex;
   const setGlobalZIndex = (val) => {
     globalZIndex = val;
   };
-  const [name$6, bem$6] = createNamespace("config-provider");
-  const CONFIG_PROVIDER_KEY = Symbol(name$6);
+  const [name$a, bem$b] = createNamespace("config-provider");
+  const CONFIG_PROVIDER_KEY = Symbol(name$a);
   const configProviderProps = {
     tag: makeStringProp("div"),
     theme: makeStringProp("light"),
@@ -3846,7 +4008,7 @@ var __async = (__this, __arguments, generator) => {
     });
   }
   vue.defineComponent({
-    name: name$6,
+    name: name$a,
     props: configProviderProps,
     setup(props, {
       slots
@@ -3894,7 +4056,7 @@ var __async = (__this, __arguments, generator) => {
         }
       });
       return () => vue.createVNode(props.tag, {
-        "class": bem$6(),
+        "class": bem$b(),
         "style": props.themeVarsScope === "local" ? style.value : void 0
       }, {
         default: () => {
@@ -3904,7 +4066,7 @@ var __async = (__this, __arguments, generator) => {
       });
     }
   });
-  const [name$5, bem$5] = createNamespace("icon");
+  const [name$9, bem$a] = createNamespace("icon");
   const isImage = (name2) => name2 == null ? void 0 : name2.includes("/");
   const iconProps = {
     dot: Boolean,
@@ -3916,14 +4078,14 @@ var __async = (__this, __arguments, generator) => {
     badgeProps: Object,
     classPrefix: String
   };
-  var stdin_default$5 = vue.defineComponent({
-    name: name$5,
+  var stdin_default$a = vue.defineComponent({
+    name: name$9,
     props: iconProps,
     setup(props, {
       slots
     }) {
       const config = vue.inject(CONFIG_PROVIDER_KEY, null);
-      const classPrefix = vue.computed(() => props.classPrefix || (config == null ? void 0 : config.iconPrefix) || bem$5());
+      const classPrefix = vue.computed(() => props.classPrefix || (config == null ? void 0 : config.iconPrefix) || bem$a());
       return () => {
         const {
           tag,
@@ -3947,7 +4109,7 @@ var __async = (__this, __arguments, generator) => {
           default: () => {
             var _a;
             return [(_a = slots.default) == null ? void 0 : _a.call(slots), isImageIcon && vue.createVNode("img", {
-              "class": bem$5("image"),
+              "class": bem$a("image"),
               "src": name2
             }, null)];
           }
@@ -3955,13 +4117,13 @@ var __async = (__this, __arguments, generator) => {
       };
     }
   });
-  const Icon = withInstall(stdin_default$5);
-  const [name$4, bem$4] = createNamespace("loading");
+  const Icon = withInstall(stdin_default$a);
+  const [name$8, bem$9] = createNamespace("loading");
   const SpinIcon = Array(12).fill(null).map((_, index) => vue.createVNode("i", {
-    "class": bem$4("line", String(index + 1))
+    "class": bem$9("line", String(index + 1))
   }, null));
   const CircularIcon = vue.createVNode("svg", {
-    "class": bem$4("circular"),
+    "class": bem$9("circular"),
     "viewBox": "25 25 50 50"
   }, [vue.createVNode("circle", {
     "cx": "50",
@@ -3977,8 +4139,8 @@ var __async = (__this, __arguments, generator) => {
     textSize: numericProp,
     textColor: String
   };
-  var stdin_default$4 = vue.defineComponent({
-    name: name$4,
+  var stdin_default$9 = vue.defineComponent({
+    name: name$8,
     props: loadingProps,
     setup(props, {
       slots
@@ -3989,7 +4151,7 @@ var __async = (__this, __arguments, generator) => {
       const renderIcon = () => {
         const DefaultIcon = props.type === "spinner" ? SpinIcon : CircularIcon;
         return vue.createVNode("span", {
-          "class": bem$4("spinner", props.type),
+          "class": bem$9("spinner", props.type),
           "style": spinnerStyle.value
         }, [slots.icon ? slots.icon() : DefaultIcon]);
       };
@@ -3997,7 +4159,7 @@ var __async = (__this, __arguments, generator) => {
         var _a;
         if (slots.default) {
           return vue.createVNode("span", {
-            "class": bem$4("text"),
+            "class": bem$9("text"),
             "style": {
               fontSize: addUnit(props.textSize),
               color: (_a = props.textColor) != null ? _a : props.color
@@ -4011,7 +4173,7 @@ var __async = (__this, __arguments, generator) => {
           vertical
         } = props;
         return vue.createVNode("div", {
-          "class": bem$4([type, {
+          "class": bem$9([type, {
             vertical
           }]),
           "aria-live": "polite",
@@ -4020,7 +4182,7 @@ var __async = (__this, __arguments, generator) => {
       };
     }
   });
-  const Loading = withInstall(stdin_default$4);
+  const Loading = withInstall(stdin_default$9);
   const popupSharedProps = {
     show: Boolean,
     zIndex: numericProp,
@@ -4161,7 +4323,7 @@ var __async = (__this, __arguments, generator) => {
     const { scopeId } = ((_a = vue.getCurrentInstance()) == null ? void 0 : _a.vnode) || {};
     return scopeId ? { [scopeId]: "" } : null;
   };
-  const [name$3, bem$3] = createNamespace("overlay");
+  const [name$7, bem$8] = createNamespace("overlay");
   const overlayProps = {
     show: Boolean,
     zIndex: numericProp,
@@ -4172,8 +4334,8 @@ var __async = (__this, __arguments, generator) => {
     customStyle: Object,
     teleport: [String, Object]
   };
-  var stdin_default$3 = vue.defineComponent({
-    name: name$3,
+  var stdin_default$8 = vue.defineComponent({
+    name: name$7,
     inheritAttrs: false,
     props: overlayProps,
     setup(props, {
@@ -4196,7 +4358,7 @@ var __async = (__this, __arguments, generator) => {
         return vue.withDirectives(vue.createVNode("div", vue.mergeProps({
           "ref": root,
           "style": style,
-          "class": [bem$3(), props.className]
+          "class": [bem$8(), props.className]
         }, attrs), [(_a = slots.default) == null ? void 0 : _a.call(slots)]), [[vue.vShow, props.show]]);
       });
       useEventListener("touchmove", onTouchMove, {
@@ -4220,8 +4382,8 @@ var __async = (__this, __arguments, generator) => {
       };
     }
   });
-  const Overlay = withInstall(stdin_default$3);
-  const popupProps = extend$1({}, popupSharedProps, {
+  const Overlay = withInstall(stdin_default$8);
+  const popupProps$1 = extend$1({}, popupSharedProps, {
     round: Boolean,
     position: makeStringProp("center"),
     closeIcon: makeStringProp("cross"),
@@ -4234,11 +4396,11 @@ var __async = (__this, __arguments, generator) => {
     safeAreaInsetTop: Boolean,
     safeAreaInsetBottom: Boolean
   });
-  const [name$2, bem$2] = createNamespace("popup");
-  var stdin_default$2 = vue.defineComponent({
-    name: name$2,
+  const [name$6, bem$7] = createNamespace("popup");
+  var stdin_default$7 = vue.defineComponent({
+    name: name$6,
     inheritAttrs: false,
-    props: popupProps,
+    props: popupProps$1,
     emits: ["open", "close", "opened", "closed", "keydown", "update:show", "clickOverlay", "clickCloseIcon"],
     setup(props, {
       emit,
@@ -4312,7 +4474,7 @@ var __async = (__this, __arguments, generator) => {
             "role": "button",
             "tabindex": 0,
             "name": props.closeIcon,
-            "class": [bem$2("close-icon", props.closeIconPosition), HAPTICS_FEEDBACK],
+            "class": [bem$7("close-icon", props.closeIconPosition), HAPTICS_FEEDBACK],
             "classPrefix": props.iconPrefix,
             "onClick": onClickCloseIcon
           }, null);
@@ -4346,7 +4508,7 @@ var __async = (__this, __arguments, generator) => {
           "style": style.value,
           "role": "dialog",
           "tabindex": 0,
-          "class": [bem$2({
+          "class": [bem$7({
             round: round2,
             [position]: position
           }), {
@@ -4427,7 +4589,443 @@ var __async = (__this, __arguments, generator) => {
       };
     }
   });
-  const Popup = withInstall(stdin_default$2);
+  const Popup = withInstall(stdin_default$7);
+  const [name$5, bem$6] = createNamespace("swipe");
+  const swipeProps = {
+    loop: truthProp,
+    width: numericProp,
+    height: numericProp,
+    vertical: Boolean,
+    autoplay: makeNumericProp(0),
+    duration: makeNumericProp(500),
+    touchable: truthProp,
+    lazyRender: Boolean,
+    initialSwipe: makeNumericProp(0),
+    indicatorColor: String,
+    showIndicators: truthProp,
+    stopPropagation: truthProp
+  };
+  const SWIPE_KEY = Symbol(name$5);
+  var stdin_default$6 = vue.defineComponent({
+    name: name$5,
+    props: swipeProps,
+    emits: ["change", "dragStart", "dragEnd"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const root = vue.ref();
+      const track = vue.ref();
+      const state = vue.reactive({
+        rect: null,
+        width: 0,
+        height: 0,
+        offset: 0,
+        active: 0,
+        swiping: false
+      });
+      let dragging = false;
+      const touch = useTouch();
+      const {
+        children,
+        linkChildren
+      } = useChildren(SWIPE_KEY);
+      const count = vue.computed(() => children.length);
+      const size = vue.computed(() => state[props.vertical ? "height" : "width"]);
+      const delta = vue.computed(() => props.vertical ? touch.deltaY.value : touch.deltaX.value);
+      const minOffset = vue.computed(() => {
+        if (state.rect) {
+          const base = props.vertical ? state.rect.height : state.rect.width;
+          return base - size.value * count.value;
+        }
+        return 0;
+      });
+      const maxCount = vue.computed(() => size.value ? Math.ceil(Math.abs(minOffset.value) / size.value) : count.value);
+      const trackSize = vue.computed(() => count.value * size.value);
+      const activeIndicator = vue.computed(() => (state.active + count.value) % count.value);
+      const isCorrectDirection = vue.computed(() => {
+        const expect = props.vertical ? "vertical" : "horizontal";
+        return touch.direction.value === expect;
+      });
+      const trackStyle = vue.computed(() => {
+        const style = {
+          transitionDuration: `${state.swiping ? 0 : props.duration}ms`,
+          transform: `translate${props.vertical ? "Y" : "X"}(${+state.offset.toFixed(2)}px)`
+        };
+        if (size.value) {
+          const mainAxis = props.vertical ? "height" : "width";
+          const crossAxis = props.vertical ? "width" : "height";
+          style[mainAxis] = `${trackSize.value}px`;
+          style[crossAxis] = props[crossAxis] ? `${props[crossAxis]}px` : "";
+        }
+        return style;
+      });
+      const getTargetActive = (pace) => {
+        const {
+          active
+        } = state;
+        if (pace) {
+          if (props.loop) {
+            return clamp(active + pace, -1, count.value);
+          }
+          return clamp(active + pace, 0, maxCount.value);
+        }
+        return active;
+      };
+      const getTargetOffset = (targetActive, offset2 = 0) => {
+        let currentPosition = targetActive * size.value;
+        if (!props.loop) {
+          currentPosition = Math.min(currentPosition, -minOffset.value);
+        }
+        let targetOffset = offset2 - currentPosition;
+        if (!props.loop) {
+          targetOffset = clamp(targetOffset, minOffset.value, 0);
+        }
+        return targetOffset;
+      };
+      const move = ({
+        pace = 0,
+        offset: offset2 = 0,
+        emitChange
+      }) => {
+        if (count.value <= 1) {
+          return;
+        }
+        const {
+          active
+        } = state;
+        const targetActive = getTargetActive(pace);
+        const targetOffset = getTargetOffset(targetActive, offset2);
+        if (props.loop) {
+          if (children[0] && targetOffset !== minOffset.value) {
+            const outRightBound = targetOffset < minOffset.value;
+            children[0].setOffset(outRightBound ? trackSize.value : 0);
+          }
+          if (children[count.value - 1] && targetOffset !== 0) {
+            const outLeftBound = targetOffset > 0;
+            children[count.value - 1].setOffset(outLeftBound ? -trackSize.value : 0);
+          }
+        }
+        state.active = targetActive;
+        state.offset = targetOffset;
+        if (emitChange && targetActive !== active) {
+          emit("change", activeIndicator.value);
+        }
+      };
+      const correctPosition = () => {
+        state.swiping = true;
+        if (state.active <= -1) {
+          move({
+            pace: count.value
+          });
+        } else if (state.active >= count.value) {
+          move({
+            pace: -count.value
+          });
+        }
+      };
+      const prev = () => {
+        correctPosition();
+        touch.reset();
+        doubleRaf(() => {
+          state.swiping = false;
+          move({
+            pace: -1,
+            emitChange: true
+          });
+        });
+      };
+      const next = () => {
+        correctPosition();
+        touch.reset();
+        doubleRaf(() => {
+          state.swiping = false;
+          move({
+            pace: 1,
+            emitChange: true
+          });
+        });
+      };
+      let autoplayTimer;
+      const stopAutoplay = () => clearTimeout(autoplayTimer);
+      const autoplay = () => {
+        stopAutoplay();
+        if (+props.autoplay > 0 && count.value > 1) {
+          autoplayTimer = setTimeout(() => {
+            next();
+            autoplay();
+          }, +props.autoplay);
+        }
+      };
+      const initialize = (active = +props.initialSwipe) => {
+        if (!root.value) {
+          return;
+        }
+        const cb = () => {
+          var _a, _b;
+          if (!isHidden(root)) {
+            const rect = {
+              width: root.value.offsetWidth,
+              height: root.value.offsetHeight
+            };
+            state.rect = rect;
+            state.width = +((_a = props.width) != null ? _a : rect.width);
+            state.height = +((_b = props.height) != null ? _b : rect.height);
+          }
+          if (count.value) {
+            active = Math.min(count.value - 1, active);
+            if (active === -1) {
+              active = count.value - 1;
+            }
+          }
+          state.active = active;
+          state.swiping = true;
+          state.offset = getTargetOffset(active);
+          children.forEach((swipe) => {
+            swipe.setOffset(0);
+          });
+          autoplay();
+        };
+        if (isHidden(root)) {
+          vue.nextTick().then(cb);
+        } else {
+          cb();
+        }
+      };
+      const resize = () => initialize(state.active);
+      let touchStartTime;
+      const onTouchStart = (event) => {
+        if (!props.touchable || event.touches.length > 1)
+          return;
+        touch.start(event);
+        dragging = false;
+        touchStartTime = Date.now();
+        stopAutoplay();
+        correctPosition();
+      };
+      const onTouchMove = (event) => {
+        if (props.touchable && state.swiping) {
+          touch.move(event);
+          if (isCorrectDirection.value) {
+            const isEdgeTouch = !props.loop && (state.active === 0 && delta.value > 0 || state.active === count.value - 1 && delta.value < 0);
+            if (!isEdgeTouch) {
+              preventDefault(event, props.stopPropagation);
+              move({
+                offset: delta.value
+              });
+              if (!dragging) {
+                emit("dragStart", {
+                  index: activeIndicator.value
+                });
+                dragging = true;
+              }
+            }
+          }
+        }
+      };
+      const onTouchEnd = () => {
+        if (!props.touchable || !state.swiping) {
+          return;
+        }
+        const duration = Date.now() - touchStartTime;
+        const speed = delta.value / duration;
+        const shouldSwipe = Math.abs(speed) > 0.25 || Math.abs(delta.value) > size.value / 2;
+        if (shouldSwipe && isCorrectDirection.value) {
+          const offset2 = props.vertical ? touch.offsetY.value : touch.offsetX.value;
+          let pace = 0;
+          if (props.loop) {
+            pace = offset2 > 0 ? delta.value > 0 ? -1 : 1 : 0;
+          } else {
+            pace = -Math[delta.value > 0 ? "ceil" : "floor"](delta.value / size.value);
+          }
+          move({
+            pace,
+            emitChange: true
+          });
+        } else if (delta.value) {
+          move({
+            pace: 0
+          });
+        }
+        dragging = false;
+        state.swiping = false;
+        emit("dragEnd", {
+          index: activeIndicator.value
+        });
+        autoplay();
+      };
+      const swipeTo = (index, options = {}) => {
+        correctPosition();
+        touch.reset();
+        doubleRaf(() => {
+          let targetIndex;
+          if (props.loop && index === count.value) {
+            targetIndex = state.active === 0 ? 0 : index;
+          } else {
+            targetIndex = index % count.value;
+          }
+          if (options.immediate) {
+            doubleRaf(() => {
+              state.swiping = false;
+            });
+          } else {
+            state.swiping = false;
+          }
+          move({
+            pace: targetIndex - state.active,
+            emitChange: true
+          });
+        });
+      };
+      const renderDot = (_, index) => {
+        const active = index === activeIndicator.value;
+        const style = active ? {
+          backgroundColor: props.indicatorColor
+        } : void 0;
+        return vue.createVNode("i", {
+          "style": style,
+          "class": bem$6("indicator", {
+            active
+          })
+        }, null);
+      };
+      const renderIndicator = () => {
+        if (slots.indicator) {
+          return slots.indicator({
+            active: activeIndicator.value,
+            total: count.value
+          });
+        }
+        if (props.showIndicators && count.value > 1) {
+          return vue.createVNode("div", {
+            "class": bem$6("indicators", {
+              vertical: props.vertical
+            })
+          }, [Array(count.value).fill("").map(renderDot)]);
+        }
+      };
+      useExpose({
+        prev,
+        next,
+        state,
+        resize,
+        swipeTo
+      });
+      linkChildren({
+        size,
+        props,
+        count,
+        activeIndicator
+      });
+      vue.watch(() => props.initialSwipe, (value) => initialize(+value));
+      vue.watch(count, () => initialize(state.active));
+      vue.watch(() => props.autoplay, autoplay);
+      vue.watch([windowWidth, windowHeight, () => props.width, () => props.height], resize);
+      vue.watch(usePageVisibility(), (visible) => {
+        if (visible === "visible") {
+          autoplay();
+        } else {
+          stopAutoplay();
+        }
+      });
+      vue.onMounted(initialize);
+      vue.onActivated(() => initialize(state.active));
+      onPopupReopen(() => initialize(state.active));
+      vue.onDeactivated(stopAutoplay);
+      vue.onBeforeUnmount(stopAutoplay);
+      useEventListener("touchmove", onTouchMove, {
+        target: track
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "ref": root,
+          "class": bem$6()
+        }, [vue.createVNode("div", {
+          "ref": track,
+          "style": trackStyle.value,
+          "class": bem$6("track", {
+            vertical: props.vertical
+          }),
+          "onTouchstartPassive": onTouchStart,
+          "onTouchend": onTouchEnd,
+          "onTouchcancel": onTouchEnd
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]), renderIndicator()]);
+      };
+    }
+  });
+  const Swipe = withInstall(stdin_default$6);
+  const [name$4, bem$5] = createNamespace("swipe-item");
+  var stdin_default$5 = vue.defineComponent({
+    name: name$4,
+    setup(props, {
+      slots
+    }) {
+      let rendered;
+      const state = vue.reactive({
+        offset: 0,
+        inited: false,
+        mounted: false
+      });
+      const {
+        parent,
+        index
+      } = useParent(SWIPE_KEY);
+      if (!parent) {
+        return;
+      }
+      const style = vue.computed(() => {
+        const style2 = {};
+        const {
+          vertical
+        } = parent.props;
+        if (parent.size.value) {
+          style2[vertical ? "height" : "width"] = `${parent.size.value}px`;
+        }
+        if (state.offset) {
+          style2.transform = `translate${vertical ? "Y" : "X"}(${state.offset}px)`;
+        }
+        return style2;
+      });
+      const shouldRender = vue.computed(() => {
+        const {
+          loop,
+          lazyRender
+        } = parent.props;
+        if (!lazyRender || rendered) {
+          return true;
+        }
+        if (!state.mounted) {
+          return false;
+        }
+        const active = parent.activeIndicator.value;
+        const maxActive = parent.count.value - 1;
+        const prevActive = active === 0 && loop ? maxActive : active - 1;
+        const nextActive = active === maxActive && loop ? 0 : active + 1;
+        rendered = index.value === active || index.value === prevActive || index.value === nextActive;
+        return rendered;
+      });
+      const setOffset = (offset2) => {
+        state.offset = offset2;
+      };
+      vue.onMounted(() => {
+        vue.nextTick(() => {
+          state.mounted = true;
+        });
+      });
+      useExpose({
+        setOffset
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "class": bem$5(),
+          "style": style.value
+        }, [shouldRender.value ? (_a = slots.default) == null ? void 0 : _a.call(slots) : null]);
+      };
+    }
+  });
+  const SwipeItem = withInstall(stdin_default$5);
   let lockCount = 0;
   function lockClick(lock) {
     if (lock) {
@@ -4442,7 +5040,7 @@ var __async = (__this, __arguments, generator) => {
       }
     }
   }
-  const [name$1, bem$1] = createNamespace("toast");
+  const [name$3, bem$4] = createNamespace("toast");
   const popupInheritProps$1 = ["show", "overlay", "teleport", "transition", "overlayClass", "overlayStyle", "closeOnClickOverlay", "zIndex"];
   const toastProps = {
     icon: String,
@@ -4466,8 +5064,8 @@ var __async = (__this, __arguments, generator) => {
     closeOnClickOverlay: Boolean,
     zIndex: numericProp
   };
-  var stdin_default$1 = vue.defineComponent({
-    name: name$1,
+  var stdin_default$4 = vue.defineComponent({
+    name: name$3,
     props: toastProps,
     emits: ["update:show"],
     setup(props, {
@@ -4503,13 +5101,13 @@ var __async = (__this, __arguments, generator) => {
           return vue.createVNode(Icon, {
             "name": icon || type,
             "size": iconSize,
-            "class": bem$1("icon"),
+            "class": bem$4("icon"),
             "classPrefix": iconPrefix
           }, null);
         }
         if (type === "loading") {
           return vue.createVNode(Loading, {
-            "class": bem$1("loading"),
+            "class": bem$4("loading"),
             "size": iconSize,
             "type": loadingType
           }, null);
@@ -4522,16 +5120,16 @@ var __async = (__this, __arguments, generator) => {
         } = props;
         if (slots.message) {
           return vue.createVNode("div", {
-            "class": bem$1("text")
+            "class": bem$4("text")
           }, [slots.message()]);
         }
         if (isDef$1(message) && message !== "") {
           return type === "html" ? vue.createVNode("div", {
             "key": 0,
-            "class": bem$1("text"),
+            "class": bem$4("text"),
             "innerHTML": String(message)
           }, null) : vue.createVNode("div", {
-            "class": bem$1("text")
+            "class": bem$4("text")
           }, [message]);
         }
       };
@@ -4547,7 +5145,7 @@ var __async = (__this, __arguments, generator) => {
       vue.onMounted(toggleClickable);
       vue.onUnmounted(toggleClickable);
       return () => vue.createVNode(Popup, vue.mergeProps({
-        "class": [bem$1([props.position, props.wordBreak === "normal" ? "break-normal" : props.wordBreak, {
+        "class": [bem$4([props.position, props.wordBreak === "normal" ? "break-normal" : props.wordBreak, {
           [props.type]: !props.icon
         }]), props.className],
         "lockScroll": false,
@@ -4644,7 +5242,7 @@ var __async = (__this, __arguments, generator) => {
             onClosed,
             "onUpdate:show": toggle
           };
-          return vue.createVNode(stdin_default$1, vue.mergeProps(state, attrs), null);
+          return vue.createVNode(stdin_default$4, vue.mergeProps(state, attrs), null);
         };
         vue.watch(message, (val) => {
           state.message = val;
@@ -4700,6 +5298,751 @@ var __async = (__this, __arguments, generator) => {
       extend$1(currentOptions$1, type);
     }
   }
+  withInstall(stdin_default$4);
+  const [name$2, bem$3] = createNamespace("image");
+  const imageProps = {
+    src: String,
+    alt: String,
+    fit: String,
+    position: String,
+    round: Boolean,
+    block: Boolean,
+    width: numericProp,
+    height: numericProp,
+    radius: numericProp,
+    lazyLoad: Boolean,
+    iconSize: numericProp,
+    showError: truthProp,
+    errorIcon: makeStringProp("photo-fail"),
+    iconPrefix: String,
+    showLoading: truthProp,
+    loadingIcon: makeStringProp("photo"),
+    crossorigin: String,
+    referrerpolicy: String,
+    decoding: String
+  };
+  var stdin_default$3 = vue.defineComponent({
+    name: name$2,
+    props: imageProps,
+    emits: ["load", "error"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const error = vue.ref(false);
+      const loading = vue.ref(true);
+      const imageRef = vue.ref();
+      const {
+        $Lazyload
+      } = vue.getCurrentInstance().proxy;
+      const style = vue.computed(() => {
+        const style2 = {
+          width: addUnit(props.width),
+          height: addUnit(props.height)
+        };
+        if (isDef$1(props.radius)) {
+          style2.overflow = "hidden";
+          style2.borderRadius = addUnit(props.radius);
+        }
+        return style2;
+      });
+      vue.watch(() => props.src, () => {
+        error.value = false;
+        loading.value = true;
+      });
+      const onLoad = (event) => {
+        if (loading.value) {
+          loading.value = false;
+          emit("load", event);
+        }
+      };
+      const triggerLoad = () => {
+        const loadEvent = new Event("load");
+        Object.defineProperty(loadEvent, "target", {
+          value: imageRef.value,
+          enumerable: true
+        });
+        onLoad(loadEvent);
+      };
+      const onError = (event) => {
+        error.value = true;
+        loading.value = false;
+        emit("error", event);
+      };
+      const renderIcon = (name2, className, slot) => {
+        if (slot) {
+          return slot();
+        }
+        return vue.createVNode(Icon, {
+          "name": name2,
+          "size": props.iconSize,
+          "class": className,
+          "classPrefix": props.iconPrefix
+        }, null);
+      };
+      const renderPlaceholder = () => {
+        if (loading.value && props.showLoading) {
+          return vue.createVNode("div", {
+            "class": bem$3("loading")
+          }, [renderIcon(props.loadingIcon, bem$3("loading-icon"), slots.loading)]);
+        }
+        if (error.value && props.showError) {
+          return vue.createVNode("div", {
+            "class": bem$3("error")
+          }, [renderIcon(props.errorIcon, bem$3("error-icon"), slots.error)]);
+        }
+      };
+      const renderImage = () => {
+        if (error.value || !props.src) {
+          return;
+        }
+        const attrs = {
+          alt: props.alt,
+          class: bem$3("img"),
+          decoding: props.decoding,
+          style: {
+            objectFit: props.fit,
+            objectPosition: props.position
+          },
+          crossorigin: props.crossorigin,
+          referrerpolicy: props.referrerpolicy
+        };
+        if (props.lazyLoad) {
+          return vue.withDirectives(vue.createVNode("img", vue.mergeProps({
+            "ref": imageRef
+          }, attrs), null), [[vue.resolveDirective("lazy"), props.src]]);
+        }
+        return vue.createVNode("img", vue.mergeProps({
+          "ref": imageRef,
+          "src": props.src,
+          "onLoad": onLoad,
+          "onError": onError
+        }, attrs), null);
+      };
+      const onLazyLoaded = ({
+        el
+      }) => {
+        const check = () => {
+          if (el === imageRef.value && loading.value) {
+            triggerLoad();
+          }
+        };
+        if (imageRef.value) {
+          check();
+        } else {
+          vue.nextTick(check);
+        }
+      };
+      const onLazyLoadError = ({
+        el
+      }) => {
+        if (el === imageRef.value && !error.value) {
+          onError();
+        }
+      };
+      if ($Lazyload && inBrowser$1) {
+        $Lazyload.$on("loaded", onLazyLoaded);
+        $Lazyload.$on("error", onLazyLoadError);
+        vue.onBeforeUnmount(() => {
+          $Lazyload.$off("loaded", onLazyLoaded);
+          $Lazyload.$off("error", onLazyLoadError);
+        });
+      }
+      vue.onMounted(() => {
+        vue.nextTick(() => {
+          var _a;
+          if (((_a = imageRef.value) == null ? void 0 : _a.complete) && !props.lazyLoad) {
+            triggerLoad();
+          }
+        });
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "class": bem$3({
+            round: props.round,
+            block: props.block
+          }),
+          "style": style.value
+        }, [renderImage(), renderPlaceholder(), (_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const Image$1 = withInstall(stdin_default$3);
+  const getDistance = (touches) => Math.sqrt(__pow(touches[0].clientX - touches[1].clientX, 2) + __pow(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$2 = 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$2 = vue.defineComponent({
+    props: imagePreviewItemProps,
+    emits: ["scale", "close", "longPress"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const state = vue.reactive({
+        scale: 1,
+        moveX: 0,
+        moveY: 0,
+        moving: false,
+        zooming: false,
+        initializing: false,
+        imageRatio: 0
+      });
+      const touch = useTouch();
+      const imageRef = vue.ref();
+      const swipeItem = vue.ref();
+      const vertical = vue.ref(false);
+      const isLongImage = vue.ref(false);
+      let initialMoveY = 0;
+      const imageStyle = vue.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 = vue.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 = vue.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 stopPropagation2 = false;
+        if (state.moving || state.zooming) {
+          stopPropagation2 = true;
+          if (state.moving && startMoveX === state.moveX && startMoveY === state.moveY) {
+            stopPropagation2 = 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, stopPropagation2);
+        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();
+      };
+      vue.watch(() => props.active, resetScale);
+      vue.watch(() => props.show, (value) => {
+        if (!value) {
+          resetScale();
+        }
+      });
+      vue.watch(() => [props.rootWidth, props.rootHeight], resize);
+      useEventListener("touchmove", onTouchMove, {
+        target: vue.computed(() => {
+          var _a;
+          return (_a = swipeItem.value) == null ? void 0 : _a.$el;
+        })
+      });
+      useExpose({
+        resetScale
+      });
+      return () => {
+        const imageSlots = {
+          loading: () => vue.createVNode(Loading, {
+            "type": "spinner"
+          }, null)
+        };
+        return vue.createVNode(SwipeItem, {
+          "ref": swipeItem,
+          "class": bem$2("swipe-item"),
+          "onTouchstartPassive": onTouchStart,
+          "onTouchend": onTouchEnd,
+          "onTouchcancel": onTouchEnd
+        }, {
+          default: () => [slots.image ? vue.createVNode("div", {
+            "class": bem$2("image-wrap")
+          }, [slots.image({
+            src: props.src,
+            onLoad,
+            style: imageStyle.value
+          })]) : vue.createVNode(Image$1, {
+            "ref": imageRef,
+            "src": props.src,
+            "fit": "contain",
+            "class": bem$2("image", {
+              vertical: vertical.value
+            }),
+            "style": imageStyle.value,
+            "onLoad": onLoad
+          }, imageSlots)]
+        });
+      };
+    }
+  });
+  const [name$1, bem$1] = 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$1 = vue.defineComponent({
+    name: name$1,
+    props: imagePreviewProps,
+    emits: ["scale", "close", "closed", "change", "longPress", "update:show"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const swipeRef = vue.ref();
+      const activedPreviewItemRef = vue.ref();
+      const state = vue.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 vue.createVNode("div", {
+            "class": bem$1("index")
+          }, [slots.index ? slots.index({
+            index: state.active
+          }) : `${state.active + 1} / ${props.images.length}`]);
+        }
+      };
+      const renderCover = () => {
+        if (slots.cover) {
+          return vue.createVNode("div", {
+            "class": bem$1("cover")
+          }, [slots.cover()]);
+        }
+      };
+      const onDragStart = () => {
+        state.disableZoom = true;
+      };
+      const onDragEnd = () => {
+        state.disableZoom = false;
+      };
+      const renderImages = () => vue.createVNode(Swipe, {
+        "ref": swipeRef,
+        "lazyRender": true,
+        "loop": props.loop,
+        "class": bem$1("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) => vue.createVNode(stdin_default$2, {
+          "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 vue.createVNode(Icon, {
+            "role": "button",
+            "name": props.closeIcon,
+            "class": [bem$1("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
+      });
+      vue.onMounted(resize);
+      vue.watch([windowWidth, windowHeight], resize);
+      vue.watch(() => props.startPosition, (value) => setActive(+value));
+      vue.watch(() => props.show, (value) => {
+        const {
+          images,
+          startPosition
+        } = props;
+        if (value) {
+          setActive(+startPosition);
+          vue.nextTick(() => {
+            resize();
+            swipeTo(+startPosition, {
+              immediate: true
+            });
+          });
+        } else {
+          emit("close", {
+            index: state.active,
+            url: images[state.active]
+          });
+        }
+      });
+      return () => vue.createVNode(Popup, vue.mergeProps({
+        "class": [bem$1(), props.className],
+        "overlayClass": [bem$1("overlay"), props.overlayClass],
+        "onClosed": onClosed,
+        "onUpdate:show": updateShow
+      }, pick(props, popupProps)), {
+        default: () => [renderClose(), renderImages(), renderIndex(), renderCover()]
+      });
+    }
+  });
+  let instance$1;
+  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$1() {
+    ({
+      instance: instance$1
+    } = mountComponent({
+      setup() {
+        const {
+          state,
+          toggle
+        } = usePopupState();
+        const onClosed = () => {
+          state.images = [];
+        };
+        return () => vue.createVNode(stdin_default$1, vue.mergeProps(state, {
+          "onClosed": onClosed,
+          "onUpdate:show": toggle
+        }), null);
+      }
+    }));
+  }
+  const showImagePreview = (options, startPosition = 0) => {
+    if (!inBrowser$1) {
+      return;
+    }
+    if (!instance$1) {
+      initInstance$1();
+    }
+    options = Array.isArray(options) ? {
+      images: options,
+      startPosition
+    } : options;
+    instance$1.open(extend$1({}, defaultConfig, options));
+    return instance$1;
+  };
   withInstall(stdin_default$1);
   const [name, bem] = createNamespace("notify");
   const popupInheritProps = ["lockScroll", "position", "show", "teleport", "zIndex"];
@@ -14785,7 +16128,7 @@ var __async = (__this, __arguments, generator) => {
         function valuesIn(object) {
           return object == null ? [] : baseValues(object, keysIn(object));
         }
-        function clamp(number, lower, upper) {
+        function clamp2(number, lower, upper) {
           if (upper === undefined$12) {
             upper = lower;
             lower = undefined$12;
@@ -15459,7 +16802,7 @@ var __async = (__this, __arguments, generator) => {
         lodash2.camelCase = camelCase;
         lodash2.capitalize = capitalize;
         lodash2.ceil = ceil;
-        lodash2.clamp = clamp;
+        lodash2.clamp = clamp2;
         lodash2.clone = clone2;
         lodash2.cloneDeep = cloneDeep;
         lodash2.cloneDeepWith = cloneDeepWith;
@@ -15797,7 +17140,7 @@ var __async = (__this, __arguments, generator) => {
   const _hoisted_1$k = {
     class: "widget"
   };
-  const _hoisted_2$c = /* @__PURE__ */ vue.createTextVNode("\u9A73\u56DE");
+  const _hoisted_2$d = /* @__PURE__ */ vue.createTextVNode("\u9A73\u56DE");
   const _hoisted_3$a = /* @__PURE__ */ vue.createTextVNode("\u63D0\u4EA4");
   const _hoisted_4$9 = /* @__PURE__ */ vue.createTextVNode("\u7533\u8BF7");
   const _hoisted_5$9 = {
@@ -16095,7 +17438,7 @@ var __async = (__this, __arguments, generator) => {
             type: "danger",
             onClick: onRefuse
           }, {
-            default: vue.withCtx(() => [_hoisted_2$c]),
+            default: vue.withCtx(() => [_hoisted_2$d]),
             _: 1
           })]),
           _: 1
@@ -16429,7 +17772,7 @@ var __async = (__this, __arguments, generator) => {
   const _hoisted_1$j = {
     class: "select-all-container"
   };
-  const _hoisted_2$b = /* @__PURE__ */ vue.createTextVNode("\u5168\u9009");
+  const _hoisted_2$c = /* @__PURE__ */ vue.createTextVNode("\u5168\u9009");
   const _hoisted_3$9 = {
     class: "checkbox-list"
   };
@@ -16487,7 +17830,7 @@ var __async = (__this, __arguments, generator) => {
             onClick: onToggleAll,
             "label-position": "left"
           }, {
-            default: vue.withCtx(() => [_hoisted_2$b]),
+            default: vue.withCtx(() => [_hoisted_2$c]),
             _: 1
           }, 8, ["modelValue"])]), vue.createElementVNode("div", _hoisted_3$9, [vue.createVNode(_component_van_checkbox_group, {
             modelValue: vue.unref(modelValue),
@@ -17188,7 +18531,7 @@ var __async = (__this, __arguments, generator) => {
   const _hoisted_1$h = {
     class: "pad10 flex-between showMultipleButton"
   };
-  const _hoisted_2$a = /* @__PURE__ */ vue.createTextVNode("\u53D6\u6D88");
+  const _hoisted_2$b = /* @__PURE__ */ vue.createTextVNode("\u53D6\u6D88");
   const _hoisted_3$8 = {
     class: "bold"
   };
@@ -17427,7 +18770,7 @@ var __async = (__this, __arguments, generator) => {
             size: "normal",
             onClick: cancelSelection
           }, {
-            default: vue.withCtx(() => [_hoisted_2$a]),
+            default: vue.withCtx(() => [_hoisted_2$b]),
             _: 1
           }), vue.createElementVNode("div", _hoisted_3$8, vue.toDisplayString(__props.label), 1), vue.createVNode(_component_van_button, {
             plain: "",
@@ -17516,7 +18859,7 @@ var __async = (__this, __arguments, generator) => {
     key: 0,
     class: "confirmation-tips"
   };
-  const _hoisted_2$9 = {
+  const _hoisted_2$a = {
     class: "option-text"
   };
   const _sfc_main$m = {
@@ -17575,7 +18918,7 @@ var __async = (__this, __arguments, generator) => {
               "icon-size": "18px",
               class: "custom-checkbox"
             }, {
-              default: vue.withCtx(() => [vue.createElementVNode("span", _hoisted_2$9, vue.toDisplayString(item.label), 1)]),
+              default: vue.withCtx(() => [vue.createElementVNode("span", _hoisted_2$a, vue.toDisplayString(item.label), 1)]),
               _: 2
             }, 1032, ["name"])]);
           }), 128))]),
@@ -17589,7 +18932,7 @@ var __async = (__this, __arguments, generator) => {
   const _hoisted_1$f = {
     class: "department-selector"
   };
-  const _hoisted_2$8 = {
+  const _hoisted_2$9 = {
     class: "popup-container"
   };
   const _hoisted_3$7 = {
@@ -17876,7 +19219,7 @@ var __async = (__this, __arguments, generator) => {
           position: "bottom",
           class: "department-popup"
         }, {
-          default: vue.withCtx(() => [vue.createElementVNode("div", _hoisted_2$8, [vue.createElementVNode("div", _hoisted_3$7, [vue.unref(currentLevel) > 0 ? (vue.openBlock(), vue.createBlock(_component_van_button, {
+          default: vue.withCtx(() => [vue.createElementVNode("div", _hoisted_2$9, [vue.createElementVNode("div", _hoisted_3$7, [vue.unref(currentLevel) > 0 ? (vue.openBlock(), vue.createBlock(_component_van_button, {
             key: 0,
             onClick: goBack,
             icon: "arrow-left",
@@ -17949,7 +19292,7 @@ var __async = (__this, __arguments, generator) => {
   const _hoisted_1$e = {
     class: "user-selector"
   };
-  const _hoisted_2$7 = {
+  const _hoisted_2$8 = {
     class: "popup-container"
   };
   const _hoisted_3$6 = {
@@ -18348,7 +19691,7 @@ var __async = (__this, __arguments, generator) => {
           position: "bottom",
           class: "user-popup"
         }, {
-          default: vue.withCtx(() => [vue.createElementVNode("div", _hoisted_2$7, [vue.createElementVNode("div", _hoisted_3$6, [vue.createElementVNode("div", _hoisted_4$6, [vue.unref(currentLevel) > 0 ? (vue.openBlock(), vue.createBlock(_component_van_button, {
+          default: vue.withCtx(() => [vue.createElementVNode("div", _hoisted_2$8, [vue.createElementVNode("div", _hoisted_3$6, [vue.createElementVNode("div", _hoisted_4$6, [vue.unref(currentLevel) > 0 ? (vue.openBlock(), vue.createBlock(_component_van_button, {
             key: 0,
             onClick: goBack,
             icon: "arrow-left",
@@ -18603,10 +19946,11 @@ var __async = (__this, __arguments, generator) => {
     }
   };
   var ImagePicker = /* @__PURE__ */ _export_sfc(_sfc_main$j, [["__scopeId", "data-v-16be97a4"]]);
-  var images_picker_vue_vue_type_style_index_0_scoped_true_lang = /* @__PURE__ */ (() => ".widget[data-v-8fca1c96] {\n  text-align: center;\n}\n.widget .btn[data-v-8fca1c96] {\n  position: fixed;\n  bottom: 1rem;\n  left: 0;\n  right: 0;\n  margin: auto auto;\n  color: white;\n  font-size: 14px;\n  background: rgb(58, 136, 255);\n  padding: 8px 35px;\n  width: 100px;\n  text-align: center;\n  display: inline-block;\n  border-radius: 2px;\n}")();
+  var images_picker_vue_vue_type_style_index_0_scoped_true_lang = /* @__PURE__ */ (() => ".image-box .cover[data-v-dc257922] {\n  width: 80px;\n  height: 80px;\n}")();
   const _hoisted_1$c = {
     class: "image-box"
   };
+  const _hoisted_2$7 = ["src", "onClick"];
   const _sfc_main$i = {
     __name: "images_picker",
     props: {
@@ -18640,7 +19984,7 @@ var __async = (__this, __arguments, generator) => {
       },
       max: {
         type: Number,
-        default: 1e3
+        default: 1e4
       },
       rules: {
         type: Array,
@@ -18649,6 +19993,10 @@ var __async = (__this, __arguments, generator) => {
       auth: {
         type: String,
         default: ""
+      },
+      maxPreview: {
+        type: Number,
+        default: 1
       }
     },
     emits: ["update:modelValue"],
@@ -18656,7 +20004,7 @@ var __async = (__this, __arguments, generator) => {
       emit
     }) {
       const props = __props;
-      useVModel(props, "modelValue", emit);
+      const modelValue = useVModel(props, "modelValue", emit);
       const {
         isRequired,
         isReadonly,
@@ -18664,6 +20012,14 @@ var __async = (__this, __arguments, generator) => {
         isDisabled
       } = util.props2auth(props);
       const files = vue.ref([]);
+      const isPreviewMore = vue.ref(false);
+      const previews = vue.computed(() => {
+        if (!modelValue.value || modelValue.value.length < 1)
+          return [];
+        if (props.maxPreview > modelValue.value.length || isPreviewMore.value)
+          return modelValue.value;
+        return modelValue.value.slice(0, props.maxPreview);
+      });
       vue.onMounted(() => {
       });
       const onAfterRead = (file) => __async(this, null, function* () {
@@ -18692,6 +20048,15 @@ var __async = (__this, __arguments, generator) => {
         emit("update:modelValue", newUrls);
         return Promise.resolve(e);
       };
+      const onPreview = (i) => {
+        showImagePreview({
+          images: modelValue.value,
+          startPosition: i
+        });
+      };
+      const onToggleMore = () => {
+        isPreviewMore.value = !isPreviewMore.value;
+      };
       vue.watch(() => props.modelValue, (newVal, oldVal) => {
         if (!props.modelValue || props.modelValue.length < 1) {
           files.value = [];
@@ -18708,6 +20073,7 @@ var __async = (__this, __arguments, generator) => {
       });
       return (_ctx, _cache) => {
         const _component_van_uploader = vue.resolveComponent("van-uploader");
+        const _component_van_icon = vue.resolveComponent("van-icon");
         const _component_van_field = vue.resolveComponent("van-field");
         return vue.openBlock(), vue.createBlock(_component_van_field, {
           name: "image",
@@ -18717,7 +20083,7 @@ var __async = (__this, __arguments, generator) => {
           "label-class": "label",
           placeholder: props.placeholder
         }, {
-          input: vue.withCtx(() => [vue.createElementVNode("div", _hoisted_1$c, [props.capture ? (vue.openBlock(), vue.createBlock(_component_van_uploader, {
+          input: vue.withCtx(() => [vue.createElementVNode("div", _hoisted_1$c, [props.capture && !vue.unref(isReadonly) && !vue.unref(isDisabled) ? (vue.openBlock(), vue.createBlock(_component_van_uploader, {
             key: 0,
             modelValue: files.value,
             "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => files.value = $event),
@@ -18729,7 +20095,7 @@ var __async = (__this, __arguments, generator) => {
             afterRead: onAfterRead,
             "before-delete": onBeforeDelete,
             "show-upload": !vue.unref(isReadonly)
-          }, null, 8, ["modelValue", "max-count", "capture", "disabled", "deletable", "show-upload"])) : (vue.openBlock(), vue.createBlock(_component_van_uploader, {
+          }, null, 8, ["modelValue", "max-count", "capture", "disabled", "deletable", "show-upload"])) : vue.createCommentVNode("", true), !props.capture && !vue.unref(isReadonly) && !vue.unref(isDisabled) ? (vue.openBlock(), vue.createBlock(_component_van_uploader, {
             key: 1,
             modelValue: files.value,
             "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => files.value = $event),
@@ -18740,14 +20106,27 @@ var __async = (__this, __arguments, generator) => {
             afterRead: onAfterRead,
             "before-delete": onBeforeDelete,
             "show-upload": !vue.unref(isReadonly)
-          }, null, 8, ["modelValue", "max-count", "disabled", "deletable", "show-upload"]))])]),
+          }, null, 8, ["modelValue", "max-count", "disabled", "deletable", "show-upload"])) : vue.createCommentVNode("", true), vue.unref(isReadonly) || vue.unref(isDisabled) ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, {
+            key: 2
+          }, vue.renderList(vue.unref(previews), (cover, i) => {
+            return vue.openBlock(), vue.createElementBlock("img", {
+              class: "cover",
+              key: i,
+              src: cover,
+              onClick: ($event) => onPreview(i)
+            }, null, 8, _hoisted_2$7);
+          }), 128)) : vue.createCommentVNode("", true), vue.unref(modelValue).length > props.maxPreview && (vue.unref(isReadonly) || vue.unref(isDisabled)) ? (vue.openBlock(), vue.createBlock(_component_van_icon, {
+            key: 3,
+            name: "ellipsis",
+            onClick: onToggleMore
+          })) : vue.createCommentVNode("", true)])]),
           _: 1
         }, 8, ["label", "required", "rules", "placeholder"]);
       };
     }
   };
-  var ImagesPicker = /* @__PURE__ */ _export_sfc(_sfc_main$i, [["__scopeId", "data-v-8fca1c96"]]);
-  var FilePicker_vue_vue_type_style_index_0_scoped_true_lang = /* @__PURE__ */ (() => "[data-v-54cbbc7a] .label {\n  color: #000 !important;\n}\n[data-v-54cbbc7a] .van-field__control:disabled {\n  color: #000 !important;\n  cursor: not-allowed;\n  opacity: 1;\n  -webkit-text-fill-color: #000;\n}")();
+  var ImagesPicker = /* @__PURE__ */ _export_sfc(_sfc_main$i, [["__scopeId", "data-v-dc257922"]]);
+  var FilePicker_vue_vue_type_style_index_0_scoped_true_lang = /* @__PURE__ */ (() => "[data-v-df75f4fa] .label {\n  color: #000 !important;\n}\n[data-v-df75f4fa] .van-field__control:disabled {\n  color: #000 !important;\n  cursor: not-allowed;\n  opacity: 1;\n  -webkit-text-fill-color: #000;\n}")();
   const _hoisted_1$b = {
     class: "file-box"
   };
@@ -18766,6 +20145,10 @@ var __async = (__this, __arguments, generator) => {
         type: Boolean,
         default: false
       },
+      maxCount: {
+        type: Number,
+        default: 1e3
+      },
       required: {
         type: Boolean,
         default: false
@@ -18804,6 +20187,12 @@ var __async = (__this, __arguments, generator) => {
         isDisabled
       } = util.props2auth(props);
       const files = vue.ref([]);
+      const maxCount = vue.computed(() => {
+        if (props.multiple)
+          return props.maxCount;
+        else
+          return 1;
+      });
       vue.onMounted(() => {
       });
       const onClickPreview = (e) => {
@@ -18812,20 +20201,34 @@ var __async = (__this, __arguments, generator) => {
           return;
         window.location.href = e.url;
       };
-      const onAfterRead = (file) => __async(this, null, function* () {
-        console.log(file);
-        let params = {
-          file: file.file
-        };
-        return util.file_upload(params).then((res) => {
-          if (props.multiple)
-            modelValue.value = [...modelValue.value || [], res.data];
-          else
+      const onAfterRead = (e) => __async(this, null, function* () {
+        console.log("onAfterRead", e);
+        if (props.multiple) {
+          if (e && e.length > 0) {
+            for (var i = 0; i < e.length; i++) {
+              let params = {
+                file: e[i].file
+              };
+              let res = yield util.file_upload(params);
+              if (res.code == 200) {
+                modelValue.value = [...modelValue.value || [], res.data];
+              }
+            }
+            return Promise.resolve(e);
+          }
+        } else {
+          let params = {
+            file: e.file
+          };
+          let res = yield util.file_upload(params);
+          if (res.code == 200) {
             modelValue.value = res.data;
-          return Promise.resolve(file);
-        });
+            return Promise.resolve(e);
+          }
+        }
       });
       const onBeforeDelete = (e) => {
+        console.log("onBeforeDelete", e);
         if (props.multiple) {
           let newUrls = props.modelValue.filter((item) => {
             return item != e.url;
@@ -18874,7 +20277,8 @@ var __async = (__this, __arguments, generator) => {
           input: vue.withCtx(() => [vue.createElementVNode("div", _hoisted_1$b, [vue.createVNode(_component_van_uploader, {
             modelValue: files.value,
             "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => files.value = $event),
-            "max-count": props.max,
+            multiple: props.multiple,
+            "max-count": vue.unref(maxCount),
             afterRead: onAfterRead,
             disabled: vue.unref(isDisabled),
             accept: props.accept,
@@ -18882,13 +20286,13 @@ var __async = (__this, __arguments, generator) => {
             deletable: !vue.unref(isDisabled),
             "before-delete": onBeforeDelete,
             onClickPreview
-          }, null, 8, ["modelValue", "max-count", "disabled", "accept", "deletable"])])]),
+          }, null, 8, ["modelValue", "multiple", "max-count", "disabled", "accept", "deletable"])])]),
           _: 1
         }, 8, ["label", "required", "rules", "placeholder"])) : vue.createCommentVNode("", true);
       };
     }
   };
-  var FilePicker = /* @__PURE__ */ _export_sfc(_sfc_main$h, [["__scopeId", "data-v-54cbbc7a"]]);
+  var FilePicker = /* @__PURE__ */ _export_sfc(_sfc_main$h, [["__scopeId", "data-v-df75f4fa"]]);
   var SingleUserSelector_vue_vue_type_style_index_0_scoped_true_lang = /* @__PURE__ */ (() => "\n.user-popup[data-v-a489ca4c] {\r\n  width: 100%;\r\n  overflow: hidden;\n}\n.department-selector[data-v-a489ca4c] {\r\n  padding: 10px;\n}\n.search-buttons[data-v-a489ca4c] {\r\n  display: flex;\r\n  gap: 10px;\n}\n.clear-btn[data-v-a489ca4c] {\r\n  background-color: #f2f3f5;\r\n  border: none;\r\n  border-radius: 4px;\r\n  padding: 4px 8px;\r\n  font-size: 14px;\n}\n.confirm-btn[data-v-a489ca4c] {\r\n  background-color: #1989fa;\r\n  color: white;\r\n  border: none;\r\n  border-radius: 4px;\r\n  padding: 4px 8px;\r\n  font-size: 14px;\n}\n.no-results[data-v-a489ca4c] {\r\n  text-align: center;\r\n  padding: 20px;\r\n  color: #969799;\n}\n.picker-header[data-v-a489ca4c] {\r\n  padding: 10px;\r\n  border-bottom: 1px solid #ebedf0;\r\n  display: flex;\r\n  justify-content: space-between;\r\n  align-items: center;\n}\n.current-path[data-v-a489ca4c] {\r\n  flex: 1;\r\n  font-size: 14px;\r\n  color: #323233;\r\n  white-space: nowrap;\r\n  overflow: hidden;\r\n  text-overflow: ellipsis;\n}\n.header-right[data-v-a489ca4c] {\r\n  display: flex;\r\n  gap: 8px;\r\n  margin-left: auto;\n}\n.cancel-btn[data-v-a489ca4c] {\r\n  color: #969799;\r\n  margin-right: 5px;\n}\n.scroll-container[data-v-a489ca4c] {\r\n  height: calc(80vh - 150px);\r\n  overflow-y: auto;\n}\r\n")();
   const _hoisted_1$a = {
     class: "department-selector"