第一次

.hbuilderx/launch.json

@@ -0,0 +1,9 @@
+{
+    "version" : "1.0",
+    "configurations" : [
+        {
+            "playground" : "custom",
+            "type" : "uni-app:app-android"
+        }
+    ]
+}

App.vue

@@ -0,0 +1,17 @@
+<script>
+	export default {
+		onLaunch: function() {
+			console.log('App Launch')
+		},
+		onShow: function() {
+			console.log('App Show')
+		},
+		onHide: function() {
+			console.log('App Hide')
+		}
+	}
+</script>
+
+<style>
+	/*每个页面公共css */
+</style>

hybrid/html/openMap/js/lib/common.js

@@ -0,0 +1,92 @@
+/**
+ * MapID
+ * 
+ * 
+ * */
+var MAPID = 'c0248134c43b27bf'
+
+/**
+ * 
+ * 获取url地址参数
+ * 
+ * */
+
+function getQueryVariable(variable) {
+	var query = decodeURI(window.location.search.substring(1));
+	var vars = query.split("&");
+	for (var i = 0; i < vars.length; i++) {
+		var pair = vars[i].split("=");
+		if (pair[0] == variable) {
+			return pair[1];
+		}
+	}
+	return (false);
+}
+
+
+
+/**
+ * 随机生成颜色rgb值
+ * 
+ * */
+
+function getRandomColor() {
+	const letters = '0123456789ABCDEF'; // 16进制颜色表示中可能出现的字符
+	let color = '#';
+	for (let i = 0; i < 6; i++) { // 随机生成6位十六进制数
+		color += letters[Math.floor(Math.random() * 16)]; // 根据随机数选取相应的字符
+	}
+	return color;
+}
+
+
+/**
+ * 随机生成中文文字
+ * 辅助方法 实际中可废弃
+ * */
+function randomChinese(num) {
+
+	let str = "";
+	const words = ["Lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit", "sed", "do",
+		"eiusmod", "tempor",
+		"incididunt", "ut", "labore", "et", "dolore", "magna", "aliqua", "Ut", "enim", "ad", "minim", "veniam",
+		"quis",
+		"nostrud", "exercitation", "ullamco", "laboris", "nisi", "ut", "aliquip", "ex", "ea", "commodo",
+		"consequat",
+		"Duis", "aute", "irure", "dolor", "in", "reprehenderit", "in", "voluptate", "velit", "esse", "cillum",
+		"dolore",
+		"eu", "fugiat", "nulla", "pariatur", "Excepteur", "sint", "occaecat", "cupidatat", "non", "proident",
+		"sunt",
+		"in", "culpa", "qui", "officia", "deserunt", "mollit", "anim", "id", "est", "laborum"
+	];
+	for (let i = 0; i < num; i++) {
+		const randomWord = words[Math.floor(Math.random() * words.length)];
+		str += randomWord + " ";
+	}
+	return str.trim();
+}
+
+
+/**
+ * 加载动画
+ * 
+ */
+function LoadAnimation(isFalse) {
+	if (isFalse) {
+		document.getElementById("loader").style.display = "inline";
+	} else {
+		document.getElementById("loader").style.display = "none";
+	}
+
+}
+
+
+
+// export default {
+// 	LoadAnimation,
+// 	randomChinese,
+// 	getRandomColor,
+// 	getQueryVariable,
+// 	getMapID
+
+// }

hybrid/html/openMap/js/lib/rem.js

@@ -0,0 +1,26 @@
+!(function(window) {
+  /* 设计图文档宽度 */
+  var docWidth = 750;
+  var doc = window.document,
+    docEl = doc.documentElement,
+    resizeEvt = 'orientationchange' in window ? 'orientationchange' : 'resize';
+  var recalc = (function refreshRem() {
+    var clientWidth = docEl.getBoundingClientRect().width;
+    /* 8.55：小于320px不再缩小，11.2：大于420px不再放大 */
+    docEl.style.fontSize = Math.max(Math.min(20 * (clientWidth / docWidth), 11.2), 8.55) * 5 + 'px';
+    return refreshRem;
+  })();
+  /* 添加倍屏标识，安卓为1 */
+  docEl.setAttribute('data-dpr', window.navigator.appVersion.match(/iphone/gi) ? window.devicePixelRatio : 1);
+  if (/iP(hone|od|ad)/.test(window.navigator.userAgent)) {
+    /* 添加IOS标识 */
+    doc.documentElement.classList.add('ios');
+    /* IOS8以上给html添加hairline样式，以便特殊处理 */
+    if (parseInt(window.navigator.appVersion.match(/OS (\d+)_(\d+)_?(\d+)?/)[1], 10) >= 8)
+      doc.documentElement.classList.add('hairline');
+  }
+  if (!doc.addEventListener)
+    return;
+  window.addEventListener(resizeEvt, recalc, false);
+  doc.addEventListener('DOMContentLoaded', recalc, false);
+})(window);

hybrid/html/openMap/js/lib/vant.js

@@ -0,0 +1,16810 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("vue")) : typeof define === "function" && define.amd ? define(["exports", "vue"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.vant = {}, global.Vue));
+})(this, function(exports2, vue) {
+  "use strict";
+  const isDef = (val) => val !== void 0 && val !== null;
+  const isFunction = (val) => typeof val === "function";
+  const isObject = (val) => val !== null && typeof val === "object";
+  const isPromise = (val) => isObject(val) && isFunction(val.then) && isFunction(val.catch);
+  const isDate = (val) => Object.prototype.toString.call(val) === "[object Date]" && !Number.isNaN(val.getTime());
+  function isMobile(value) {
+    value = value.replace(/[^-|\d]/g, "");
+    return /^((\+86)|(86))?(1)\d{10}$/.test(value) || /^0[0-9-]{10,13}$/.test(value);
+  }
+  const isNumeric = (val) => typeof val === "number" || /^\d+(\.\d+)?$/.test(val);
+  const isIOS$1 = () => inBrowser$1 ? /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase()) : false;
+  function noop() {
+  }
+  const extend = Object.assign;
+  const inBrowser$1 = typeof window !== "undefined";
+  function get(object, path) {
+    const keys = path.split(".");
+    let result = object;
+    keys.forEach((key) => {
+      var _a;
+      result = isObject(result) ? (_a = result[key]) != null ? _a : "" : "";
+    });
+    return result;
+  }
+  function pick(obj, keys, ignoreUndefined) {
+    return keys.reduce((ret, key) => {
+      if (!ignoreUndefined || obj[key] !== void 0) {
+        ret[key] = obj[key];
+      }
+      return ret;
+    }, {});
+  }
+  const isSameValue = (newValue, oldValue) => JSON.stringify(newValue) === JSON.stringify(oldValue);
+  const toArray = (item) => Array.isArray(item) ? item : [item];
+  const unknownProp = null;
+  const numericProp = [Number, String];
+  const truthProp = {
+    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 cancelRaf(id) {
+    if (inBrowser) {
+      cancelAnimationFrame(id);
+    }
+  }
+  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 useToggle(defaultValue = false) {
+    const state = vue.ref(defaultValue);
+    const toggle = (value = !state.value) => {
+      state.value = value;
+    };
+    return [state, toggle];
+  }
+  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
+    };
+  }
+  var SECOND = 1e3;
+  var MINUTE = 60 * SECOND;
+  var HOUR = 60 * MINUTE;
+  var DAY = 24 * HOUR;
+  function parseTime(time) {
+    const days = Math.floor(time / DAY);
+    const hours = Math.floor(time % DAY / HOUR);
+    const minutes = Math.floor(time % HOUR / MINUTE);
+    const seconds = Math.floor(time % MINUTE / SECOND);
+    const milliseconds = Math.floor(time % SECOND);
+    return {
+      total: time,
+      days,
+      hours,
+      minutes,
+      seconds,
+      milliseconds
+    };
+  }
+  function isSameSecond(time1, time2) {
+    return Math.floor(time1 / 1e3) === Math.floor(time2 / 1e3);
+  }
+  function useCountDown(options) {
+    let rafId;
+    let endTime;
+    let counting;
+    let deactivated;
+    const remain = vue.ref(options.time);
+    const current2 = vue.computed(() => parseTime(remain.value));
+    const pause = () => {
+      counting = false;
+      cancelRaf(rafId);
+    };
+    const getCurrentRemain = () => Math.max(endTime - Date.now(), 0);
+    const setRemain = (value) => {
+      var _a, _b;
+      remain.value = value;
+      (_a = options.onChange) == null ? void 0 : _a.call(options, current2.value);
+      if (value === 0) {
+        pause();
+        (_b = options.onFinish) == null ? void 0 : _b.call(options);
+      }
+    };
+    const microTick = () => {
+      rafId = raf(() => {
+        if (counting) {
+          setRemain(getCurrentRemain());
+          if (remain.value > 0) {
+            microTick();
+          }
+        }
+      });
+    };
+    const macroTick = () => {
+      rafId = raf(() => {
+        if (counting) {
+          const remainRemain = getCurrentRemain();
+          if (!isSameSecond(remainRemain, remain.value) || remainRemain === 0) {
+            setRemain(remainRemain);
+          }
+          if (remain.value > 0) {
+            macroTick();
+          }
+        }
+      });
+    };
+    const tick = () => {
+      if (!inBrowser) {
+        return;
+      }
+      if (options.millisecond) {
+        microTick();
+      } else {
+        macroTick();
+      }
+    };
+    const start2 = () => {
+      if (!counting) {
+        endTime = Date.now() + remain.value;
+        counting = true;
+        tick();
+      }
+    };
+    const reset = (totalTime = options.time) => {
+      pause();
+      remain.value = totalTime;
+    };
+    vue.onBeforeUnmount(pause);
+    vue.onActivated(() => {
+      if (deactivated) {
+        counting = true;
+        deactivated = false;
+        tick();
+      }
+    });
+    vue.onDeactivated(() => {
+      if (counting) {
+        pause();
+        deactivated = true;
+      }
+    });
+    return {
+      start: start2,
+      pause,
+      reset,
+      current: current2
+    };
+  }
+  function onMountedOrActivated(hook) {
+    let mounted;
+    vue.onMounted(() => {
+      hook();
+      vue.nextTick(() => {
+        mounted = true;
+      });
+    });
+    vue.onActivated(() => {
+      if (mounted) {
+        hook();
+      }
+    });
+  }
+  function useEventListener(type, listener, options = {}) {
+    if (!inBrowser) {
+      return;
+    }
+    const { target = window, passive: passive2 = false, capture = false } = options;
+    let cleaned = false;
+    let attached;
+    const add = (target2) => {
+      if (cleaned) {
+        return;
+      }
+      const element = vue.unref(target2);
+      if (element && !attached) {
+        element.addEventListener(type, listener, {
+          capture,
+          passive: passive2
+        });
+        attached = true;
+      }
+    };
+    const remove2 = (target2) => {
+      if (cleaned) {
+        return;
+      }
+      const element = vue.unref(target2);
+      if (element && attached) {
+        element.removeEventListener(type, listener, capture);
+        attached = false;
+      }
+    };
+    vue.onUnmounted(() => remove2(target));
+    vue.onDeactivated(() => remove2(target));
+    onMountedOrActivated(() => add(target));
+    let stopWatch;
+    if (vue.isRef(target)) {
+      stopWatch = vue.watch(target, (val, oldVal) => {
+        remove2(oldVal);
+        add(val);
+      });
+    }
+    return () => {
+      stopWatch == null ? void 0 : stopWatch();
+      remove2(target);
+      cleaned = true;
+    };
+  }
+  function useClickAway(target, listener, options = {}) {
+    if (!inBrowser) {
+      return;
+    }
+    const { eventName = "click" } = options;
+    const onClick = (event) => {
+      const targets = Array.isArray(target) ? target : [target];
+      const isClickAway = targets.every((item) => {
+        const element = vue.unref(item);
+        return element && !element.contains(event.target);
+      });
+      if (isClickAway) {
+        listener(event);
+      }
+    };
+    useEventListener(eventName, onClick, { target: document });
+  }
+  var width;
+  var height;
+  function useWindowSize() {
+    if (!width) {
+      width = vue.ref(0);
+      height = vue.ref(0);
+      if (inBrowser) {
+        const update = () => {
+          width.value = window.innerWidth;
+          height.value = window.innerHeight;
+        };
+        update();
+        window.addEventListener("resize", update, { passive: true });
+        window.addEventListener("orientationchange", update, { passive: true });
+      }
+    }
+    return { width, height };
+  }
+  var overflowScrollReg = /scroll|auto|overlay/i;
+  var defaultRoot = inBrowser ? window : void 0;
+  function isElement$1(node) {
+    const ELEMENT_NODE_TYPE = 1;
+    return node.tagName !== "HTML" && node.tagName !== "BODY" && node.nodeType === ELEMENT_NODE_TYPE;
+  }
+  function getScrollParent$1(el, root = defaultRoot) {
+    let node = el;
+    while (node && node !== root && isElement$1(node)) {
+      const { overflowY } = window.getComputedStyle(node);
+      if (overflowScrollReg.test(overflowY)) {
+        return node;
+      }
+      node = node.parentNode;
+    }
+    return root;
+  }
+  function useScrollParent(el, root = defaultRoot) {
+    const scrollParent = vue.ref();
+    vue.onMounted(() => {
+      if (el.value) {
+        scrollParent.value = getScrollParent$1(el.value, root);
+      }
+    });
+    return scrollParent;
+  }
+  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;
+  }
+  var CUSTOM_FIELD_INJECTION_KEY = Symbol("van-field");
+  function useCustomFieldValue(customValue) {
+    const field = vue.inject(CUSTOM_FIELD_INJECTION_KEY, null);
+    if (field && !field.customValue.value) {
+      field.customValue.value = customValue;
+      vue.watch(customValue, () => {
+        field.resetValidation();
+        field.validateWithTrigger("onChange");
+      });
+    }
+  }
+  function getScrollTop(el) {
+    const top2 = "scrollTop" in el ? el.scrollTop : el.pageYOffset;
+    return Math.max(top2, 0);
+  }
+  function setScrollTop(el, value) {
+    if ("scrollTop" in el) {
+      el.scrollTop = value;
+    } else {
+      el.scrollTo(el.scrollX, value);
+    }
+  }
+  function getRootScrollTop() {
+    return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+  }
+  function setRootScrollTop(value) {
+    setScrollTop(window, value);
+    setScrollTop(document.body, value);
+  }
+  function getElementTop(el, scroller) {
+    if (el === window) {
+      return 0;
+    }
+    const scrollTop = scroller ? getScrollTop(scroller) : getRootScrollTop();
+    return useRect(el).top + scrollTop;
+  }
+  const isIOS = isIOS$1();
+  function resetScroll() {
+    if (isIOS) {
+      setRootScrollTop(getRootScrollTop());
+    }
+  }
+  const stopPropagation = (event) => event.stopPropagation();
+  function preventDefault(event, isStopPropagation) {
+    if (typeof event.cancelable !== "boolean" || event.cancelable) {
+      event.preventDefault();
+    }
+    if (isStopPropagation) {
+      stopPropagation(event);
+    }
+  }
+  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(value)) {
+      return isNumeric(value) ? `${value}px` : String(value);
+    }
+    return void 0;
+  }
+  function getSizeStyle(originSize) {
+    if (isDef(originSize)) {
+      if (Array.isArray(originSize)) {
+        return {
+          width: addUnit(originSize[0]),
+          height: addUnit(originSize[1])
+        };
+      }
+      const size = addUnit(originSize);
+      return {
+        width: size,
+        height: size
+      };
+    }
+  }
+  function getZIndexStyle(zIndex) {
+    const style = {};
+    if (zIndex !== void 0) {
+      style.zIndex = +zIndex;
+    }
+    return style;
+  }
+  let rootFontSize;
+  function getRootFontSize() {
+    if (!rootFontSize) {
+      const doc = document.documentElement;
+      const fontSize = doc.style.fontSize || window.getComputedStyle(doc).fontSize;
+      rootFontSize = parseFloat(fontSize);
+    }
+    return rootFontSize;
+  }
+  function convertRem(value) {
+    value = value.replace(/rem/g, "");
+    return +value * getRootFontSize();
+  }
+  function convertVw(value) {
+    value = value.replace(/vw/g, "");
+    return +value * windowWidth.value / 100;
+  }
+  function convertVh(value) {
+    value = value.replace(/vh/g, "");
+    return +value * windowHeight.value / 100;
+  }
+  function unitToPx(value) {
+    if (typeof value === "number") {
+      return value;
+    }
+    if (inBrowser$1) {
+      if (value.includes("rem")) {
+        return convertRem(value);
+      }
+      if (value.includes("vw")) {
+        return convertVw(value);
+      }
+      if (value.includes("vh")) {
+        return convertVh(value);
+      }
+    }
+    return parseFloat(value);
+  }
+  const camelizeRE = /-(\w)/g;
+  const camelize = (str) => str.replace(camelizeRE, (_, c) => c.toUpperCase());
+  const kebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+  function padZero(num, targetLength = 2) {
+    let str = num + "";
+    while (str.length < targetLength) {
+      str = "0" + str;
+    }
+    return str;
+  }
+  const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+  function trimExtraChar(value, char, regExp) {
+    const index = value.indexOf(char);
+    if (index === -1) {
+      return value;
+    }
+    if (char === "-" && index !== 0) {
+      return value.slice(0, index);
+    }
+    return value.slice(0, index + 1) + value.slice(index).replace(regExp, "");
+  }
+  function formatNumber(value, allowDot = true, allowMinus = true) {
+    if (allowDot) {
+      value = trimExtraChar(value, ".", /\./g);
+    } else {
+      value = value.split(".")[0];
+    }
+    if (allowMinus) {
+      value = trimExtraChar(value, "-", /-/g);
+    } else {
+      value = value.replace(/-/, "");
+    }
+    const regExp = allowDot ? /[^-0-9.]/g : /[^-0-9]/g;
+    return value.replace(regExp, "");
+  }
+  function addNumber(num1, num2) {
+    const cardinal = 10 ** 10;
+    return Math.round((num1 + num2) * cardinal) / cardinal;
+  }
+  const { hasOwnProperty } = Object.prototype;
+  function assignKey(to, from, key) {
+    const val = from[key];
+    if (!isDef(val)) {
+      return;
+    }
+    if (!hasOwnProperty.call(to, key) || !isObject(val)) {
+      to[key] = val;
+    } else {
+      to[key] = deepAssign(Object(to[key]), val);
+    }
+  }
+  function deepAssign(to, from) {
+    Object.keys(from).forEach((key) => {
+      assignKey(to, from, key);
+    });
+    return to;
+  }
+  var stdin_default$1O = {
+    name: "姓名",
+    tel: "电话",
+    save: "保存",
+    confirm: "确认",
+    cancel: "取消",
+    delete: "删除",
+    loading: "加载中...",
+    noCoupon: "暂无优惠券",
+    nameEmpty: "请填写姓名",
+    addContact: "添加联系人",
+    telInvalid: "请填写正确的电话",
+    vanCalendar: {
+      end: "结束",
+      start: "开始",
+      title: "日期选择",
+      weekdays: ["日", "一", "二", "三", "四", "五", "六"],
+      monthTitle: (year, month) => `${year}年${month}月`,
+      rangePrompt: (maxRange) => `最多选择 ${maxRange} 天`
+    },
+    vanCascader: {
+      select: "请选择"
+    },
+    vanPagination: {
+      prev: "上一页",
+      next: "下一页"
+    },
+    vanPullRefresh: {
+      pulling: "下拉即可刷新...",
+      loosing: "释放即可刷新..."
+    },
+    vanSubmitBar: {
+      label: "合计:"
+    },
+    vanCoupon: {
+      unlimited: "无门槛",
+      discount: (discount) => `${discount}折`,
+      condition: (condition) => `满${condition}元可用`
+    },
+    vanCouponCell: {
+      title: "优惠券",
+      count: (count) => `${count}张可用`
+    },
+    vanCouponList: {
+      exchange: "兑换",
+      close: "不使用",
+      enable: "可用",
+      disabled: "不可用",
+      placeholder: "输入优惠码"
+    },
+    vanAddressEdit: {
+      area: "地区",
+      areaEmpty: "请选择地区",
+      addressEmpty: "请填写详细地址",
+      addressDetail: "详细地址",
+      defaultAddress: "设为默认收货地址"
+    },
+    vanAddressList: {
+      add: "新增地址"
+    }
+  };
+  const lang = vue.ref("zh-CN");
+  const messages = vue.reactive({
+    "zh-CN": stdin_default$1O
+  });
+  const Locale = {
+    messages() {
+      return messages[lang.value];
+    },
+    use(newLang, newMessages) {
+      lang.value = newLang;
+      this.add({ [newLang]: newMessages });
+    },
+    add(newMessages = {}) {
+      deepAssign(messages, newMessages);
+    }
+  };
+  const useCurrentLang = () => lang;
+  var stdin_default$1N = Locale;
+  function createTranslate(name2) {
+    const prefix = camelize(name2) + ".";
+    return (path, ...args) => {
+      const messages2 = stdin_default$1N.messages();
+      const message = get(messages2, prefix + path) || get(messages2, path);
+      return isFunction(message) ? message(...args) : message;
+    };
+  }
+  function genBem(name2, mods) {
+    if (!mods) {
+      return "";
+    }
+    if (typeof mods === "string") {
+      return ` ${name2}--${mods}`;
+    }
+    if (Array.isArray(mods)) {
+      return mods.reduce(
+        (ret, item) => ret + genBem(name2, item),
+        ""
+      );
+    }
+    return Object.keys(mods).reduce(
+      (ret, key) => ret + (mods[key] ? genBem(name2, key) : ""),
+      ""
+    );
+  }
+  function createBEM(name2) {
+    return (el, mods) => {
+      if (el && typeof el !== "string") {
+        mods = el;
+        el = "";
+      }
+      el = el ? `${name2}__${el}` : name2;
+      return `${el}${genBem(el, mods)}`;
+    };
+  }
+  function createNamespace(name2) {
+    const prefixedName = `van-${name2}`;
+    return [
+      prefixedName,
+      createBEM(prefixedName),
+      createTranslate(prefixedName)
+    ];
+  }
+  const BORDER = "van-hairline";
+  const BORDER_TOP = `${BORDER}--top`;
+  const BORDER_LEFT = `${BORDER}--left`;
+  const BORDER_BOTTOM = `${BORDER}--bottom`;
+  const BORDER_SURROUND = `${BORDER}--surround`;
+  const BORDER_TOP_BOTTOM = `${BORDER}--top-bottom`;
+  const BORDER_UNSET_TOP_BOTTOM = `${BORDER}-unset--top-bottom`;
+  const HAPTICS_FEEDBACK = "van-haptics-feedback";
+  const FORM_KEY = Symbol("van-form");
+  const LONG_PRESS_START_TIME = 500;
+  function callInterceptor(interceptor, {
+    args = [],
+    done,
+    canceled
+  }) {
+    if (interceptor) {
+      const returnVal = interceptor.apply(null, args);
+      if (isPromise(returnVal)) {
+        returnVal.then((value) => {
+          if (value) {
+            done();
+          } else if (canceled) {
+            canceled();
+          }
+        }).catch(noop);
+      } else if (returnVal) {
+        done();
+      } else if (canceled) {
+        canceled();
+      }
+    } else {
+      done();
+    }
+  }
+  function withInstall(options) {
+    options.install = (app) => {
+      const { name: name2 } = options;
+      if (name2) {
+        app.component(name2, options);
+        app.component(camelize(`-${name2}`), options);
+      }
+    };
+    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();
+        }
+      });
+    }
+  }
+  const useHeight = (element, withSafeArea) => {
+    const height2 = vue.ref();
+    const setHeight = () => {
+      height2.value = useRect(element).height;
+    };
+    vue.onMounted(() => {
+      vue.nextTick(setHeight);
+      if (withSafeArea) {
+        for (let i = 1; i <= 3; i++) {
+          setTimeout(setHeight, 100 * i);
+        }
+      }
+    });
+    onPopupReopen(() => vue.nextTick(setHeight));
+    vue.watch([windowWidth, windowHeight], setHeight);
+    return height2;
+  };
+  function usePlaceholder(contentRef, bem2) {
+    const height2 = useHeight(contentRef, true);
+    return (renderContent) => vue.createVNode("div", {
+      "class": bem2("placeholder"),
+      "style": {
+        height: height2.value ? `${height2.value}px` : void 0
+      }
+    }, [renderContent()]);
+  }
+  const [name$1C, bem$1x] = createNamespace("action-bar");
+  const ACTION_BAR_KEY = Symbol(name$1C);
+  const actionBarProps = {
+    placeholder: Boolean,
+    safeAreaInsetBottom: truthProp
+  };
+  var stdin_default$1M = vue.defineComponent({
+    name: name$1C,
+    props: actionBarProps,
+    setup(props, {
+      slots
+    }) {
+      const root = vue.ref();
+      const renderPlaceholder = usePlaceholder(root, bem$1x);
+      const {
+        linkChildren
+      } = useChildren(ACTION_BAR_KEY);
+      linkChildren();
+      const renderActionBar = () => {
+        var _a;
+        return vue.createVNode("div", {
+          "ref": root,
+          "class": [bem$1x(), {
+            "van-safe-area-bottom": props.safeAreaInsetBottom
+          }]
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+      return () => {
+        if (props.placeholder) {
+          return renderPlaceholder(renderActionBar);
+        }
+        return renderActionBar();
+      };
+    }
+  });
+  const ActionBar = withInstall(stdin_default$1M);
+  function useExpose(apis) {
+    const instance2 = vue.getCurrentInstance();
+    if (instance2) {
+      extend(instance2.proxy, apis);
+    }
+  }
+  const routeProps = {
+    to: [String, Object],
+    url: String,
+    replace: Boolean
+  };
+  function route({
+    to,
+    url,
+    replace,
+    $router: router
+  }) {
+    if (to && router) {
+      router[replace ? "replace" : "push"](to);
+    } else if (url) {
+      replace ? location.replace(url) : location.href = url;
+    }
+  }
+  function useRoute() {
+    const vm = vue.getCurrentInstance().proxy;
+    return () => route(vm);
+  }
+  const [name$1B, bem$1w] = createNamespace("badge");
+  const badgeProps = {
+    dot: Boolean,
+    max: numericProp,
+    tag: makeStringProp("div"),
+    color: String,
+    offset: Array,
+    content: numericProp,
+    showZero: truthProp,
+    position: makeStringProp("top-right")
+  };
+  var stdin_default$1L = vue.defineComponent({
+    name: name$1B,
+    props: badgeProps,
+    setup(props, {
+      slots
+    }) {
+      const hasContent = () => {
+        if (slots.content) {
+          return true;
+        }
+        const {
+          content,
+          showZero
+        } = props;
+        return isDef(content) && content !== "" && (showZero || content !== 0 && content !== "0");
+      };
+      const renderContent = () => {
+        const {
+          dot,
+          max,
+          content
+        } = props;
+        if (!dot && hasContent()) {
+          if (slots.content) {
+            return slots.content();
+          }
+          if (isDef(max) && isNumeric(content) && +content > +max) {
+            return `${max}+`;
+          }
+          return content;
+        }
+      };
+      const getOffsetWithMinusString = (val) => val.startsWith("-") ? val.replace("-", "") : `-${val}`;
+      const style = vue.computed(() => {
+        const style2 = {
+          background: props.color
+        };
+        if (props.offset) {
+          const [x, y] = props.offset;
+          const {
+            position
+          } = props;
+          const [offsetY, offsetX] = position.split("-");
+          if (slots.default) {
+            if (typeof y === "number") {
+              style2[offsetY] = addUnit(offsetY === "top" ? y : -y);
+            } else {
+              style2[offsetY] = offsetY === "top" ? addUnit(y) : getOffsetWithMinusString(y);
+            }
+            if (typeof x === "number") {
+              style2[offsetX] = addUnit(offsetX === "left" ? x : -x);
+            } else {
+              style2[offsetX] = offsetX === "left" ? addUnit(x) : getOffsetWithMinusString(x);
+            }
+          } else {
+            style2.marginTop = addUnit(y);
+            style2.marginLeft = addUnit(x);
+          }
+        }
+        return style2;
+      });
+      const renderBadge = () => {
+        if (hasContent() || props.dot) {
+          return vue.createVNode("div", {
+            "class": bem$1w([props.position, {
+              dot: props.dot,
+              fixed: !!slots.default
+            }]),
+            "style": style.value
+          }, [renderContent()]);
+        }
+      };
+      return () => {
+        if (slots.default) {
+          const {
+            tag
+          } = props;
+          return vue.createVNode(tag, {
+            "class": bem$1w("wrapper")
+          }, {
+            default: () => [slots.default(), renderBadge()]
+          });
+        }
+        return renderBadge();
+      };
+    }
+  });
+  const Badge = withInstall(stdin_default$1L);
+  let globalZIndex = 2e3;
+  const useGlobalZIndex = () => ++globalZIndex;
+  const setGlobalZIndex = (val) => {
+    globalZIndex = val;
+  };
+  const [name$1A, bem$1v] = createNamespace("config-provider");
+  const CONFIG_PROVIDER_KEY = Symbol(name$1A);
+  const configProviderProps = {
+    tag: makeStringProp("div"),
+    theme: makeStringProp("light"),
+    zIndex: Number,
+    themeVars: Object,
+    themeVarsDark: Object,
+    themeVarsLight: Object,
+    iconPrefix: String
+  };
+  function mapThemeVarsToCSSVars(themeVars) {
+    const cssVars = {};
+    Object.keys(themeVars).forEach((key) => {
+      cssVars[`--van-${kebabCase(key)}`] = themeVars[key];
+    });
+    return cssVars;
+  }
+  var stdin_default$1K = vue.defineComponent({
+    name: name$1A,
+    props: configProviderProps,
+    setup(props, {
+      slots
+    }) {
+      const style = vue.computed(() => mapThemeVarsToCSSVars(extend({}, props.themeVars, props.theme === "dark" ? props.themeVarsDark : props.themeVarsLight)));
+      if (inBrowser$1) {
+        const addTheme = () => {
+          document.documentElement.classList.add(`van-theme-${props.theme}`);
+        };
+        const removeTheme = (theme = props.theme) => {
+          document.documentElement.classList.remove(`van-theme-${theme}`);
+        };
+        vue.watch(() => props.theme, (newVal, oldVal) => {
+          if (oldVal) {
+            removeTheme(oldVal);
+          }
+          addTheme();
+        }, {
+          immediate: true
+        });
+        vue.onActivated(addTheme);
+        vue.onDeactivated(removeTheme);
+        vue.onBeforeUnmount(removeTheme);
+      }
+      vue.provide(CONFIG_PROVIDER_KEY, props);
+      vue.watchEffect(() => {
+        if (props.zIndex !== void 0) {
+          setGlobalZIndex(props.zIndex);
+        }
+      });
+      return () => vue.createVNode(props.tag, {
+        "class": bem$1v(),
+        "style": style.value
+      }, {
+        default: () => {
+          var _a;
+          return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
+        }
+      });
+    }
+  });
+  const [name$1z, bem$1u] = createNamespace("icon");
+  const isImage = (name2) => name2 == null ? void 0 : name2.includes("/");
+  const iconProps = {
+    dot: Boolean,
+    tag: makeStringProp("i"),
+    name: String,
+    size: numericProp,
+    badge: numericProp,
+    color: String,
+    badgeProps: Object,
+    classPrefix: String
+  };
+  var stdin_default$1J = vue.defineComponent({
+    name: name$1z,
+    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$1u());
+      return () => {
+        const {
+          tag,
+          dot,
+          name: name2,
+          size,
+          badge,
+          color
+        } = props;
+        const isImageIcon = isImage(name2);
+        return vue.createVNode(Badge, vue.mergeProps({
+          "dot": dot,
+          "tag": tag,
+          "class": [classPrefix.value, isImageIcon ? "" : `${classPrefix.value}-${name2}`],
+          "style": {
+            color,
+            fontSize: addUnit(size)
+          },
+          "content": badge
+        }, props.badgeProps), {
+          default: () => {
+            var _a;
+            return [(_a = slots.default) == null ? void 0 : _a.call(slots), isImageIcon && vue.createVNode("img", {
+              "class": bem$1u("image"),
+              "src": name2
+            }, null)];
+          }
+        });
+      };
+    }
+  });
+  const Icon = withInstall(stdin_default$1J);
+  const [name$1y, bem$1t] = createNamespace("loading");
+  const SpinIcon = Array(12).fill(null).map((_, index) => vue.createVNode("i", {
+    "class": bem$1t("line", String(index + 1))
+  }, null));
+  const CircularIcon = vue.createVNode("svg", {
+    "class": bem$1t("circular"),
+    "viewBox": "25 25 50 50"
+  }, [vue.createVNode("circle", {
+    "cx": "50",
+    "cy": "50",
+    "r": "20",
+    "fill": "none"
+  }, null)]);
+  const loadingProps = {
+    size: numericProp,
+    type: makeStringProp("circular"),
+    color: String,
+    vertical: Boolean,
+    textSize: numericProp,
+    textColor: String
+  };
+  var stdin_default$1I = vue.defineComponent({
+    name: name$1y,
+    props: loadingProps,
+    setup(props, {
+      slots
+    }) {
+      const spinnerStyle = vue.computed(() => extend({
+        color: props.color
+      }, getSizeStyle(props.size)));
+      const renderIcon = () => {
+        const DefaultIcon = props.type === "spinner" ? SpinIcon : CircularIcon;
+        return vue.createVNode("span", {
+          "class": bem$1t("spinner", props.type),
+          "style": spinnerStyle.value
+        }, [slots.icon ? slots.icon() : DefaultIcon]);
+      };
+      const renderText = () => {
+        var _a;
+        if (slots.default) {
+          return vue.createVNode("span", {
+            "class": bem$1t("text"),
+            "style": {
+              fontSize: addUnit(props.textSize),
+              color: (_a = props.textColor) != null ? _a : props.color
+            }
+          }, [slots.default()]);
+        }
+      };
+      return () => {
+        const {
+          type,
+          vertical
+        } = props;
+        return vue.createVNode("div", {
+          "class": bem$1t([type, {
+            vertical
+          }]),
+          "aria-live": "polite",
+          "aria-busy": true
+        }, [renderIcon(), renderText()]);
+      };
+    }
+  });
+  const Loading = withInstall(stdin_default$1I);
+  const [name$1x, bem$1s] = createNamespace("button");
+  const buttonProps = extend({}, routeProps, {
+    tag: makeStringProp("button"),
+    text: String,
+    icon: String,
+    type: makeStringProp("default"),
+    size: makeStringProp("normal"),
+    color: String,
+    block: Boolean,
+    plain: Boolean,
+    round: Boolean,
+    square: Boolean,
+    loading: Boolean,
+    hairline: Boolean,
+    disabled: Boolean,
+    iconPrefix: String,
+    nativeType: makeStringProp("button"),
+    loadingSize: numericProp,
+    loadingText: String,
+    loadingType: String,
+    iconPosition: makeStringProp("left")
+  });
+  var stdin_default$1H = vue.defineComponent({
+    name: name$1x,
+    props: buttonProps,
+    emits: ["click"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const route2 = useRoute();
+      const renderLoadingIcon = () => {
+        if (slots.loading) {
+          return slots.loading();
+        }
+        return vue.createVNode(Loading, {
+          "size": props.loadingSize,
+          "type": props.loadingType,
+          "class": bem$1s("loading")
+        }, null);
+      };
+      const renderIcon = () => {
+        if (props.loading) {
+          return renderLoadingIcon();
+        }
+        if (slots.icon) {
+          return vue.createVNode("div", {
+            "class": bem$1s("icon")
+          }, [slots.icon()]);
+        }
+        if (props.icon) {
+          return vue.createVNode(Icon, {
+            "name": props.icon,
+            "class": bem$1s("icon"),
+            "classPrefix": props.iconPrefix
+          }, null);
+        }
+      };
+      const renderText = () => {
+        let text;
+        if (props.loading) {
+          text = props.loadingText;
+        } else {
+          text = slots.default ? slots.default() : props.text;
+        }
+        if (text) {
+          return vue.createVNode("span", {
+            "class": bem$1s("text")
+          }, [text]);
+        }
+      };
+      const getStyle = () => {
+        const {
+          color,
+          plain
+        } = props;
+        if (color) {
+          const style = {
+            color: plain ? color : "white"
+          };
+          if (!plain) {
+            style.background = color;
+          }
+          if (color.includes("gradient")) {
+            style.border = 0;
+          } else {
+            style.borderColor = color;
+          }
+          return style;
+        }
+      };
+      const onClick = (event) => {
+        if (props.loading) {
+          preventDefault(event);
+        } else if (!props.disabled) {
+          emit("click", event);
+          route2();
+        }
+      };
+      return () => {
+        const {
+          tag,
+          type,
+          size,
+          block,
+          round: round2,
+          plain,
+          square,
+          loading,
+          disabled,
+          hairline,
+          nativeType,
+          iconPosition
+        } = props;
+        const classes = [bem$1s([type, size, {
+          plain,
+          block,
+          round: round2,
+          square,
+          loading,
+          disabled,
+          hairline
+        }]), {
+          [BORDER_SURROUND]: hairline
+        }];
+        return vue.createVNode(tag, {
+          "type": nativeType,
+          "class": classes,
+          "style": getStyle(),
+          "disabled": disabled,
+          "onClick": onClick
+        }, {
+          default: () => [vue.createVNode("div", {
+            "class": bem$1s("content")
+          }, [iconPosition === "left" && renderIcon(), renderText(), iconPosition === "right" && renderIcon()])]
+        });
+      };
+    }
+  });
+  const Button = withInstall(stdin_default$1H);
+  const [name$1w, bem$1r] = createNamespace("action-bar-button");
+  const actionBarButtonProps = extend({}, routeProps, {
+    type: String,
+    text: String,
+    icon: String,
+    color: String,
+    loading: Boolean,
+    disabled: Boolean
+  });
+  var stdin_default$1G = vue.defineComponent({
+    name: name$1w,
+    props: actionBarButtonProps,
+    setup(props, {
+      slots
+    }) {
+      const route2 = useRoute();
+      const {
+        parent,
+        index
+      } = useParent(ACTION_BAR_KEY);
+      const isFirst = vue.computed(() => {
+        if (parent) {
+          const prev = parent.children[index.value - 1];
+          return !(prev && "isButton" in prev);
+        }
+      });
+      const isLast = vue.computed(() => {
+        if (parent) {
+          const next = parent.children[index.value + 1];
+          return !(next && "isButton" in next);
+        }
+      });
+      useExpose({
+        isButton: true
+      });
+      return () => {
+        const {
+          type,
+          icon,
+          text,
+          color,
+          loading,
+          disabled
+        } = props;
+        return vue.createVNode(Button, {
+          "class": bem$1r([type, {
+            last: isLast.value,
+            first: isFirst.value
+          }]),
+          "size": "large",
+          "type": type,
+          "icon": icon,
+          "color": color,
+          "loading": loading,
+          "disabled": disabled,
+          "onClick": route2
+        }, {
+          default: () => [slots.default ? slots.default() : text]
+        });
+      };
+    }
+  });
+  const ActionBarButton = withInstall(stdin_default$1G);
+  const [name$1v, bem$1q] = createNamespace("action-bar-icon");
+  const actionBarIconProps = extend({}, routeProps, {
+    dot: Boolean,
+    text: String,
+    icon: String,
+    color: String,
+    badge: numericProp,
+    iconClass: unknownProp,
+    badgeProps: Object,
+    iconPrefix: String
+  });
+  var stdin_default$1F = vue.defineComponent({
+    name: name$1v,
+    props: actionBarIconProps,
+    setup(props, {
+      slots
+    }) {
+      const route2 = useRoute();
+      useParent(ACTION_BAR_KEY);
+      const renderIcon = () => {
+        const {
+          dot,
+          badge,
+          icon,
+          color,
+          iconClass,
+          badgeProps: badgeProps2,
+          iconPrefix
+        } = props;
+        if (slots.icon) {
+          return vue.createVNode(Badge, vue.mergeProps({
+            "dot": dot,
+            "class": bem$1q("icon"),
+            "content": badge
+          }, badgeProps2), {
+            default: slots.icon
+          });
+        }
+        return vue.createVNode(Icon, {
+          "tag": "div",
+          "dot": dot,
+          "name": icon,
+          "badge": badge,
+          "color": color,
+          "class": [bem$1q("icon"), iconClass],
+          "badgeProps": badgeProps2,
+          "classPrefix": iconPrefix
+        }, null);
+      };
+      return () => vue.createVNode("div", {
+        "role": "button",
+        "class": bem$1q(),
+        "tabindex": 0,
+        "onClick": route2
+      }, [renderIcon(), slots.default ? slots.default() : props.text]);
+    }
+  });
+  const ActionBarIcon = withInstall(stdin_default$1F);
+  const popupSharedProps = {
+    // whether to show popup
+    show: Boolean,
+    // z-index
+    zIndex: numericProp,
+    // whether to show overlay
+    overlay: truthProp,
+    // transition duration
+    duration: numericProp,
+    // teleport
+    teleport: [String, Object],
+    // prevent body scroll
+    lockScroll: truthProp,
+    // whether to lazy render
+    lazyRender: truthProp,
+    // callback function before close
+    beforeClose: Function,
+    // overlay custom style
+    overlayStyle: Object,
+    // overlay custom class name
+    overlayClass: unknownProp,
+    // Initial rendering animation
+    transitionAppear: Boolean,
+    // whether to close popup when overlay is clicked
+    closeOnClickOverlay: truthProp
+  };
+  const popupSharedPropKeys = Object.keys(
+    popupSharedProps
+  );
+  function getDirection(x, y) {
+    if (x > y) {
+      return "horizontal";
+    }
+    if (y > x) {
+      return "vertical";
+    }
+    return "";
+  }
+  function useTouch() {
+    const startX = vue.ref(0);
+    const startY = vue.ref(0);
+    const deltaX = vue.ref(0);
+    const deltaY = vue.ref(0);
+    const offsetX = vue.ref(0);
+    const offsetY = vue.ref(0);
+    const direction = vue.ref("");
+    const isVertical = () => direction.value === "vertical";
+    const isHorizontal = () => direction.value === "horizontal";
+    const reset = () => {
+      deltaX.value = 0;
+      deltaY.value = 0;
+      offsetX.value = 0;
+      offsetY.value = 0;
+      direction.value = "";
+    };
+    const start2 = (event) => {
+      reset();
+      startX.value = event.touches[0].clientX;
+      startY.value = event.touches[0].clientY;
+    };
+    const move = (event) => {
+      const touch = event.touches[0];
+      deltaX.value = (touch.clientX < 0 ? 0 : touch.clientX) - startX.value;
+      deltaY.value = touch.clientY - startY.value;
+      offsetX.value = Math.abs(deltaX.value);
+      offsetY.value = Math.abs(deltaY.value);
+      const LOCK_DIRECTION_DISTANCE = 10;
+      if (!direction.value || offsetX.value < LOCK_DIRECTION_DISTANCE && offsetY.value < LOCK_DIRECTION_DISTANCE) {
+        direction.value = getDirection(offsetX.value, offsetY.value);
+      }
+    };
+    return {
+      move,
+      start: start2,
+      reset,
+      startX,
+      startY,
+      deltaX,
+      deltaY,
+      offsetX,
+      offsetY,
+      direction,
+      isVertical,
+      isHorizontal
+    };
+  }
+  let totalLockCount = 0;
+  const BODY_LOCK_CLASS = "van-overflow-hidden";
+  function useLockScroll(rootRef, shouldLock) {
+    const touch = useTouch();
+    const DIRECTION_UP = "01";
+    const DIRECTION_DOWN = "10";
+    const onTouchMove = (event) => {
+      touch.move(event);
+      const direction = touch.deltaY.value > 0 ? DIRECTION_DOWN : DIRECTION_UP;
+      const el = getScrollParent$1(
+        event.target,
+        rootRef.value
+      );
+      const { scrollHeight, offsetHeight, scrollTop } = el;
+      let status = "11";
+      if (scrollTop === 0) {
+        status = offsetHeight >= scrollHeight ? "00" : "01";
+      } else if (scrollTop + offsetHeight >= scrollHeight) {
+        status = "10";
+      }
+      if (status !== "11" && touch.isVertical() && !(parseInt(status, 2) & parseInt(direction, 2))) {
+        preventDefault(event, true);
+      }
+    };
+    const lock = () => {
+      document.addEventListener("touchstart", touch.start);
+      document.addEventListener("touchmove", onTouchMove, { passive: false });
+      if (!totalLockCount) {
+        document.body.classList.add(BODY_LOCK_CLASS);
+      }
+      totalLockCount++;
+    };
+    const unlock = () => {
+      if (totalLockCount) {
+        document.removeEventListener("touchstart", touch.start);
+        document.removeEventListener("touchmove", onTouchMove);
+        totalLockCount--;
+        if (!totalLockCount) {
+          document.body.classList.remove(BODY_LOCK_CLASS);
+        }
+      }
+    };
+    const init = () => shouldLock() && lock();
+    const destroy = () => shouldLock() && unlock();
+    onMountedOrActivated(init);
+    vue.onDeactivated(destroy);
+    vue.onBeforeUnmount(destroy);
+    vue.watch(shouldLock, (value) => {
+      value ? lock() : unlock();
+    });
+  }
+  function useLazyRender(show) {
+    const inited = vue.ref(false);
+    vue.watch(
+      show,
+      (value) => {
+        if (value) {
+          inited.value = value;
+        }
+      },
+      { immediate: true }
+    );
+    return (render) => () => inited.value ? render() : null;
+  }
+  const [name$1u, bem$1p] = createNamespace("overlay");
+  const overlayProps = {
+    show: Boolean,
+    zIndex: numericProp,
+    duration: numericProp,
+    className: unknownProp,
+    lockScroll: truthProp,
+    lazyRender: truthProp,
+    customStyle: Object
+  };
+  var stdin_default$1E = vue.defineComponent({
+    name: name$1u,
+    props: overlayProps,
+    setup(props, {
+      slots
+    }) {
+      const root = vue.ref();
+      const lazyRender = useLazyRender(() => props.show || !props.lazyRender);
+      const onTouchMove = (event) => {
+        if (props.lockScroll) {
+          preventDefault(event, true);
+        }
+      };
+      const renderOverlay = lazyRender(() => {
+        var _a;
+        const style = extend(getZIndexStyle(props.zIndex), props.customStyle);
+        if (isDef(props.duration)) {
+          style.animationDuration = `${props.duration}s`;
+        }
+        return vue.withDirectives(vue.createVNode("div", {
+          "ref": root,
+          "style": style,
+          "class": [bem$1p(), props.className]
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]), [[vue.vShow, props.show]]);
+      });
+      useEventListener("touchmove", onTouchMove, {
+        target: root
+      });
+      return () => vue.createVNode(vue.Transition, {
+        "name": "van-fade",
+        "appear": true
+      }, {
+        default: renderOverlay
+      });
+    }
+  });
+  const Overlay = withInstall(stdin_default$1E);
+  const popupProps$2 = extend({}, popupSharedProps, {
+    round: Boolean,
+    position: makeStringProp("center"),
+    closeIcon: makeStringProp("cross"),
+    closeable: Boolean,
+    transition: String,
+    iconPrefix: String,
+    closeOnPopstate: Boolean,
+    closeIconPosition: makeStringProp("top-right"),
+    safeAreaInsetTop: Boolean,
+    safeAreaInsetBottom: Boolean
+  });
+  const [name$1t, bem$1o] = createNamespace("popup");
+  var stdin_default$1D = vue.defineComponent({
+    name: name$1t,
+    inheritAttrs: false,
+    props: popupProps$2,
+    emits: ["open", "close", "opened", "closed", "keydown", "update:show", "clickOverlay", "clickCloseIcon"],
+    setup(props, {
+      emit,
+      attrs,
+      slots
+    }) {
+      let opened;
+      let shouldReopen;
+      const zIndex = vue.ref();
+      const popupRef = vue.ref();
+      const lazyRender = useLazyRender(() => props.show || !props.lazyRender);
+      const style = vue.computed(() => {
+        const style2 = {
+          zIndex: zIndex.value
+        };
+        if (isDef(props.duration)) {
+          const key = props.position === "center" ? "animationDuration" : "transitionDuration";
+          style2[key] = `${props.duration}s`;
+        }
+        return style2;
+      });
+      const open = () => {
+        if (!opened) {
+          opened = true;
+          zIndex.value = props.zIndex !== void 0 ? +props.zIndex : useGlobalZIndex();
+          emit("open");
+        }
+      };
+      const close = () => {
+        if (opened) {
+          callInterceptor(props.beforeClose, {
+            done() {
+              opened = false;
+              emit("close");
+              emit("update:show", false);
+            }
+          });
+        }
+      };
+      const onClickOverlay = (event) => {
+        emit("clickOverlay", event);
+        if (props.closeOnClickOverlay) {
+          close();
+        }
+      };
+      const renderOverlay = () => {
+        if (props.overlay) {
+          return vue.createVNode(Overlay, {
+            "show": props.show,
+            "class": props.overlayClass,
+            "zIndex": zIndex.value,
+            "duration": props.duration,
+            "customStyle": props.overlayStyle,
+            "role": props.closeOnClickOverlay ? "button" : void 0,
+            "tabindex": props.closeOnClickOverlay ? 0 : void 0,
+            "onClick": onClickOverlay
+          }, {
+            default: slots["overlay-content"]
+          });
+        }
+      };
+      const onClickCloseIcon = (event) => {
+        emit("clickCloseIcon", event);
+        close();
+      };
+      const renderCloseIcon = () => {
+        if (props.closeable) {
+          return vue.createVNode(Icon, {
+            "role": "button",
+            "tabindex": 0,
+            "name": props.closeIcon,
+            "class": [bem$1o("close-icon", props.closeIconPosition), HAPTICS_FEEDBACK],
+            "classPrefix": props.iconPrefix,
+            "onClick": onClickCloseIcon
+          }, null);
+        }
+      };
+      const onOpened = () => emit("opened");
+      const onClosed = () => emit("closed");
+      const onKeydown = (event) => emit("keydown", event);
+      const renderPopup = lazyRender(() => {
+        var _a;
+        const {
+          round: round2,
+          position,
+          safeAreaInsetTop,
+          safeAreaInsetBottom
+        } = props;
+        return vue.withDirectives(vue.createVNode("div", vue.mergeProps({
+          "ref": popupRef,
+          "style": style.value,
+          "role": "dialog",
+          "tabindex": 0,
+          "class": [bem$1o({
+            round: round2,
+            [position]: position
+          }), {
+            "van-safe-area-top": safeAreaInsetTop,
+            "van-safe-area-bottom": safeAreaInsetBottom
+          }],
+          "onKeydown": onKeydown
+        }, attrs), [(_a = slots.default) == null ? void 0 : _a.call(slots), renderCloseIcon()]), [[vue.vShow, props.show]]);
+      });
+      const renderTransition = () => {
+        const {
+          position,
+          transition,
+          transitionAppear
+        } = props;
+        const name2 = position === "center" ? "van-fade" : `van-popup-slide-${position}`;
+        return vue.createVNode(vue.Transition, {
+          "name": transition || name2,
+          "appear": transitionAppear,
+          "onAfterEnter": onOpened,
+          "onAfterLeave": onClosed
+        }, {
+          default: renderPopup
+        });
+      };
+      vue.watch(() => props.show, (show) => {
+        if (show && !opened) {
+          open();
+          if (attrs.tabindex === 0) {
+            vue.nextTick(() => {
+              var _a;
+              (_a = popupRef.value) == null ? void 0 : _a.focus();
+            });
+          }
+        }
+        if (!show && opened) {
+          opened = false;
+          emit("close");
+        }
+      });
+      useExpose({
+        popupRef
+      });
+      useLockScroll(popupRef, () => props.show && props.lockScroll);
+      useEventListener("popstate", () => {
+        if (props.closeOnPopstate) {
+          close();
+          shouldReopen = false;
+        }
+      });
+      vue.onMounted(() => {
+        if (props.show) {
+          open();
+        }
+      });
+      vue.onActivated(() => {
+        if (shouldReopen) {
+          emit("update:show", true);
+          shouldReopen = false;
+        }
+      });
+      vue.onDeactivated(() => {
+        if (props.show && props.teleport) {
+          close();
+          shouldReopen = true;
+        }
+      });
+      vue.provide(POPUP_TOGGLE_KEY, () => props.show);
+      return () => {
+        if (props.teleport) {
+          return vue.createVNode(vue.Teleport, {
+            "to": props.teleport
+          }, {
+            default: () => [renderOverlay(), renderTransition()]
+          });
+        }
+        return vue.createVNode(vue.Fragment, null, [renderOverlay(), renderTransition()]);
+      };
+    }
+  });
+  const Popup = withInstall(stdin_default$1D);
+  const [name$1s, bem$1n] = createNamespace("action-sheet");
+  const actionSheetProps = extend({}, popupSharedProps, {
+    title: String,
+    round: truthProp,
+    actions: makeArrayProp(),
+    closeIcon: makeStringProp("cross"),
+    closeable: truthProp,
+    cancelText: String,
+    description: String,
+    closeOnPopstate: truthProp,
+    closeOnClickAction: Boolean,
+    safeAreaInsetBottom: truthProp
+  });
+  const popupInheritKeys$2 = [...popupSharedPropKeys, "round", "closeOnPopstate", "safeAreaInsetBottom"];
+  var stdin_default$1C = vue.defineComponent({
+    name: name$1s,
+    props: actionSheetProps,
+    emits: ["select", "cancel", "update:show"],
+    setup(props, {
+      slots,
+      emit
+    }) {
+      const updateShow = (show) => emit("update:show", show);
+      const onCancel = () => {
+        updateShow(false);
+        emit("cancel");
+      };
+      const renderHeader = () => {
+        if (props.title) {
+          return vue.createVNode("div", {
+            "class": bem$1n("header")
+          }, [props.title, props.closeable && vue.createVNode(Icon, {
+            "name": props.closeIcon,
+            "class": [bem$1n("close"), HAPTICS_FEEDBACK],
+            "onClick": onCancel
+          }, null)]);
+        }
+      };
+      const renderCancel = () => {
+        if (slots.cancel || props.cancelText) {
+          return [vue.createVNode("div", {
+            "class": bem$1n("gap")
+          }, null), vue.createVNode("button", {
+            "type": "button",
+            "class": bem$1n("cancel"),
+            "onClick": onCancel
+          }, [slots.cancel ? slots.cancel() : props.cancelText])];
+        }
+      };
+      const renderActionContent = (action, index) => {
+        if (action.loading) {
+          return vue.createVNode(Loading, {
+            "class": bem$1n("loading-icon")
+          }, null);
+        }
+        if (slots.action) {
+          return slots.action({
+            action,
+            index
+          });
+        }
+        return [vue.createVNode("span", {
+          "class": bem$1n("name")
+        }, [action.name]), action.subname && vue.createVNode("div", {
+          "class": bem$1n("subname")
+        }, [action.subname])];
+      };
+      const renderAction = (action, index) => {
+        const {
+          color,
+          loading,
+          callback,
+          disabled,
+          className
+        } = action;
+        const onClick = () => {
+          if (disabled || loading) {
+            return;
+          }
+          if (callback) {
+            callback(action);
+          }
+          if (props.closeOnClickAction) {
+            updateShow(false);
+          }
+          vue.nextTick(() => emit("select", action, index));
+        };
+        return vue.createVNode("button", {
+          "type": "button",
+          "style": {
+            color
+          },
+          "class": [bem$1n("item", {
+            loading,
+            disabled
+          }), className],
+          "onClick": onClick
+        }, [renderActionContent(action, index)]);
+      };
+      const renderDescription = () => {
+        if (props.description || slots.description) {
+          const content = slots.description ? slots.description() : props.description;
+          return vue.createVNode("div", {
+            "class": bem$1n("description")
+          }, [content]);
+        }
+      };
+      return () => vue.createVNode(Popup, vue.mergeProps({
+        "class": bem$1n(),
+        "position": "bottom",
+        "onUpdate:show": updateShow
+      }, pick(props, popupInheritKeys$2)), {
+        default: () => {
+          var _a;
+          return [renderHeader(), renderDescription(), vue.createVNode("div", {
+            "class": bem$1n("content")
+          }, [props.actions.map(renderAction), (_a = slots.default) == null ? void 0 : _a.call(slots)]), renderCancel()];
+        }
+      });
+    }
+  });
+  const ActionSheet = withInstall(stdin_default$1C);
+  const [name$1r, bem$1m, t$j] = createNamespace("picker");
+  const getFirstEnabledOption = (options) => options.find((option) => !option.disabled) || options[0];
+  function getColumnsType(columns, fields) {
+    const firstColumn = columns[0];
+    if (firstColumn) {
+      if (Array.isArray(firstColumn)) {
+        return "multiple";
+      }
+      if (fields.children in firstColumn) {
+        return "cascade";
+      }
+    }
+    return "default";
+  }
+  function findIndexOfEnabledOption(options, index) {
+    index = clamp(index, 0, options.length);
+    for (let i = index; i < options.length; i++) {
+      if (!options[i].disabled)
+        return i;
+    }
+    for (let i = index - 1; i >= 0; i--) {
+      if (!options[i].disabled)
+        return i;
+    }
+    return 0;
+  }
+  const isOptionExist = (options, value, fields) => value !== void 0 && !!options.find((option) => option[fields.value] === value);
+  function findOptionByValue(options, value, fields) {
+    const index = options.findIndex((option) => option[fields.value] === value);
+    const enabledIndex = findIndexOfEnabledOption(options, index);
+    return options[enabledIndex];
+  }
+  function formatCascadeColumns(columns, fields, selectedValues) {
+    const formatted = [];
+    let cursor = {
+      [fields.children]: columns
+    };
+    let columnIndex = 0;
+    while (cursor && cursor[fields.children]) {
+      const options = cursor[fields.children];
+      const value = selectedValues.value[columnIndex];
+      cursor = isDef(value) ? findOptionByValue(options, value, fields) : void 0;
+      if (!cursor && options.length) {
+        const firstValue = getFirstEnabledOption(options)[fields.value];
+        cursor = findOptionByValue(options, firstValue, fields);
+      }
+      columnIndex++;
+      formatted.push(options);
+    }
+    return formatted;
+  }
+  function getElementTranslateY(element) {
+    const { transform } = window.getComputedStyle(element);
+    const translateY = transform.slice(7, transform.length - 1).split(", ")[5];
+    return Number(translateY);
+  }
+  function assignDefaultFields(fields) {
+    return extend(
+      {
+        text: "text",
+        value: "value",
+        children: "children"
+      },
+      fields
+    );
+  }
+  const DEFAULT_DURATION = 200;
+  const MOMENTUM_TIME = 300;
+  const MOMENTUM_DISTANCE = 15;
+  const [name$1q, bem$1l] = createNamespace("picker-column");
+  const PICKER_KEY = Symbol(name$1q);
+  var stdin_default$1B = vue.defineComponent({
+    name: name$1q,
+    props: {
+      value: numericProp,
+      fields: makeRequiredProp(Object),
+      options: makeArrayProp(),
+      readonly: Boolean,
+      allowHtml: Boolean,
+      optionHeight: makeRequiredProp(Number),
+      swipeDuration: makeRequiredProp(numericProp),
+      visibleOptionNum: makeRequiredProp(numericProp)
+    },
+    emits: ["change", "clickOption"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      let moving;
+      let startOffset;
+      let touchStartTime;
+      let momentumOffset;
+      let transitionEndTrigger;
+      const root = vue.ref();
+      const wrapper = vue.ref();
+      const currentOffset = vue.ref(0);
+      const currentDuration = vue.ref(0);
+      const touch = useTouch();
+      const count = () => props.options.length;
+      const baseOffset = () => props.optionHeight * (+props.visibleOptionNum - 1) / 2;
+      const updateValueByIndex = (index) => {
+        const enabledIndex = findIndexOfEnabledOption(props.options, index);
+        const offset2 = -enabledIndex * props.optionHeight;
+        const trigger = () => {
+          const value = props.options[enabledIndex][props.fields.value];
+          if (value !== props.value) {
+            emit("change", value);
+          }
+        };
+        if (moving && offset2 !== currentOffset.value) {
+          transitionEndTrigger = trigger;
+        } else {
+          trigger();
+        }
+        currentOffset.value = offset2;
+      };
+      const isReadonly = () => props.readonly || !props.options.length;
+      const onClickOption = (index) => {
+        if (moving || isReadonly()) {
+          return;
+        }
+        transitionEndTrigger = null;
+        currentDuration.value = DEFAULT_DURATION;
+        updateValueByIndex(index);
+        emit("clickOption", props.options[index]);
+      };
+      const getIndexByOffset = (offset2) => clamp(Math.round(-offset2 / props.optionHeight), 0, count() - 1);
+      const momentum = (distance, duration) => {
+        const speed = Math.abs(distance / duration);
+        distance = currentOffset.value + speed / 3e-3 * (distance < 0 ? -1 : 1);
+        const index = getIndexByOffset(distance);
+        currentDuration.value = +props.swipeDuration;
+        updateValueByIndex(index);
+      };
+      const stopMomentum = () => {
+        moving = false;
+        currentDuration.value = 0;
+        if (transitionEndTrigger) {
+          transitionEndTrigger();
+          transitionEndTrigger = null;
+        }
+      };
+      const onTouchStart = (event) => {
+        if (isReadonly()) {
+          return;
+        }
+        touch.start(event);
+        if (moving) {
+          const translateY = getElementTranslateY(wrapper.value);
+          currentOffset.value = Math.min(0, translateY - baseOffset());
+        }
+        currentDuration.value = 0;
+        startOffset = currentOffset.value;
+        touchStartTime = Date.now();
+        momentumOffset = startOffset;
+        transitionEndTrigger = null;
+      };
+      const onTouchMove = (event) => {
+        if (isReadonly()) {
+          return;
+        }
+        touch.move(event);
+        if (touch.isVertical()) {
+          moving = true;
+          preventDefault(event, true);
+        }
+        currentOffset.value = clamp(startOffset + touch.deltaY.value, -(count() * props.optionHeight), props.optionHeight);
+        const now = Date.now();
+        if (now - touchStartTime > MOMENTUM_TIME) {
+          touchStartTime = now;
+          momentumOffset = currentOffset.value;
+        }
+      };
+      const onTouchEnd = () => {
+        if (isReadonly()) {
+          return;
+        }
+        const distance = currentOffset.value - momentumOffset;
+        const duration = Date.now() - touchStartTime;
+        const startMomentum = duration < MOMENTUM_TIME && Math.abs(distance) > MOMENTUM_DISTANCE;
+        if (startMomentum) {
+          momentum(distance, duration);
+          return;
+        }
+        const index = getIndexByOffset(currentOffset.value);
+        currentDuration.value = DEFAULT_DURATION;
+        updateValueByIndex(index);
+        setTimeout(() => {
+          moving = false;
+        }, 0);
+      };
+      const renderOptions = () => {
+        const optionStyle = {
+          height: `${props.optionHeight}px`
+        };
+        return props.options.map((option, index) => {
+          const text = option[props.fields.text];
+          const {
+            disabled
+          } = option;
+          const value = option[props.fields.value];
+          const data = {
+            role: "button",
+            style: optionStyle,
+            tabindex: disabled ? -1 : 0,
+            class: [bem$1l("item", {
+              disabled,
+              selected: value === props.value
+            }), option.className],
+            onClick: () => onClickOption(index)
+          };
+          const childData = {
+            class: "van-ellipsis",
+            [props.allowHtml ? "innerHTML" : "textContent"]: text
+          };
+          return vue.createVNode("li", data, [slots.option ? slots.option(option, index) : vue.createVNode("div", childData, null)]);
+        });
+      };
+      useParent(PICKER_KEY);
+      useExpose({
+        stopMomentum
+      });
+      vue.watchEffect(() => {
+        const index = props.options.findIndex((option) => option[props.fields.value] === props.value);
+        const enabledIndex = findIndexOfEnabledOption(props.options, index);
+        const offset2 = -enabledIndex * props.optionHeight;
+        currentOffset.value = offset2;
+      });
+      useEventListener("touchmove", onTouchMove, {
+        target: root
+      });
+      return () => vue.createVNode("div", {
+        "ref": root,
+        "class": bem$1l(),
+        "onTouchstartPassive": onTouchStart,
+        "onTouchend": onTouchEnd,
+        "onTouchcancel": onTouchEnd
+      }, [vue.createVNode("ul", {
+        "ref": wrapper,
+        "style": {
+          transform: `translate3d(0, ${currentOffset.value + baseOffset()}px, 0)`,
+          transitionDuration: `${currentDuration.value}ms`,
+          transitionProperty: currentDuration.value ? "all" : "none"
+        },
+        "class": bem$1l("wrapper"),
+        "onTransitionend": stopMomentum
+      }, [renderOptions()])]);
+    }
+  });
+  const [name$1p] = createNamespace("picker-toolbar");
+  const pickerToolbarProps = {
+    title: String,
+    cancelButtonText: String,
+    confirmButtonText: String
+  };
+  const pickerToolbarSlots = ["cancel", "confirm", "title", "toolbar"];
+  const pickerToolbarPropKeys = Object.keys(pickerToolbarProps);
+  var stdin_default$1A = vue.defineComponent({
+    name: name$1p,
+    props: pickerToolbarProps,
+    emits: ["confirm", "cancel"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const renderTitle = () => {
+        if (slots.title) {
+          return slots.title();
+        }
+        if (props.title) {
+          return vue.createVNode("div", {
+            "class": [bem$1m("title"), "van-ellipsis"]
+          }, [props.title]);
+        }
+      };
+      const onCancel = () => emit("cancel");
+      const onConfirm = () => emit("confirm");
+      const renderCancel = () => {
+        const text = props.cancelButtonText || t$j("cancel");
+        return vue.createVNode("button", {
+          "type": "button",
+          "class": [bem$1m("cancel"), HAPTICS_FEEDBACK],
+          "onClick": onCancel
+        }, [slots.cancel ? slots.cancel() : text]);
+      };
+      const renderConfirm = () => {
+        const text = props.confirmButtonText || t$j("confirm");
+        return vue.createVNode("button", {
+          "type": "button",
+          "class": [bem$1m("confirm"), HAPTICS_FEEDBACK],
+          "onClick": onConfirm
+        }, [slots.confirm ? slots.confirm() : text]);
+      };
+      return () => vue.createVNode("div", {
+        "class": bem$1m("toolbar")
+      }, [slots.toolbar ? slots.toolbar() : [renderCancel(), renderTitle(), renderConfirm()]]);
+    }
+  });
+  function scrollLeftTo(scroller, to, duration) {
+    let count = 0;
+    const from = scroller.scrollLeft;
+    const frames = duration === 0 ? 1 : Math.round(duration * 1e3 / 16);
+    function animate() {
+      scroller.scrollLeft += (to - from) / frames;
+      if (++count < frames) {
+        raf(animate);
+      }
+    }
+    animate();
+  }
+  function scrollTopTo(scroller, to, duration, callback) {
+    let current2 = getScrollTop(scroller);
+    const isDown = current2 < to;
+    const frames = duration === 0 ? 1 : Math.round(duration * 1e3 / 16);
+    const step = (to - current2) / frames;
+    function animate() {
+      current2 += step;
+      if (isDown && current2 > to || !isDown && current2 < to) {
+        current2 = to;
+      }
+      setScrollTop(scroller, current2);
+      if (isDown && current2 < to || !isDown && current2 > to) {
+        raf(animate);
+      } else if (callback) {
+        raf(callback);
+      }
+    }
+    animate();
+  }
+  let current = 0;
+  function useId() {
+    const vm = vue.getCurrentInstance();
+    const { name: name2 = "unknown" } = (vm == null ? void 0 : vm.type) || {};
+    return `${name2}-${++current}`;
+  }
+  function useRefs() {
+    const refs = vue.ref([]);
+    const cache = [];
+    vue.onBeforeUpdate(() => {
+      refs.value = [];
+    });
+    const setRefs = (index) => {
+      if (!cache[index]) {
+        cache[index] = (el) => {
+          refs.value[index] = el;
+        };
+      }
+      return cache[index];
+    };
+    return [refs, setRefs];
+  }
+  function useVisibilityChange(target, onChange) {
+    if (!inBrowser$1 || !window.IntersectionObserver) {
+      return;
+    }
+    const observer = new IntersectionObserver(
+      (entries) => {
+        onChange(entries[0].intersectionRatio > 0);
+      },
+      { root: document.body }
+    );
+    const observe = () => {
+      if (target.value) {
+        observer.observe(target.value);
+      }
+    };
+    const unobserve = () => {
+      if (target.value) {
+        observer.unobserve(target.value);
+      }
+    };
+    vue.onDeactivated(unobserve);
+    vue.onBeforeUnmount(unobserve);
+    onMountedOrActivated(observe);
+  }
+  const [name$1o, bem$1k] = createNamespace("sticky");
+  const stickyProps = {
+    zIndex: numericProp,
+    position: makeStringProp("top"),
+    container: Object,
+    offsetTop: makeNumericProp(0),
+    offsetBottom: makeNumericProp(0)
+  };
+  var stdin_default$1z = vue.defineComponent({
+    name: name$1o,
+    props: stickyProps,
+    emits: ["scroll", "change"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const root = vue.ref();
+      const scrollParent = useScrollParent(root);
+      const state = vue.reactive({
+        fixed: false,
+        width: 0,
+        // root width
+        height: 0,
+        // root height
+        transform: 0
+      });
+      const offset2 = vue.computed(() => unitToPx(props.position === "top" ? props.offsetTop : props.offsetBottom));
+      const rootStyle = vue.computed(() => {
+        const {
+          fixed,
+          height: height2,
+          width: width2
+        } = state;
+        if (fixed) {
+          return {
+            width: `${width2}px`,
+            height: `${height2}px`
+          };
+        }
+      });
+      const stickyStyle = vue.computed(() => {
+        if (!state.fixed) {
+          return;
+        }
+        const style = extend(getZIndexStyle(props.zIndex), {
+          width: `${state.width}px`,
+          height: `${state.height}px`,
+          [props.position]: `${offset2.value}px`
+        });
+        if (state.transform) {
+          style.transform = `translate3d(0, ${state.transform}px, 0)`;
+        }
+        return style;
+      });
+      const emitScroll = (scrollTop) => emit("scroll", {
+        scrollTop,
+        isFixed: state.fixed
+      });
+      const onScroll = () => {
+        if (!root.value || isHidden(root)) {
+          return;
+        }
+        const {
+          container,
+          position
+        } = props;
+        const rootRect = useRect(root);
+        const scrollTop = getScrollTop(window);
+        state.width = rootRect.width;
+        state.height = rootRect.height;
+        if (position === "top") {
+          if (container) {
+            const containerRect = useRect(container);
+            const difference = containerRect.bottom - offset2.value - state.height;
+            state.fixed = offset2.value > rootRect.top && containerRect.bottom > 0;
+            state.transform = difference < 0 ? difference : 0;
+          } else {
+            state.fixed = offset2.value > rootRect.top;
+          }
+        } else {
+          const {
+            clientHeight
+          } = document.documentElement;
+          if (container) {
+            const containerRect = useRect(container);
+            const difference = clientHeight - containerRect.top - offset2.value - state.height;
+            state.fixed = clientHeight - offset2.value < rootRect.bottom && clientHeight > containerRect.top;
+            state.transform = difference < 0 ? -difference : 0;
+          } else {
+            state.fixed = clientHeight - offset2.value < rootRect.bottom;
+          }
+        }
+        emitScroll(scrollTop);
+      };
+      vue.watch(() => state.fixed, (value) => emit("change", value));
+      useEventListener("scroll", onScroll, {
+        target: scrollParent,
+        passive: true
+      });
+      useVisibilityChange(root, onScroll);
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "ref": root,
+          "style": rootStyle.value
+        }, [vue.createVNode("div", {
+          "class": bem$1k({
+            fixed: state.fixed
+          }),
+          "style": stickyStyle.value
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
+      };
+    }
+  });
+  const Sticky = withInstall(stdin_default$1z);
+  const [name$1n, bem$1j] = createNamespace("tab");
+  var stdin_default$1y = vue.defineComponent({
+    name: name$1n,
+    props: {
+      id: String,
+      dot: Boolean,
+      type: String,
+      color: String,
+      title: String,
+      badge: numericProp,
+      shrink: Boolean,
+      isActive: Boolean,
+      disabled: Boolean,
+      controls: String,
+      scrollable: Boolean,
+      activeColor: String,
+      inactiveColor: String,
+      showZeroBadge: truthProp
+    },
+    setup(props, {
+      slots
+    }) {
+      const style = vue.computed(() => {
+        const style2 = {};
+        const {
+          type,
+          color,
+          disabled,
+          isActive,
+          activeColor,
+          inactiveColor
+        } = props;
+        const isCard = type === "card";
+        if (color && isCard) {
+          style2.borderColor = color;
+          if (!disabled) {
+            if (isActive) {
+              style2.backgroundColor = color;
+            } else {
+              style2.color = color;
+            }
+          }
+        }
+        const titleColor = isActive ? activeColor : inactiveColor;
+        if (titleColor) {
+          style2.color = titleColor;
+        }
+        return style2;
+      });
+      const renderText = () => {
+        const Text = vue.createVNode("span", {
+          "class": bem$1j("text", {
+            ellipsis: !props.scrollable
+          })
+        }, [slots.title ? slots.title() : props.title]);
+        if (props.dot || isDef(props.badge) && props.badge !== "") {
+          return vue.createVNode(Badge, {
+            "dot": props.dot,
+            "content": props.badge,
+            "showZero": props.showZeroBadge
+          }, {
+            default: () => [Text]
+          });
+        }
+        return Text;
+      };
+      return () => vue.createVNode("div", {
+        "id": props.id,
+        "role": "tab",
+        "class": [bem$1j([props.type, {
+          grow: props.scrollable && !props.shrink,
+          shrink: props.shrink,
+          active: props.isActive,
+          disabled: props.disabled
+        }])],
+        "style": style.value,
+        "tabindex": props.disabled ? void 0 : props.isActive ? 0 : -1,
+        "aria-selected": props.isActive,
+        "aria-disabled": props.disabled || void 0,
+        "aria-controls": props.controls
+      }, [renderText()]);
+    }
+  });
+  const [name$1m, bem$1i] = 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$1m);
+  var stdin_default$1x = vue.defineComponent({
+    name: name$1m,
+    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}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 || // avoid resetting position on multi-finger touch
+        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$1i("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$1i("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], 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$1i()
+        }, [vue.createVNode("div", {
+          "ref": track,
+          "style": trackStyle.value,
+          "class": bem$1i("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$1x);
+  const [name$1l, bem$1h] = createNamespace("tabs");
+  var stdin_default$1w = vue.defineComponent({
+    name: name$1l,
+    props: {
+      count: makeRequiredProp(Number),
+      inited: Boolean,
+      animated: Boolean,
+      duration: makeRequiredProp(numericProp),
+      swipeable: Boolean,
+      lazyRender: Boolean,
+      currentIndex: makeRequiredProp(Number)
+    },
+    emits: ["change"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const swipeRef = vue.ref();
+      const onChange = (index) => emit("change", index);
+      const renderChildren = () => {
+        var _a;
+        const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
+        if (props.animated || props.swipeable) {
+          return vue.createVNode(Swipe, {
+            "ref": swipeRef,
+            "loop": false,
+            "class": bem$1h("track"),
+            "duration": +props.duration * 1e3,
+            "touchable": props.swipeable,
+            "lazyRender": props.lazyRender,
+            "showIndicators": false,
+            "onChange": onChange
+          }, {
+            default: () => [Content]
+          });
+        }
+        return Content;
+      };
+      const swipeToCurrentTab = (index) => {
+        const swipe = swipeRef.value;
+        if (swipe && swipe.state.active !== index) {
+          swipe.swipeTo(index, {
+            immediate: !props.inited
+          });
+        }
+      };
+      vue.watch(() => props.currentIndex, swipeToCurrentTab);
+      vue.onMounted(() => {
+        swipeToCurrentTab(props.currentIndex);
+      });
+      useExpose({
+        swipeRef
+      });
+      return () => vue.createVNode("div", {
+        "class": bem$1h("content", {
+          animated: props.animated || props.swipeable
+        })
+      }, [renderChildren()]);
+    }
+  });
+  const [name$1k, bem$1g] = createNamespace("tabs");
+  const tabsProps = {
+    type: makeStringProp("line"),
+    color: String,
+    border: Boolean,
+    sticky: Boolean,
+    shrink: Boolean,
+    active: makeNumericProp(0),
+    duration: makeNumericProp(0.3),
+    animated: Boolean,
+    ellipsis: truthProp,
+    swipeable: Boolean,
+    scrollspy: Boolean,
+    offsetTop: makeNumericProp(0),
+    background: String,
+    lazyRender: truthProp,
+    lineWidth: numericProp,
+    lineHeight: numericProp,
+    beforeChange: Function,
+    swipeThreshold: makeNumericProp(5),
+    titleActiveColor: String,
+    titleInactiveColor: String
+  };
+  const TABS_KEY = Symbol(name$1k);
+  var stdin_default$1v = vue.defineComponent({
+    name: name$1k,
+    props: tabsProps,
+    emits: ["change", "scroll", "rendered", "clickTab", "update:active"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      let tabHeight;
+      let lockScroll;
+      let stickyFixed;
+      const root = vue.ref();
+      const navRef = vue.ref();
+      const wrapRef = vue.ref();
+      const contentRef = vue.ref();
+      const id = useId();
+      const scroller = useScrollParent(root);
+      const [titleRefs, setTitleRefs] = useRefs();
+      const {
+        children,
+        linkChildren
+      } = useChildren(TABS_KEY);
+      const state = vue.reactive({
+        inited: false,
+        position: "",
+        lineStyle: {},
+        currentIndex: -1
+      });
+      const scrollable = vue.computed(() => children.length > +props.swipeThreshold || !props.ellipsis || props.shrink);
+      const navStyle = vue.computed(() => ({
+        borderColor: props.color,
+        background: props.background
+      }));
+      const getTabName = (tab, index) => {
+        var _a;
+        return (_a = tab.name) != null ? _a : index;
+      };
+      const currentName = vue.computed(() => {
+        const activeTab = children[state.currentIndex];
+        if (activeTab) {
+          return getTabName(activeTab, state.currentIndex);
+        }
+      });
+      const offsetTopPx = vue.computed(() => unitToPx(props.offsetTop));
+      const scrollOffset = vue.computed(() => {
+        if (props.sticky) {
+          return offsetTopPx.value + tabHeight;
+        }
+        return 0;
+      });
+      const scrollIntoView = (immediate) => {
+        const nav = navRef.value;
+        const titles = titleRefs.value;
+        if (!scrollable.value || !nav || !titles || !titles[state.currentIndex]) {
+          return;
+        }
+        const title = titles[state.currentIndex].$el;
+        const to = title.offsetLeft - (nav.offsetWidth - title.offsetWidth) / 2;
+        scrollLeftTo(nav, to, immediate ? 0 : +props.duration);
+      };
+      const setLine = () => {
+        const shouldAnimate = state.inited;
+        vue.nextTick(() => {
+          const titles = titleRefs.value;
+          if (!titles || !titles[state.currentIndex] || props.type !== "line" || isHidden(root.value)) {
+            return;
+          }
+          const title = titles[state.currentIndex].$el;
+          const {
+            lineWidth,
+            lineHeight
+          } = props;
+          const left2 = title.offsetLeft + title.offsetWidth / 2;
+          const lineStyle = {
+            width: addUnit(lineWidth),
+            backgroundColor: props.color,
+            transform: `translateX(${left2}px) translateX(-50%)`
+          };
+          if (shouldAnimate) {
+            lineStyle.transitionDuration = `${props.duration}s`;
+          }
+          if (isDef(lineHeight)) {
+            const height2 = addUnit(lineHeight);
+            lineStyle.height = height2;
+            lineStyle.borderRadius = height2;
+          }
+          state.lineStyle = lineStyle;
+        });
+      };
+      const findAvailableTab = (index) => {
+        const diff = index < state.currentIndex ? -1 : 1;
+        while (index >= 0 && index < children.length) {
+          if (!children[index].disabled) {
+            return index;
+          }
+          index += diff;
+        }
+      };
+      const setCurrentIndex = (currentIndex, skipScrollIntoView) => {
+        const newIndex = findAvailableTab(currentIndex);
+        if (!isDef(newIndex)) {
+          return;
+        }
+        const newTab = children[newIndex];
+        const newName = getTabName(newTab, newIndex);
+        const shouldEmitChange = state.currentIndex !== null;
+        if (state.currentIndex !== newIndex) {
+          state.currentIndex = newIndex;
+          if (!skipScrollIntoView) {
+            scrollIntoView();
+          }
+          setLine();
+        }
+        if (newName !== props.active) {
+          emit("update:active", newName);
+          if (shouldEmitChange) {
+            emit("change", newName, newTab.title);
+          }
+        }
+        if (stickyFixed && !props.scrollspy) {
+          setRootScrollTop(Math.ceil(getElementTop(root.value) - offsetTopPx.value));
+        }
+      };
+      const setCurrentIndexByName = (name2, skipScrollIntoView) => {
+        const matched = children.find((tab, index2) => getTabName(tab, index2) === name2);
+        const index = matched ? children.indexOf(matched) : 0;
+        setCurrentIndex(index, skipScrollIntoView);
+      };
+      const scrollToCurrentContent = (immediate = false) => {
+        if (props.scrollspy) {
+          const target = children[state.currentIndex].$el;
+          if (target && scroller.value) {
+            const to = getElementTop(target, scroller.value) - scrollOffset.value;
+            lockScroll = true;
+            scrollTopTo(scroller.value, to, immediate ? 0 : +props.duration, () => {
+              lockScroll = false;
+            });
+          }
+        }
+      };
+      const onClickTab = (item, index, event) => {
+        const {
+          title,
+          disabled
+        } = children[index];
+        const name2 = getTabName(children[index], index);
+        if (!disabled) {
+          callInterceptor(props.beforeChange, {
+            args: [name2],
+            done: () => {
+              setCurrentIndex(index);
+              scrollToCurrentContent();
+            }
+          });
+          route(item);
+        }
+        emit("clickTab", {
+          name: name2,
+          title,
+          event,
+          disabled
+        });
+      };
+      const onStickyScroll = (params) => {
+        stickyFixed = params.isFixed;
+        emit("scroll", params);
+      };
+      const scrollTo = (name2) => {
+        vue.nextTick(() => {
+          setCurrentIndexByName(name2);
+          scrollToCurrentContent(true);
+        });
+      };
+      const getCurrentIndexOnScroll = () => {
+        for (let index = 0; index < children.length; index++) {
+          const {
+            top: top2
+          } = useRect(children[index].$el);
+          if (top2 > scrollOffset.value) {
+            return index === 0 ? 0 : index - 1;
+          }
+        }
+        return children.length - 1;
+      };
+      const onScroll = () => {
+        if (props.scrollspy && !lockScroll) {
+          const index = getCurrentIndexOnScroll();
+          setCurrentIndex(index);
+        }
+      };
+      const renderNav = () => children.map((item, index) => vue.createVNode(stdin_default$1y, vue.mergeProps({
+        "key": item.id,
+        "id": `${id}-${index}`,
+        "ref": setTitleRefs(index),
+        "type": props.type,
+        "color": props.color,
+        "style": item.titleStyle,
+        "class": item.titleClass,
+        "shrink": props.shrink,
+        "isActive": index === state.currentIndex,
+        "controls": item.id,
+        "scrollable": scrollable.value,
+        "activeColor": props.titleActiveColor,
+        "inactiveColor": props.titleInactiveColor,
+        "onClick": (event) => onClickTab(item, index, event)
+      }, pick(item, ["dot", "badge", "title", "disabled", "showZeroBadge"])), {
+        title: item.$slots.title
+      }));
+      const renderLine = () => {
+        if (props.type === "line" && children.length) {
+          return vue.createVNode("div", {
+            "class": bem$1g("line"),
+            "style": state.lineStyle
+          }, null);
+        }
+      };
+      const renderHeader = () => {
+        var _a, _b, _c;
+        const {
+          type,
+          border,
+          sticky
+        } = props;
+        const Header = [vue.createVNode("div", {
+          "ref": sticky ? void 0 : wrapRef,
+          "class": [bem$1g("wrap"), {
+            [BORDER_TOP_BOTTOM]: type === "line" && border
+          }]
+        }, [vue.createVNode("div", {
+          "ref": navRef,
+          "role": "tablist",
+          "class": bem$1g("nav", [type, {
+            shrink: props.shrink,
+            complete: scrollable.value
+          }]),
+          "style": navStyle.value,
+          "aria-orientation": "horizontal"
+        }, [(_a = slots["nav-left"]) == null ? void 0 : _a.call(slots), renderNav(), renderLine(), (_b = slots["nav-right"]) == null ? void 0 : _b.call(slots)])]), (_c = slots["nav-bottom"]) == null ? void 0 : _c.call(slots)];
+        if (sticky) {
+          return vue.createVNode("div", {
+            "ref": wrapRef
+          }, [Header]);
+        }
+        return Header;
+      };
+      vue.watch([() => props.color, windowWidth], setLine);
+      vue.watch(() => props.active, (value) => {
+        if (value !== currentName.value) {
+          setCurrentIndexByName(value);
+        }
+      });
+      vue.watch(() => children.length, () => {
+        if (state.inited) {
+          setCurrentIndexByName(props.active);
+          setLine();
+          vue.nextTick(() => {
+            scrollIntoView(true);
+          });
+        }
+      });
+      const init = () => {
+        setCurrentIndexByName(props.active, true);
+        vue.nextTick(() => {
+          state.inited = true;
+          if (wrapRef.value) {
+            tabHeight = useRect(wrapRef.value).height;
+          }
+          scrollIntoView(true);
+        });
+      };
+      const onRendered = (name2, title) => emit("rendered", name2, title);
+      const resize = () => {
+        setLine();
+        vue.nextTick(() => {
+          var _a, _b;
+          return (_b = (_a = contentRef.value) == null ? void 0 : _a.swipeRef.value) == null ? void 0 : _b.resize();
+        });
+      };
+      useExpose({
+        resize,
+        scrollTo
+      });
+      vue.onActivated(setLine);
+      onPopupReopen(setLine);
+      onMountedOrActivated(init);
+      useVisibilityChange(root, setLine);
+      useEventListener("scroll", onScroll, {
+        target: scroller,
+        passive: true
+      });
+      linkChildren({
+        id,
+        props,
+        setLine,
+        onRendered,
+        currentName,
+        scrollIntoView
+      });
+      return () => vue.createVNode("div", {
+        "ref": root,
+        "class": bem$1g([props.type])
+      }, [props.sticky ? vue.createVNode(Sticky, {
+        "container": root.value,
+        "offsetTop": offsetTopPx.value,
+        "onScroll": onStickyScroll
+      }, {
+        default: () => [renderHeader()]
+      }) : renderHeader(), vue.createVNode(stdin_default$1w, {
+        "ref": contentRef,
+        "count": children.length,
+        "inited": state.inited,
+        "animated": props.animated,
+        "duration": props.duration,
+        "swipeable": props.swipeable,
+        "lazyRender": props.lazyRender,
+        "currentIndex": state.currentIndex,
+        "onChange": setCurrentIndex
+      }, {
+        default: () => {
+          var _a;
+          return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
+        }
+      })]);
+    }
+  });
+  const TAB_STATUS_KEY = Symbol();
+  const useTabStatus = () => vue.inject(TAB_STATUS_KEY, null);
+  const [name$1j, bem$1f] = createNamespace("swipe-item");
+  var stdin_default$1u = vue.defineComponent({
+    name: name$1j,
+    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$1f(),
+          "style": style.value
+        }, [shouldRender.value ? (_a = slots.default) == null ? void 0 : _a.call(slots) : null]);
+      };
+    }
+  });
+  const SwipeItem = withInstall(stdin_default$1u);
+  const [name$1i, bem$1e] = createNamespace("tab");
+  const tabProps = extend({}, routeProps, {
+    dot: Boolean,
+    name: numericProp,
+    badge: numericProp,
+    title: String,
+    disabled: Boolean,
+    titleClass: unknownProp,
+    titleStyle: [String, Object],
+    showZeroBadge: truthProp
+  });
+  var stdin_default$1t = vue.defineComponent({
+    name: name$1i,
+    props: tabProps,
+    setup(props, {
+      slots
+    }) {
+      const id = useId();
+      const inited = vue.ref(false);
+      const {
+        parent,
+        index
+      } = useParent(TABS_KEY);
+      if (!parent) {
+        return;
+      }
+      const getName = () => {
+        var _a;
+        return (_a = props.name) != null ? _a : index.value;
+      };
+      const init = () => {
+        inited.value = true;
+        if (parent.props.lazyRender) {
+          vue.nextTick(() => {
+            parent.onRendered(getName(), props.title);
+          });
+        }
+      };
+      const active = vue.computed(() => {
+        const isActive = getName() === parent.currentName.value;
+        if (isActive && !inited.value) {
+          init();
+        }
+        return isActive;
+      });
+      const hasInactiveClass = vue.ref(!active.value);
+      vue.watch(active, (val) => {
+        if (val) {
+          hasInactiveClass.value = false;
+        } else {
+          doubleRaf(() => {
+            hasInactiveClass.value = true;
+          });
+        }
+      });
+      vue.watch(() => props.title, () => {
+        parent.setLine();
+        parent.scrollIntoView();
+      });
+      vue.provide(TAB_STATUS_KEY, active);
+      return () => {
+        var _a;
+        const label = `${parent.id}-${index.value}`;
+        const {
+          animated,
+          swipeable,
+          scrollspy,
+          lazyRender
+        } = parent.props;
+        if (!slots.default && !animated) {
+          return;
+        }
+        const show = scrollspy || active.value;
+        if (animated || swipeable) {
+          return vue.createVNode(SwipeItem, {
+            "id": id,
+            "role": "tabpanel",
+            "class": bem$1e("panel-wrapper", {
+              inactive: hasInactiveClass.value
+            }),
+            "tabindex": active.value ? 0 : -1,
+            "aria-hidden": !active.value,
+            "aria-labelledby": label
+          }, {
+            default: () => {
+              var _a2;
+              return [vue.createVNode("div", {
+                "class": bem$1e("panel")
+              }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)])];
+            }
+          });
+        }
+        const shouldRender = inited.value || scrollspy || !lazyRender;
+        const Content = shouldRender ? (_a = slots.default) == null ? void 0 : _a.call(slots) : null;
+        useExpose({
+          id
+        });
+        return vue.withDirectives(vue.createVNode("div", {
+          "id": id,
+          "role": "tabpanel",
+          "class": bem$1e("panel"),
+          "tabindex": show ? 0 : -1,
+          "aria-labelledby": label
+        }, [Content]), [[vue.vShow, show]]);
+      };
+    }
+  });
+  const Tab = withInstall(stdin_default$1t);
+  const Tabs = withInstall(stdin_default$1v);
+  const [name$1h, bem$1d] = createNamespace("picker-group");
+  const PICKER_GROUP_KEY = Symbol(name$1h);
+  const pickerGroupProps = extend({
+    tabs: makeArrayProp(),
+    nextStepText: String
+  }, pickerToolbarProps);
+  var stdin_default$1s = vue.defineComponent({
+    name: name$1h,
+    props: pickerGroupProps,
+    emits: ["confirm", "cancel"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const activeTab = vue.ref(0);
+      const {
+        children,
+        linkChildren
+      } = useChildren(PICKER_GROUP_KEY);
+      linkChildren();
+      const showNextButton = () => activeTab.value < props.tabs.length - 1 && props.nextStepText;
+      const onConfirm = () => {
+        if (showNextButton()) {
+          activeTab.value++;
+        } else {
+          emit("confirm", children.map((item) => item.confirm()));
+        }
+      };
+      const onCancel = () => emit("cancel");
+      return () => {
+        var _a;
+        const childNodes = (_a = slots.default) == null ? void 0 : _a.call(slots);
+        const confirmButtonText = showNextButton() ? props.nextStepText : props.confirmButtonText;
+        return vue.createVNode("div", {
+          "class": bem$1d()
+        }, [vue.createVNode(stdin_default$1A, {
+          "title": props.title,
+          "cancelButtonText": props.cancelButtonText,
+          "confirmButtonText": confirmButtonText,
+          "onConfirm": onConfirm,
+          "onCancel": onCancel
+        }, pick(slots, pickerToolbarSlots)), vue.createVNode(Tabs, {
+          "active": activeTab.value,
+          "onUpdate:active": ($event) => activeTab.value = $event,
+          "class": bem$1d("tabs"),
+          "shrink": true,
+          "animated": true,
+          "lazyRender": false
+        }, {
+          default: () => [props.tabs.map((title, index) => vue.createVNode(Tab, {
+            "title": title,
+            "titleClass": bem$1d("tab-title")
+          }, {
+            default: () => [childNodes == null ? void 0 : childNodes[index]]
+          }))]
+        })]);
+      };
+    }
+  });
+  const pickerSharedProps = extend({
+    loading: Boolean,
+    readonly: Boolean,
+    allowHtml: Boolean,
+    optionHeight: makeNumericProp(44),
+    showToolbar: truthProp,
+    swipeDuration: makeNumericProp(1e3),
+    visibleOptionNum: makeNumericProp(6)
+  }, pickerToolbarProps);
+  const pickerProps = extend({}, pickerSharedProps, {
+    columns: makeArrayProp(),
+    modelValue: makeArrayProp(),
+    toolbarPosition: makeStringProp("top"),
+    columnsFieldNames: Object
+  });
+  var stdin_default$1r = vue.defineComponent({
+    name: name$1r,
+    props: pickerProps,
+    emits: ["confirm", "cancel", "change", "clickOption", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const columnsRef = vue.ref();
+      const selectedValues = vue.ref(props.modelValue.slice(0));
+      const {
+        parent
+      } = useParent(PICKER_GROUP_KEY);
+      const {
+        children,
+        linkChildren
+      } = useChildren(PICKER_KEY);
+      linkChildren();
+      const fields = vue.computed(() => assignDefaultFields(props.columnsFieldNames));
+      const optionHeight = vue.computed(() => unitToPx(props.optionHeight));
+      const columnsType = vue.computed(() => getColumnsType(props.columns, fields.value));
+      const currentColumns = vue.computed(() => {
+        const {
+          columns
+        } = props;
+        switch (columnsType.value) {
+          case "multiple":
+            return columns;
+          case "cascade":
+            return formatCascadeColumns(columns, fields.value, selectedValues);
+          default:
+            return [columns];
+        }
+      });
+      const hasOptions = vue.computed(() => currentColumns.value.some((options) => options.length));
+      const selectedOptions = vue.computed(() => currentColumns.value.map((options, index) => findOptionByValue(options, selectedValues.value[index], fields.value)));
+      const selectedIndexes = vue.computed(() => currentColumns.value.map((options, index) => options.findIndex((option) => option[fields.value.value] === selectedValues.value[index])));
+      const setValue = (index, value) => {
+        if (selectedValues.value[index] !== value) {
+          const newValues = selectedValues.value.slice(0);
+          newValues[index] = value;
+          selectedValues.value = newValues;
+        }
+      };
+      const getEventParams = () => ({
+        selectedValues: selectedValues.value.slice(0),
+        selectedOptions: selectedOptions.value,
+        selectedIndexes: selectedIndexes.value
+      });
+      const onChange = (value, columnIndex) => {
+        setValue(columnIndex, value);
+        if (columnsType.value === "cascade") {
+          selectedValues.value.forEach((value2, index) => {
+            const options = currentColumns.value[index];
+            if (!isOptionExist(options, value2, fields.value)) {
+              setValue(index, options.length ? options[0][fields.value.value] : void 0);
+            }
+          });
+        }
+        vue.nextTick(() => {
+          emit("change", extend({
+            columnIndex
+          }, getEventParams()));
+        });
+      };
+      const onClickOption = (currentOption, columnIndex) => emit("clickOption", extend({
+        columnIndex,
+        currentOption
+      }, getEventParams()));
+      const confirm = () => {
+        children.forEach((child) => child.stopMomentum());
+        const params = getEventParams();
+        vue.nextTick(() => {
+          emit("confirm", params);
+        });
+        return params;
+      };
+      const cancel = () => emit("cancel", getEventParams());
+      const renderColumnItems = () => currentColumns.value.map((options, columnIndex) => vue.createVNode(stdin_default$1B, {
+        "value": selectedValues.value[columnIndex],
+        "fields": fields.value,
+        "options": options,
+        "readonly": props.readonly,
+        "allowHtml": props.allowHtml,
+        "optionHeight": optionHeight.value,
+        "swipeDuration": props.swipeDuration,
+        "visibleOptionNum": props.visibleOptionNum,
+        "onChange": (value) => onChange(value, columnIndex),
+        "onClickOption": (option) => onClickOption(option, columnIndex)
+      }, {
+        option: slots.option
+      }));
+      const renderMask = (wrapHeight) => {
+        if (hasOptions.value) {
+          const frameStyle = {
+            height: `${optionHeight.value}px`
+          };
+          const maskStyle = {
+            backgroundSize: `100% ${(wrapHeight - optionHeight.value) / 2}px`
+          };
+          return [vue.createVNode("div", {
+            "class": bem$1m("mask"),
+            "style": maskStyle
+          }, null), vue.createVNode("div", {
+            "class": [BORDER_UNSET_TOP_BOTTOM, bem$1m("frame")],
+            "style": frameStyle
+          }, null)];
+        }
+      };
+      const renderColumns = () => {
+        const wrapHeight = optionHeight.value * +props.visibleOptionNum;
+        const columnsStyle = {
+          height: `${wrapHeight}px`
+        };
+        return vue.createVNode("div", {
+          "ref": columnsRef,
+          "class": bem$1m("columns"),
+          "style": columnsStyle
+        }, [renderColumnItems(), renderMask(wrapHeight)]);
+      };
+      const renderToolbar = () => {
+        if (props.showToolbar && !parent) {
+          return vue.createVNode(stdin_default$1A, vue.mergeProps(pick(props, pickerToolbarPropKeys), {
+            "onConfirm": confirm,
+            "onCancel": cancel
+          }), pick(slots, pickerToolbarSlots));
+        }
+      };
+      vue.watch(currentColumns, (columns) => {
+        columns.forEach((options, index) => {
+          if (options.length && !isOptionExist(options, selectedValues.value[index], fields.value)) {
+            setValue(index, getFirstEnabledOption(options)[fields.value.value]);
+          }
+        });
+      }, {
+        immediate: true
+      });
+      let lastEmittedModelValue;
+      vue.watch(() => props.modelValue, (newValues) => {
+        if (!isSameValue(newValues, selectedValues.value) && !isSameValue(newValues, lastEmittedModelValue)) {
+          selectedValues.value = newValues.slice(0);
+          lastEmittedModelValue = newValues.slice(0);
+        }
+      }, {
+        deep: true
+      });
+      vue.watch(selectedValues, (newValues) => {
+        if (!isSameValue(newValues, props.modelValue)) {
+          lastEmittedModelValue = newValues.slice(0);
+          emit("update:modelValue", lastEmittedModelValue);
+        }
+      }, {
+        immediate: true
+      });
+      useEventListener("touchmove", preventDefault, {
+        target: columnsRef
+      });
+      const getSelectedOptions = () => selectedOptions.value;
+      useExpose({
+        confirm,
+        getSelectedOptions
+      });
+      return () => {
+        var _a, _b;
+        return vue.createVNode("div", {
+          "class": bem$1m()
+        }, [props.toolbarPosition === "top" ? renderToolbar() : null, props.loading ? vue.createVNode(Loading, {
+          "class": bem$1m("loading")
+        }, null) : null, (_a = slots["columns-top"]) == null ? void 0 : _a.call(slots), renderColumns(), (_b = slots["columns-bottom"]) == null ? void 0 : _b.call(slots), props.toolbarPosition === "bottom" ? renderToolbar() : null]);
+      };
+    }
+  });
+  const AREA_EMPTY_CODE = "000000";
+  const INHERIT_SLOTS = [
+    "title",
+    "cancel",
+    "confirm",
+    "toolbar",
+    "columns-top",
+    "columns-bottom"
+  ];
+  const INHERIT_PROPS = [
+    "title",
+    "loading",
+    "readonly",
+    "optionHeight",
+    "swipeDuration",
+    "visibleOptionNum",
+    "cancelButtonText",
+    "confirmButtonText"
+  ];
+  const makeOption = (text = "", value = AREA_EMPTY_CODE, children = void 0) => ({
+    text,
+    value,
+    children
+  });
+  function formatDataForCascade({
+    areaList,
+    columnsNum,
+    columnsPlaceholder: placeholder
+  }) {
+    const {
+      city_list: city = {},
+      county_list: county = {},
+      province_list: province = {}
+    } = areaList;
+    const showCity = +columnsNum > 1;
+    const showCounty = +columnsNum > 2;
+    const getProvinceChildren = () => {
+      if (showCity) {
+        return placeholder.length ? [
+          makeOption(
+            placeholder[0],
+            AREA_EMPTY_CODE,
+            showCounty ? [] : void 0
+          )
+        ] : [];
+      }
+    };
+    const provinceMap = /* @__PURE__ */ new Map();
+    Object.keys(province).forEach((code) => {
+      provinceMap.set(
+        code.slice(0, 2),
+        makeOption(province[code], code, getProvinceChildren())
+      );
+    });
+    const cityMap = /* @__PURE__ */ new Map();
+    if (showCity) {
+      const getCityChildren = () => {
+        if (showCounty) {
+          return placeholder.length ? [makeOption(placeholder[1])] : [];
+        }
+      };
+      Object.keys(city).forEach((code) => {
+        const option = makeOption(city[code], code, getCityChildren());
+        cityMap.set(code.slice(0, 4), option);
+        const province2 = provinceMap.get(code.slice(0, 2));
+        if (province2) {
+          province2.children.push(option);
+        }
+      });
+    }
+    if (showCounty) {
+      Object.keys(county).forEach((code) => {
+        const city2 = cityMap.get(code.slice(0, 4));
+        if (city2) {
+          city2.children.push(makeOption(county[code], code));
+        }
+      });
+    }
+    const options = Array.from(provinceMap.values());
+    if (placeholder.length) {
+      const county2 = showCounty ? [makeOption(placeholder[2])] : void 0;
+      const city2 = showCity ? [makeOption(placeholder[1], AREA_EMPTY_CODE, county2)] : void 0;
+      options.unshift(makeOption(placeholder[0], AREA_EMPTY_CODE, city2));
+    }
+    return options;
+  }
+  const Picker = withInstall(stdin_default$1r);
+  const [name$1g, bem$1c] = createNamespace("area");
+  const areaProps = extend({}, pickerSharedProps, {
+    modelValue: String,
+    columnsNum: makeNumericProp(3),
+    columnsPlaceholder: makeArrayProp(),
+    areaList: {
+      type: Object,
+      default: () => ({})
+    }
+  });
+  var stdin_default$1q = vue.defineComponent({
+    name: name$1g,
+    props: areaProps,
+    emits: ["change", "confirm", "cancel", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const codes = vue.ref([]);
+      const picker = vue.ref();
+      const columns = vue.computed(() => formatDataForCascade(props));
+      const onChange = (...args) => emit("change", ...args);
+      const onCancel = (...args) => emit("cancel", ...args);
+      const onConfirm = (...args) => emit("confirm", ...args);
+      vue.watch(codes, (newCodes) => {
+        const lastCode = newCodes.length ? newCodes[newCodes.length - 1] : "";
+        if (lastCode && lastCode !== props.modelValue) {
+          emit("update:modelValue", lastCode);
+        }
+      }, {
+        deep: true
+      });
+      vue.watch(() => props.modelValue, (newCode) => {
+        if (newCode) {
+          const lastCode = codes.value.length ? codes.value[codes.value.length - 1] : "";
+          if (newCode !== lastCode) {
+            codes.value = [`${newCode.slice(0, 2)}0000`, `${newCode.slice(0, 4)}00`, newCode].slice(0, +props.columnsNum);
+          }
+        } else {
+          codes.value = [];
+        }
+      }, {
+        immediate: true
+      });
+      useExpose({
+        confirm: () => {
+          var _a;
+          return (_a = picker.value) == null ? void 0 : _a.confirm();
+        },
+        getSelectedOptions: () => {
+          var _a;
+          return ((_a = picker.value) == null ? void 0 : _a.getSelectedOptions()) || [];
+        }
+      });
+      return () => vue.createVNode(Picker, vue.mergeProps({
+        "ref": picker,
+        "modelValue": codes.value,
+        "onUpdate:modelValue": ($event) => codes.value = $event,
+        "class": bem$1c(),
+        "columns": columns.value,
+        "onChange": onChange,
+        "onCancel": onCancel,
+        "onConfirm": onConfirm
+      }, pick(props, INHERIT_PROPS)), pick(slots, INHERIT_SLOTS));
+    }
+  });
+  const Area = withInstall(stdin_default$1q);
+  const [name$1f, bem$1b] = createNamespace("cell");
+  const cellSharedProps = {
+    tag: makeStringProp("div"),
+    icon: String,
+    size: String,
+    title: numericProp,
+    value: numericProp,
+    label: numericProp,
+    center: Boolean,
+    isLink: Boolean,
+    border: truthProp,
+    required: Boolean,
+    iconPrefix: String,
+    valueClass: unknownProp,
+    labelClass: unknownProp,
+    titleClass: unknownProp,
+    titleStyle: null,
+    arrowDirection: String,
+    clickable: {
+      type: Boolean,
+      default: null
+    }
+  };
+  const cellProps = extend({}, cellSharedProps, routeProps);
+  var stdin_default$1p = vue.defineComponent({
+    name: name$1f,
+    props: cellProps,
+    setup(props, {
+      slots
+    }) {
+      const route2 = useRoute();
+      const renderLabel = () => {
+        const showLabel = slots.label || isDef(props.label);
+        if (showLabel) {
+          return vue.createVNode("div", {
+            "class": [bem$1b("label"), props.labelClass]
+          }, [slots.label ? slots.label() : props.label]);
+        }
+      };
+      const renderTitle = () => {
+        var _a;
+        if (slots.title || isDef(props.title)) {
+          const titleSlot = (_a = slots.title) == null ? void 0 : _a.call(slots);
+          if (Array.isArray(titleSlot) && titleSlot.length === 0) {
+            return;
+          }
+          return vue.createVNode("div", {
+            "class": [bem$1b("title"), props.titleClass],
+            "style": props.titleStyle
+          }, [titleSlot || vue.createVNode("span", null, [props.title]), renderLabel()]);
+        }
+      };
+      const renderValue = () => {
+        const slot = slots.value || slots.default;
+        const hasValue = slot || isDef(props.value);
+        if (hasValue) {
+          return vue.createVNode("div", {
+            "class": [bem$1b("value"), props.valueClass]
+          }, [slot ? slot() : vue.createVNode("span", null, [props.value])]);
+        }
+      };
+      const renderLeftIcon = () => {
+        if (slots.icon) {
+          return slots.icon();
+        }
+        if (props.icon) {
+          return vue.createVNode(Icon, {
+            "name": props.icon,
+            "class": bem$1b("left-icon"),
+            "classPrefix": props.iconPrefix
+          }, null);
+        }
+      };
+      const renderRightIcon = () => {
+        if (slots["right-icon"]) {
+          return slots["right-icon"]();
+        }
+        if (props.isLink) {
+          const name2 = props.arrowDirection && props.arrowDirection !== "right" ? `arrow-${props.arrowDirection}` : "arrow";
+          return vue.createVNode(Icon, {
+            "name": name2,
+            "class": bem$1b("right-icon")
+          }, null);
+        }
+      };
+      return () => {
+        var _a;
+        const {
+          tag,
+          size,
+          center,
+          border,
+          isLink,
+          required
+        } = props;
+        const clickable = (_a = props.clickable) != null ? _a : isLink;
+        const classes = {
+          center,
+          required,
+          clickable,
+          borderless: !border
+        };
+        if (size) {
+          classes[size] = !!size;
+        }
+        return vue.createVNode(tag, {
+          "class": bem$1b(classes),
+          "role": clickable ? "button" : void 0,
+          "tabindex": clickable ? 0 : void 0,
+          "onClick": route2
+        }, {
+          default: () => {
+            var _a2;
+            return [renderLeftIcon(), renderTitle(), renderValue(), renderRightIcon(), (_a2 = slots.extra) == null ? void 0 : _a2.call(slots)];
+          }
+        });
+      };
+    }
+  });
+  const Cell = withInstall(stdin_default$1p);
+  const [name$1e, bem$1a] = createNamespace("form");
+  const formProps = {
+    colon: Boolean,
+    disabled: Boolean,
+    readonly: Boolean,
+    showError: Boolean,
+    labelWidth: numericProp,
+    labelAlign: String,
+    inputAlign: String,
+    scrollToError: Boolean,
+    validateFirst: Boolean,
+    submitOnEnter: truthProp,
+    showErrorMessage: truthProp,
+    errorMessageAlign: String,
+    validateTrigger: {
+      type: [String, Array],
+      default: "onBlur"
+    }
+  };
+  var stdin_default$1o = vue.defineComponent({
+    name: name$1e,
+    props: formProps,
+    emits: ["submit", "failed"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const {
+        children,
+        linkChildren
+      } = useChildren(FORM_KEY);
+      const getFieldsByNames = (names) => {
+        if (names) {
+          return children.filter((field) => names.includes(field.name));
+        }
+        return children;
+      };
+      const validateSeq = (names) => new Promise((resolve, reject) => {
+        const errors = [];
+        const fields = getFieldsByNames(names);
+        fields.reduce((promise, field) => promise.then(() => {
+          if (!errors.length) {
+            return field.validate().then((error) => {
+              if (error) {
+                errors.push(error);
+              }
+            });
+          }
+        }), Promise.resolve()).then(() => {
+          if (errors.length) {
+            reject(errors);
+          } else {
+            resolve();
+          }
+        });
+      });
+      const validateAll = (names) => new Promise((resolve, reject) => {
+        const fields = getFieldsByNames(names);
+        Promise.all(fields.map((item) => item.validate())).then((errors) => {
+          errors = errors.filter(Boolean);
+          if (errors.length) {
+            reject(errors);
+          } else {
+            resolve();
+          }
+        });
+      });
+      const validateField = (name2) => {
+        const matched = children.find((item) => item.name === name2);
+        if (matched) {
+          return new Promise((resolve, reject) => {
+            matched.validate().then((error) => {
+              if (error) {
+                reject(error);
+              } else {
+                resolve();
+              }
+            });
+          });
+        }
+        return Promise.reject();
+      };
+      const validate = (name2) => {
+        if (typeof name2 === "string") {
+          return validateField(name2);
+        }
+        return props.validateFirst ? validateSeq(name2) : validateAll(name2);
+      };
+      const resetValidation = (name2) => {
+        if (typeof name2 === "string") {
+          name2 = [name2];
+        }
+        const fields = getFieldsByNames(name2);
+        fields.forEach((item) => {
+          item.resetValidation();
+        });
+      };
+      const getValidationStatus = () => children.reduce((form, field) => {
+        form[field.name] = field.getValidationStatus();
+        return form;
+      }, {});
+      const scrollToField = (name2, options) => {
+        children.some((item) => {
+          if (item.name === name2) {
+            item.$el.scrollIntoView(options);
+            return true;
+          }
+          return false;
+        });
+      };
+      const getValues = () => children.reduce((form, field) => {
+        if (field.name !== void 0) {
+          form[field.name] = field.formValue.value;
+        }
+        return form;
+      }, {});
+      const submit = () => {
+        const values = getValues();
+        validate().then(() => emit("submit", values)).catch((errors) => {
+          emit("failed", {
+            values,
+            errors
+          });
+          if (props.scrollToError && errors[0].name) {
+            scrollToField(errors[0].name);
+          }
+        });
+      };
+      const onSubmit = (event) => {
+        preventDefault(event);
+        submit();
+      };
+      linkChildren({
+        props
+      });
+      useExpose({
+        submit,
+        validate,
+        getValues,
+        scrollToField,
+        resetValidation,
+        getValidationStatus
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("form", {
+          "class": bem$1a(),
+          "onSubmit": onSubmit
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const Form = withInstall(stdin_default$1o);
+  function isEmptyValue(value) {
+    if (Array.isArray(value)) {
+      return !value.length;
+    }
+    if (value === 0) {
+      return false;
+    }
+    return !value;
+  }
+  function runSyncRule(value, rule) {
+    if (isEmptyValue(value)) {
+      if (rule.required) {
+        return false;
+      }
+      if (rule.validateEmpty === false) {
+        return true;
+      }
+    }
+    if (rule.pattern && !rule.pattern.test(String(value))) {
+      return false;
+    }
+    return true;
+  }
+  function runRuleValidator(value, rule) {
+    return new Promise((resolve) => {
+      const returnVal = rule.validator(value, rule);
+      if (isPromise(returnVal)) {
+        returnVal.then(resolve);
+        return;
+      }
+      resolve(returnVal);
+    });
+  }
+  function getRuleMessage(value, rule) {
+    const { message } = rule;
+    if (isFunction(message)) {
+      return message(value, rule);
+    }
+    return message || "";
+  }
+  function startComposing({ target }) {
+    target.composing = true;
+  }
+  function endComposing({ target }) {
+    if (target.composing) {
+      target.composing = false;
+      target.dispatchEvent(new Event("input"));
+    }
+  }
+  function resizeTextarea(input, autosize) {
+    const scrollTop = getRootScrollTop();
+    input.style.height = "auto";
+    let height2 = input.scrollHeight;
+    if (isObject(autosize)) {
+      const { maxHeight, minHeight } = autosize;
+      if (maxHeight !== void 0) {
+        height2 = Math.min(height2, maxHeight);
+      }
+      if (minHeight !== void 0) {
+        height2 = Math.max(height2, minHeight);
+      }
+    }
+    if (height2) {
+      input.style.height = `${height2}px`;
+      setRootScrollTop(scrollTop);
+    }
+  }
+  function mapInputType(type) {
+    if (type === "number") {
+      return {
+        type: "text",
+        inputmode: "decimal"
+      };
+    }
+    if (type === "digit") {
+      return {
+        type: "tel",
+        inputmode: "numeric"
+      };
+    }
+    return { type };
+  }
+  function getStringLength(str) {
+    return [...str].length;
+  }
+  function cutString(str, maxlength) {
+    return [...str].slice(0, maxlength).join("");
+  }
+  const [name$1d, bem$19] = createNamespace("field");
+  const fieldSharedProps = {
+    id: String,
+    name: String,
+    leftIcon: String,
+    rightIcon: String,
+    autofocus: Boolean,
+    clearable: Boolean,
+    maxlength: numericProp,
+    formatter: Function,
+    clearIcon: makeStringProp("clear"),
+    modelValue: makeNumericProp(""),
+    inputAlign: String,
+    placeholder: String,
+    autocomplete: String,
+    errorMessage: String,
+    enterkeyhint: String,
+    clearTrigger: makeStringProp("focus"),
+    formatTrigger: makeStringProp("onChange"),
+    error: {
+      type: Boolean,
+      default: null
+    },
+    disabled: {
+      type: Boolean,
+      default: null
+    },
+    readonly: {
+      type: Boolean,
+      default: null
+    }
+  };
+  const fieldProps = extend({}, cellSharedProps, fieldSharedProps, {
+    rows: numericProp,
+    type: makeStringProp("text"),
+    rules: Array,
+    autosize: [Boolean, Object],
+    labelWidth: numericProp,
+    labelClass: unknownProp,
+    labelAlign: String,
+    showWordLimit: Boolean,
+    errorMessageAlign: String,
+    colon: {
+      type: Boolean,
+      default: null
+    }
+  });
+  var stdin_default$1n = vue.defineComponent({
+    name: name$1d,
+    props: fieldProps,
+    emits: ["blur", "focus", "clear", "keypress", "clickInput", "endValidate", "startValidate", "clickLeftIcon", "clickRightIcon", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const id = useId();
+      const state = vue.reactive({
+        status: "unvalidated",
+        focused: false,
+        validateMessage: ""
+      });
+      const inputRef = vue.ref();
+      const clearIconRef = vue.ref();
+      const customValue = vue.ref();
+      const {
+        parent: form
+      } = useParent(FORM_KEY);
+      const getModelValue = () => {
+        var _a;
+        return String((_a = props.modelValue) != null ? _a : "");
+      };
+      const getProp = (key) => {
+        if (isDef(props[key])) {
+          return props[key];
+        }
+        if (form && isDef(form.props[key])) {
+          return form.props[key];
+        }
+      };
+      const showClear = vue.computed(() => {
+        const readonly = getProp("readonly");
+        if (props.clearable && !readonly) {
+          const hasValue = getModelValue() !== "";
+          const trigger = props.clearTrigger === "always" || props.clearTrigger === "focus" && state.focused;
+          return hasValue && trigger;
+        }
+        return false;
+      });
+      const formValue = vue.computed(() => {
+        if (customValue.value && slots.input) {
+          return customValue.value();
+        }
+        return props.modelValue;
+      });
+      const runRules = (rules) => rules.reduce((promise, rule) => promise.then(() => {
+        if (state.status === "failed") {
+          return;
+        }
+        let {
+          value
+        } = formValue;
+        if (rule.formatter) {
+          value = rule.formatter(value, rule);
+        }
+        if (!runSyncRule(value, rule)) {
+          state.status = "failed";
+          state.validateMessage = getRuleMessage(value, rule);
+          return;
+        }
+        if (rule.validator) {
+          if (isEmptyValue(value) && rule.validateEmpty === false) {
+            return;
+          }
+          return runRuleValidator(value, rule).then((result) => {
+            if (result && typeof result === "string") {
+              state.status = "failed";
+              state.validateMessage = result;
+            } else if (result === false) {
+              state.status = "failed";
+              state.validateMessage = getRuleMessage(value, rule);
+            }
+          });
+        }
+      }), Promise.resolve());
+      const resetValidation = () => {
+        state.status = "unvalidated";
+        state.validateMessage = "";
+      };
+      const endValidate = () => emit("endValidate", {
+        status: state.status,
+        message: state.validateMessage
+      });
+      const validate = (rules = props.rules) => new Promise((resolve) => {
+        resetValidation();
+        if (rules) {
+          emit("startValidate");
+          runRules(rules).then(() => {
+            if (state.status === "failed") {
+              resolve({
+                name: props.name,
+                message: state.validateMessage
+              });
+              endValidate();
+            } else {
+              state.status = "passed";
+              resolve();
+              endValidate();
+            }
+          });
+        } else {
+          resolve();
+        }
+      });
+      const validateWithTrigger = (trigger) => {
+        if (form && props.rules) {
+          const {
+            validateTrigger
+          } = form.props;
+          const defaultTrigger = toArray(validateTrigger).includes(trigger);
+          const rules = props.rules.filter((rule) => {
+            if (rule.trigger) {
+              return toArray(rule.trigger).includes(trigger);
+            }
+            return defaultTrigger;
+          });
+          if (rules.length) {
+            validate(rules);
+          }
+        }
+      };
+      const limitValueLength = (value) => {
+        var _a;
+        const {
+          maxlength
+        } = props;
+        if (isDef(maxlength) && getStringLength(value) > +maxlength) {
+          const modelValue = getModelValue();
+          if (modelValue && getStringLength(modelValue) === +maxlength) {
+            return modelValue;
+          }
+          const selectionEnd = (_a = inputRef.value) == null ? void 0 : _a.selectionEnd;
+          if (state.focused && selectionEnd) {
+            const valueArr = [...value];
+            const exceededLength = valueArr.length - +maxlength;
+            valueArr.splice(selectionEnd - exceededLength, exceededLength);
+            return valueArr.join("");
+          }
+          return cutString(value, +maxlength);
+        }
+        return value;
+      };
+      const updateValue = (value, trigger = "onChange") => {
+        const originalValue = value;
+        value = limitValueLength(value);
+        const limitDiffLen = getStringLength(originalValue) - getStringLength(value);
+        if (props.type === "number" || props.type === "digit") {
+          const isNumber = props.type === "number";
+          value = formatNumber(value, isNumber, isNumber);
+        }
+        let formatterDiffLen = 0;
+        if (props.formatter && trigger === props.formatTrigger) {
+          const {
+            formatter,
+            maxlength
+          } = props;
+          value = formatter(value);
+          if (isDef(maxlength) && getStringLength(value) > +maxlength) {
+            value = cutString(value, +maxlength);
+          }
+          if (inputRef.value && state.focused) {
+            const {
+              selectionEnd
+            } = inputRef.value;
+            const bcoVal = cutString(originalValue, selectionEnd);
+            formatterDiffLen = getStringLength(formatter(bcoVal)) - getStringLength(bcoVal);
+          }
+        }
+        if (inputRef.value && inputRef.value.value !== value) {
+          if (state.focused) {
+            let {
+              selectionStart,
+              selectionEnd
+            } = inputRef.value;
+            inputRef.value.value = value;
+            if (isDef(selectionStart) && isDef(selectionEnd)) {
+              const valueLen = getStringLength(value);
+              if (limitDiffLen) {
+                selectionStart -= limitDiffLen;
+                selectionEnd -= limitDiffLen;
+              } else if (formatterDiffLen) {
+                selectionStart += formatterDiffLen;
+                selectionEnd += formatterDiffLen;
+              }
+              inputRef.value.setSelectionRange(Math.min(selectionStart, valueLen), Math.min(selectionEnd, valueLen));
+            }
+          } else {
+            inputRef.value.value = value;
+          }
+        }
+        if (value !== props.modelValue) {
+          emit("update:modelValue", value);
+        }
+      };
+      const onInput = (event) => {
+        if (!event.target.composing) {
+          updateValue(event.target.value);
+        }
+      };
+      const blur = () => {
+        var _a;
+        return (_a = inputRef.value) == null ? void 0 : _a.blur();
+      };
+      const focus = () => {
+        var _a;
+        return (_a = inputRef.value) == null ? void 0 : _a.focus();
+      };
+      const adjustTextareaSize = () => {
+        const input = inputRef.value;
+        if (props.type === "textarea" && props.autosize && input) {
+          resizeTextarea(input, props.autosize);
+        }
+      };
+      const onFocus = (event) => {
+        state.focused = true;
+        emit("focus", event);
+        vue.nextTick(adjustTextareaSize);
+        if (getProp("readonly")) {
+          blur();
+        }
+      };
+      const onBlur = (event) => {
+        state.focused = false;
+        updateValue(getModelValue(), "onBlur");
+        emit("blur", event);
+        if (getProp("readonly")) {
+          return;
+        }
+        validateWithTrigger("onBlur");
+        vue.nextTick(adjustTextareaSize);
+        resetScroll();
+      };
+      const onClickInput = (event) => emit("clickInput", event);
+      const onClickLeftIcon = (event) => emit("clickLeftIcon", event);
+      const onClickRightIcon = (event) => emit("clickRightIcon", event);
+      const onClear = (event) => {
+        preventDefault(event);
+        emit("update:modelValue", "");
+        emit("clear", event);
+      };
+      const showError = vue.computed(() => {
+        if (typeof props.error === "boolean") {
+          return props.error;
+        }
+        if (form && form.props.showError && state.status === "failed") {
+          return true;
+        }
+      });
+      const labelStyle = vue.computed(() => {
+        const labelWidth = getProp("labelWidth");
+        const labelAlign = getProp("labelAlign");
+        if (labelWidth && labelAlign !== "top") {
+          return {
+            width: addUnit(labelWidth)
+          };
+        }
+      });
+      const onKeypress = (event) => {
+        const ENTER_CODE = 13;
+        if (event.keyCode === ENTER_CODE) {
+          const submitOnEnter = form && form.props.submitOnEnter;
+          if (!submitOnEnter && props.type !== "textarea") {
+            preventDefault(event);
+          }
+          if (props.type === "search") {
+            blur();
+          }
+        }
+        emit("keypress", event);
+      };
+      const getInputId = () => props.id || `${id}-input`;
+      const getValidationStatus = () => state.status;
+      const renderInput = () => {
+        const controlClass = bem$19("control", [getProp("inputAlign"), {
+          error: showError.value,
+          custom: !!slots.input,
+          "min-height": props.type === "textarea" && !props.autosize
+        }]);
+        if (slots.input) {
+          return vue.createVNode("div", {
+            "class": controlClass,
+            "onClick": onClickInput
+          }, [slots.input()]);
+        }
+        const inputAttrs = {
+          id: getInputId(),
+          ref: inputRef,
+          name: props.name,
+          rows: props.rows !== void 0 ? +props.rows : void 0,
+          class: controlClass,
+          disabled: getProp("disabled"),
+          readonly: getProp("readonly"),
+          autofocus: props.autofocus,
+          placeholder: props.placeholder,
+          autocomplete: props.autocomplete,
+          enterkeyhint: props.enterkeyhint,
+          "aria-labelledby": props.label ? `${id}-label` : void 0,
+          onBlur,
+          onFocus,
+          onInput,
+          onClick: onClickInput,
+          onChange: endComposing,
+          onKeypress,
+          onCompositionend: endComposing,
+          onCompositionstart: startComposing
+        };
+        if (props.type === "textarea") {
+          return vue.createVNode("textarea", inputAttrs, null);
+        }
+        return vue.createVNode("input", vue.mergeProps(mapInputType(props.type), inputAttrs), null);
+      };
+      const renderLeftIcon = () => {
+        const leftIconSlot = slots["left-icon"];
+        if (props.leftIcon || leftIconSlot) {
+          return vue.createVNode("div", {
+            "class": bem$19("left-icon"),
+            "onClick": onClickLeftIcon
+          }, [leftIconSlot ? leftIconSlot() : vue.createVNode(Icon, {
+            "name": props.leftIcon,
+            "classPrefix": props.iconPrefix
+          }, null)]);
+        }
+      };
+      const renderRightIcon = () => {
+        const rightIconSlot = slots["right-icon"];
+        if (props.rightIcon || rightIconSlot) {
+          return vue.createVNode("div", {
+            "class": bem$19("right-icon"),
+            "onClick": onClickRightIcon
+          }, [rightIconSlot ? rightIconSlot() : vue.createVNode(Icon, {
+            "name": props.rightIcon,
+            "classPrefix": props.iconPrefix
+          }, null)]);
+        }
+      };
+      const renderWordLimit = () => {
+        if (props.showWordLimit && props.maxlength) {
+          const count = getStringLength(getModelValue());
+          return vue.createVNode("div", {
+            "class": bem$19("word-limit")
+          }, [vue.createVNode("span", {
+            "class": bem$19("word-num")
+          }, [count]), vue.createTextVNode("/"), props.maxlength]);
+        }
+      };
+      const renderMessage = () => {
+        if (form && form.props.showErrorMessage === false) {
+          return;
+        }
+        const message = props.errorMessage || state.validateMessage;
+        if (message) {
+          const slot = slots["error-message"];
+          const errorMessageAlign = getProp("errorMessageAlign");
+          return vue.createVNode("div", {
+            "class": bem$19("error-message", errorMessageAlign)
+          }, [slot ? slot({
+            message
+          }) : message]);
+        }
+      };
+      const renderLabel = () => {
+        const labelWidth = getProp("labelWidth");
+        const labelAlign = getProp("labelAlign");
+        const colon = getProp("colon") ? ":" : "";
+        if (slots.label) {
+          return [slots.label(), colon];
+        }
+        if (props.label) {
+          return vue.createVNode("label", {
+            "id": `${id}-label`,
+            "for": getInputId(),
+            "style": labelAlign === "top" && labelWidth ? {
+              width: addUnit(labelWidth)
+            } : void 0
+          }, [props.label + colon]);
+        }
+      };
+      const renderFieldBody = () => [vue.createVNode("div", {
+        "class": bem$19("body")
+      }, [renderInput(), showClear.value && vue.createVNode(Icon, {
+        "ref": clearIconRef,
+        "name": props.clearIcon,
+        "class": bem$19("clear")
+      }, null), renderRightIcon(), slots.button && vue.createVNode("div", {
+        "class": bem$19("button")
+      }, [slots.button()])]), renderWordLimit(), renderMessage()];
+      useExpose({
+        blur,
+        focus,
+        validate,
+        formValue,
+        resetValidation,
+        getValidationStatus
+      });
+      vue.provide(CUSTOM_FIELD_INJECTION_KEY, {
+        customValue,
+        resetValidation,
+        validateWithTrigger
+      });
+      vue.watch(() => props.modelValue, () => {
+        updateValue(getModelValue());
+        resetValidation();
+        validateWithTrigger("onChange");
+        vue.nextTick(adjustTextareaSize);
+      });
+      vue.onMounted(() => {
+        updateValue(getModelValue(), props.formatTrigger);
+        vue.nextTick(adjustTextareaSize);
+      });
+      useEventListener("touchstart", onClear, {
+        target: vue.computed(() => {
+          var _a;
+          return (_a = clearIconRef.value) == null ? void 0 : _a.$el;
+        })
+      });
+      return () => {
+        const disabled = getProp("disabled");
+        const labelAlign = getProp("labelAlign");
+        const LeftIcon = renderLeftIcon();
+        const renderTitle = () => {
+          const Label = renderLabel();
+          if (labelAlign === "top") {
+            return [LeftIcon, Label].filter(Boolean);
+          }
+          return Label || [];
+        };
+        return vue.createVNode(Cell, {
+          "size": props.size,
+          "class": bem$19({
+            error: showError.value,
+            disabled,
+            [`label-${labelAlign}`]: labelAlign
+          }),
+          "center": props.center,
+          "border": props.border,
+          "isLink": props.isLink,
+          "clickable": props.clickable,
+          "titleStyle": labelStyle.value,
+          "valueClass": bem$19("value"),
+          "titleClass": [bem$19("label", [labelAlign, {
+            required: props.required
+          }]), props.labelClass],
+          "arrowDirection": props.arrowDirection
+        }, {
+          icon: LeftIcon && labelAlign !== "top" ? () => LeftIcon : null,
+          title: renderTitle,
+          value: renderFieldBody,
+          extra: slots.extra
+        });
+      };
+    }
+  });
+  const Field = withInstall(stdin_default$1n);
+  let lockCount = 0;
+  function lockClick(lock) {
+    if (lock) {
+      if (!lockCount) {
+        document.body.classList.add("van-toast--unclickable");
+      }
+      lockCount++;
+    } else if (lockCount) {
+      lockCount--;
+      if (!lockCount) {
+        document.body.classList.remove("van-toast--unclickable");
+      }
+    }
+  }
+  const [name$1c, bem$18] = createNamespace("toast");
+  const popupInheritProps = ["show", "overlay", "teleport", "transition", "overlayClass", "overlayStyle", "closeOnClickOverlay"];
+  const toastProps = {
+    icon: String,
+    show: Boolean,
+    type: makeStringProp("text"),
+    overlay: Boolean,
+    message: numericProp,
+    iconSize: numericProp,
+    duration: makeNumberProp(2e3),
+    position: makeStringProp("middle"),
+    teleport: [String, Object],
+    wordBreak: String,
+    className: unknownProp,
+    iconPrefix: String,
+    transition: makeStringProp("van-fade"),
+    loadingType: String,
+    forbidClick: Boolean,
+    overlayClass: unknownProp,
+    overlayStyle: Object,
+    closeOnClick: Boolean,
+    closeOnClickOverlay: Boolean
+  };
+  var stdin_default$1m = vue.defineComponent({
+    name: name$1c,
+    props: toastProps,
+    emits: ["update:show"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      let timer2;
+      let clickable = false;
+      const toggleClickable = () => {
+        const newValue = props.show && props.forbidClick;
+        if (clickable !== newValue) {
+          clickable = newValue;
+          lockClick(clickable);
+        }
+      };
+      const updateShow = (show) => emit("update:show", show);
+      const onClick = () => {
+        if (props.closeOnClick) {
+          updateShow(false);
+        }
+      };
+      const clearTimer = () => clearTimeout(timer2);
+      const renderIcon = () => {
+        const {
+          icon,
+          type,
+          iconSize,
+          iconPrefix,
+          loadingType
+        } = props;
+        const hasIcon = icon || type === "success" || type === "fail";
+        if (hasIcon) {
+          return vue.createVNode(Icon, {
+            "name": icon || type,
+            "size": iconSize,
+            "class": bem$18("icon"),
+            "classPrefix": iconPrefix
+          }, null);
+        }
+        if (type === "loading") {
+          return vue.createVNode(Loading, {
+            "class": bem$18("loading"),
+            "size": iconSize,
+            "type": loadingType
+          }, null);
+        }
+      };
+      const renderMessage = () => {
+        const {
+          type,
+          message
+        } = props;
+        if (slots.message) {
+          return vue.createVNode("div", {
+            "class": bem$18("text")
+          }, [slots.message()]);
+        }
+        if (isDef(message) && message !== "") {
+          return type === "html" ? vue.createVNode("div", {
+            "key": 0,
+            "class": bem$18("text"),
+            "innerHTML": String(message)
+          }, null) : vue.createVNode("div", {
+            "class": bem$18("text")
+          }, [message]);
+        }
+      };
+      vue.watch(() => [props.show, props.forbidClick], toggleClickable);
+      vue.watch(() => [props.show, props.type, props.message, props.duration], () => {
+        clearTimer();
+        if (props.show && props.duration > 0) {
+          timer2 = setTimeout(() => {
+            updateShow(false);
+          }, props.duration);
+        }
+      });
+      vue.onMounted(toggleClickable);
+      vue.onUnmounted(toggleClickable);
+      return () => vue.createVNode(Popup, vue.mergeProps({
+        "class": [bem$18([props.position, props.wordBreak === "normal" ? "break-normal" : props.wordBreak, {
+          [props.type]: !props.icon
+        }]), props.className],
+        "lockScroll": false,
+        "onClick": onClick,
+        "onClosed": clearTimer,
+        "onUpdate:show": updateShow
+      }, pick(props, popupInheritProps)), {
+        default: () => [renderIcon(), renderMessage()]
+      });
+    }
+  });
+  function usePopupState() {
+    const state = vue.reactive({
+      show: false
+    });
+    const toggle = (show) => {
+      state.show = show;
+    };
+    const open = (props) => {
+      extend(state, props, { transitionAppear: true });
+      toggle(true);
+    };
+    const close = () => toggle(false);
+    useExpose({ open, close, toggle });
+    return {
+      open,
+      close,
+      state,
+      toggle
+    };
+  }
+  function mountComponent(RootComponent) {
+    const app = vue.createApp(RootComponent);
+    const root = document.createElement("div");
+    document.body.appendChild(root);
+    return {
+      instance: app.mount(root),
+      unmount() {
+        app.unmount();
+        document.body.removeChild(root);
+      }
+    };
+  }
+  const defaultOptions$1 = {
+    icon: "",
+    type: "text",
+    message: "",
+    className: "",
+    overlay: false,
+    onClose: void 0,
+    onOpened: void 0,
+    duration: 2e3,
+    teleport: "body",
+    iconSize: void 0,
+    iconPrefix: void 0,
+    position: "middle",
+    transition: "van-fade",
+    forbidClick: false,
+    loadingType: void 0,
+    overlayClass: "",
+    overlayStyle: void 0,
+    closeOnClick: false,
+    closeOnClickOverlay: false
+  };
+  let queue = [];
+  let allowMultiple = false;
+  let currentOptions$2 = extend({}, defaultOptions$1);
+  const defaultOptionsMap = /* @__PURE__ */ new Map();
+  function parseOptions$1(message) {
+    if (isObject(message)) {
+      return message;
+    }
+    return {
+      message
+    };
+  }
+  function createInstance() {
+    const {
+      instance: instance2,
+      unmount
+    } = mountComponent({
+      setup() {
+        const message = vue.ref("");
+        const {
+          open,
+          state,
+          close,
+          toggle
+        } = usePopupState();
+        const onClosed = () => {
+          if (allowMultiple) {
+            queue = queue.filter((item) => item !== instance2);
+            unmount();
+          }
+        };
+        const render = () => {
+          const attrs = {
+            onClosed,
+            "onUpdate:show": toggle
+          };
+          return vue.createVNode(stdin_default$1m, vue.mergeProps(state, attrs), null);
+        };
+        vue.watch(message, (val) => {
+          state.message = val;
+        });
+        vue.getCurrentInstance().render = render;
+        return {
+          open,
+          close,
+          message
+        };
+      }
+    });
+    return instance2;
+  }
+  function getInstance() {
+    if (!queue.length || allowMultiple) {
+      const instance2 = createInstance();
+      queue.push(instance2);
+    }
+    return queue[queue.length - 1];
+  }
+  function showToast(options = {}) {
+    if (!inBrowser$1) {
+      return {};
+    }
+    const toast = getInstance();
+    const parsedOptions = parseOptions$1(options);
+    toast.open(extend({}, currentOptions$2, defaultOptionsMap.get(parsedOptions.type || currentOptions$2.type), parsedOptions));
+    return toast;
+  }
+  const createMethod = (type) => (options) => showToast(extend({
+    type
+  }, parseOptions$1(options)));
+  const showLoadingToast = createMethod("loading");
+  const showSuccessToast = createMethod("success");
+  const showFailToast = createMethod("fail");
+  const closeToast = (all) => {
+    var _a;
+    if (queue.length) {
+      if (all) {
+        queue.forEach((toast) => {
+          toast.close();
+        });
+        queue = [];
+      } else if (!allowMultiple) {
+        queue[0].close();
+      } else {
+        (_a = queue.shift()) == null ? void 0 : _a.close();
+      }
+    }
+  };
+  function setToastDefaultOptions(type, options) {
+    if (typeof type === "string") {
+      defaultOptionsMap.set(type, options);
+    } else {
+      extend(currentOptions$2, type);
+    }
+  }
+  const resetToastDefaultOptions = (type) => {
+    if (typeof type === "string") {
+      defaultOptionsMap.delete(type);
+    } else {
+      currentOptions$2 = extend({}, defaultOptions$1);
+      defaultOptionsMap.clear();
+    }
+  };
+  const allowMultipleToast = (value = true) => {
+    allowMultiple = value;
+  };
+  const Toast = withInstall(stdin_default$1m);
+  const [name$1b, bem$17] = createNamespace("switch");
+  const switchProps = {
+    size: numericProp,
+    loading: Boolean,
+    disabled: Boolean,
+    modelValue: unknownProp,
+    activeColor: String,
+    inactiveColor: String,
+    activeValue: {
+      type: unknownProp,
+      default: true
+    },
+    inactiveValue: {
+      type: unknownProp,
+      default: false
+    }
+  };
+  var stdin_default$1l = vue.defineComponent({
+    name: name$1b,
+    props: switchProps,
+    emits: ["change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const isChecked = () => props.modelValue === props.activeValue;
+      const onClick = () => {
+        if (!props.disabled && !props.loading) {
+          const newValue = isChecked() ? props.inactiveValue : props.activeValue;
+          emit("update:modelValue", newValue);
+          emit("change", newValue);
+        }
+      };
+      const renderLoading = () => {
+        if (props.loading) {
+          const color = isChecked() ? props.activeColor : props.inactiveColor;
+          return vue.createVNode(Loading, {
+            "class": bem$17("loading"),
+            "color": color
+          }, null);
+        }
+        if (slots.node) {
+          return slots.node();
+        }
+      };
+      useCustomFieldValue(() => props.modelValue);
+      return () => {
+        var _a;
+        const {
+          size,
+          loading,
+          disabled,
+          activeColor,
+          inactiveColor
+        } = props;
+        const checked = isChecked();
+        const style = {
+          fontSize: addUnit(size),
+          backgroundColor: checked ? activeColor : inactiveColor
+        };
+        return vue.createVNode("div", {
+          "role": "switch",
+          "class": bem$17({
+            on: checked,
+            loading,
+            disabled
+          }),
+          "style": style,
+          "tabindex": disabled ? void 0 : 0,
+          "aria-checked": checked,
+          "onClick": onClick
+        }, [vue.createVNode("div", {
+          "class": bem$17("node")
+        }, [renderLoading()]), (_a = slots.background) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const Switch = withInstall(stdin_default$1l);
+  const [name$1a, bem$16] = createNamespace("address-edit-detail");
+  const t$i = createNamespace("address-edit")[2];
+  var stdin_default$1k = vue.defineComponent({
+    name: name$1a,
+    props: {
+      show: Boolean,
+      rows: numericProp,
+      value: String,
+      rules: Array,
+      focused: Boolean,
+      maxlength: numericProp,
+      searchResult: Array,
+      showSearchResult: Boolean
+    },
+    emits: ["blur", "focus", "input", "selectSearch"],
+    setup(props, {
+      emit
+    }) {
+      const field = vue.ref();
+      const showSearchResult = () => props.focused && props.searchResult && props.showSearchResult;
+      const onSelect = (express) => {
+        emit("selectSearch", express);
+        emit("input", `${express.address || ""} ${express.name || ""}`.trim());
+      };
+      const renderSearchResult = () => {
+        if (!showSearchResult()) {
+          return;
+        }
+        const {
+          searchResult
+        } = props;
+        return searchResult.map((express) => vue.createVNode(Cell, {
+          "clickable": true,
+          "key": (express.name || "") + (express.address || ""),
+          "icon": "location-o",
+          "title": express.name,
+          "label": express.address,
+          "class": bem$16("search-item"),
+          "border": false,
+          "onClick": () => onSelect(express)
+        }, null));
+      };
+      const onBlur = (event) => emit("blur", event);
+      const onFocus = (event) => emit("focus", event);
+      const onInput = (value) => emit("input", value);
+      return () => {
+        if (props.show) {
+          return vue.createVNode(vue.Fragment, null, [vue.createVNode(Field, {
+            "autosize": true,
+            "clearable": true,
+            "ref": field,
+            "class": bem$16(),
+            "rows": props.rows,
+            "type": "textarea",
+            "rules": props.rules,
+            "label": t$i("addressDetail"),
+            "border": !showSearchResult(),
+            "maxlength": props.maxlength,
+            "modelValue": props.value,
+            "placeholder": t$i("addressDetail"),
+            "onBlur": onBlur,
+            "onFocus": onFocus,
+            "onUpdate:modelValue": onInput
+          }, null), renderSearchResult()]);
+        }
+      };
+    }
+  });
+  const [name$19, bem$15, t$h] = createNamespace("address-edit");
+  const DEFAULT_DATA = {
+    name: "",
+    tel: "",
+    city: "",
+    county: "",
+    country: "",
+    province: "",
+    areaCode: "",
+    isDefault: false,
+    addressDetail: ""
+  };
+  const addressEditProps = {
+    areaList: Object,
+    isSaving: Boolean,
+    isDeleting: Boolean,
+    validator: Function,
+    showArea: truthProp,
+    showDetail: truthProp,
+    showDelete: Boolean,
+    disableArea: Boolean,
+    searchResult: Array,
+    telMaxlength: numericProp,
+    showSetDefault: Boolean,
+    saveButtonText: String,
+    areaPlaceholder: String,
+    deleteButtonText: String,
+    showSearchResult: Boolean,
+    detailRows: makeNumericProp(1),
+    detailMaxlength: makeNumericProp(200),
+    areaColumnsPlaceholder: makeArrayProp(),
+    addressInfo: {
+      type: Object,
+      default: () => extend({}, DEFAULT_DATA)
+    },
+    telValidator: {
+      type: Function,
+      default: isMobile
+    }
+  };
+  var stdin_default$1j = vue.defineComponent({
+    name: name$19,
+    props: addressEditProps,
+    emits: ["save", "focus", "delete", "clickArea", "changeArea", "changeDetail", "selectSearch", "changeDefault"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const areaRef = vue.ref();
+      const data = vue.reactive({});
+      const showAreaPopup = vue.ref(false);
+      const detailFocused = vue.ref(false);
+      const areaListLoaded = vue.computed(() => isObject(props.areaList) && Object.keys(props.areaList).length);
+      const areaText = vue.computed(() => {
+        const {
+          province,
+          city,
+          county,
+          areaCode
+        } = data;
+        if (areaCode) {
+          const arr = [province, city, county];
+          if (province && province === city) {
+            arr.splice(1, 1);
+          }
+          return arr.filter(Boolean).join("/");
+        }
+        return "";
+      });
+      const hideBottomFields = vue.computed(() => {
+        var _a;
+        return ((_a = props.searchResult) == null ? void 0 : _a.length) && detailFocused.value;
+      });
+      const onFocus = (key) => {
+        detailFocused.value = key === "addressDetail";
+        emit("focus", key);
+      };
+      const rules = vue.computed(() => {
+        const {
+          validator,
+          telValidator
+        } = props;
+        const makeRule = (name2, emptyMessage) => ({
+          validator: (value) => {
+            if (validator) {
+              const message = validator(name2, value);
+              if (message) {
+                return message;
+              }
+            }
+            if (!value) {
+              return emptyMessage;
+            }
+            return true;
+          }
+        });
+        return {
+          name: [makeRule("name", t$h("nameEmpty"))],
+          tel: [makeRule("tel", t$h("telInvalid")), {
+            validator: telValidator,
+            message: t$h("telInvalid")
+          }],
+          areaCode: [makeRule("areaCode", t$h("areaEmpty"))],
+          addressDetail: [makeRule("addressDetail", t$h("addressEmpty"))]
+        };
+      });
+      const onSave = () => emit("save", data);
+      const onChangeDetail = (val) => {
+        data.addressDetail = val;
+        emit("changeDetail", val);
+      };
+      const assignAreaText = (options) => {
+        data.province = options[0].text;
+        data.city = options[1].text;
+        data.county = options[2].text;
+      };
+      const onAreaConfirm = ({
+        selectedValues,
+        selectedOptions
+      }) => {
+        if (selectedValues.some((value) => value === AREA_EMPTY_CODE)) {
+          showToast(t$h("areaEmpty"));
+        } else {
+          showAreaPopup.value = false;
+          assignAreaText(selectedOptions);
+          emit("changeArea", selectedOptions);
+        }
+      };
+      const onDelete = () => emit("delete", data);
+      const setAreaCode = (code) => {
+        data.areaCode = code || "";
+      };
+      const onDetailBlur = () => {
+        setTimeout(() => {
+          detailFocused.value = false;
+        });
+      };
+      const setAddressDetail = (value) => {
+        data.addressDetail = value;
+      };
+      const renderSetDefaultCell = () => {
+        if (props.showSetDefault) {
+          const slots2 = {
+            "right-icon": () => vue.createVNode(Switch, {
+              "modelValue": data.isDefault,
+              "onUpdate:modelValue": ($event) => data.isDefault = $event,
+              "onChange": (event) => emit("changeDefault", event)
+            }, null)
+          };
+          return vue.withDirectives(vue.createVNode(Cell, {
+            "center": true,
+            "title": t$h("defaultAddress"),
+            "class": bem$15("default")
+          }, slots2), [[vue.vShow, !hideBottomFields.value]]);
+        }
+      };
+      useExpose({
+        setAreaCode,
+        setAddressDetail
+      });
+      vue.watch(() => props.addressInfo, (value) => {
+        extend(data, DEFAULT_DATA, value);
+        vue.nextTick(() => {
+          var _a;
+          const options = (_a = areaRef.value) == null ? void 0 : _a.getSelectedOptions();
+          if (options && options.every((option) => option && option.value !== AREA_EMPTY_CODE)) {
+            assignAreaText(options);
+          }
+        });
+      }, {
+        deep: true,
+        immediate: true
+      });
+      return () => {
+        const {
+          disableArea
+        } = props;
+        return vue.createVNode(Form, {
+          "class": bem$15(),
+          "onSubmit": onSave
+        }, {
+          default: () => {
+            var _a;
+            return [vue.createVNode("div", {
+              "class": bem$15("fields")
+            }, [vue.createVNode(Field, {
+              "modelValue": data.name,
+              "onUpdate:modelValue": ($event) => data.name = $event,
+              "clearable": true,
+              "label": t$h("name"),
+              "rules": rules.value.name,
+              "placeholder": t$h("name"),
+              "onFocus": () => onFocus("name")
+            }, null), vue.createVNode(Field, {
+              "modelValue": data.tel,
+              "onUpdate:modelValue": ($event) => data.tel = $event,
+              "clearable": true,
+              "type": "tel",
+              "label": t$h("tel"),
+              "rules": rules.value.tel,
+              "maxlength": props.telMaxlength,
+              "placeholder": t$h("tel"),
+              "onFocus": () => onFocus("tel")
+            }, null), vue.withDirectives(vue.createVNode(Field, {
+              "readonly": true,
+              "label": t$h("area"),
+              "is-link": !disableArea,
+              "modelValue": areaText.value,
+              "rules": rules.value.areaCode,
+              "placeholder": props.areaPlaceholder || t$h("area"),
+              "onFocus": () => onFocus("areaCode"),
+              "onClick": () => {
+                emit("clickArea");
+                showAreaPopup.value = !disableArea;
+              }
+            }, null), [[vue.vShow, props.showArea]]), vue.createVNode(stdin_default$1k, {
+              "show": props.showDetail,
+              "rows": props.detailRows,
+              "rules": rules.value.addressDetail,
+              "value": data.addressDetail,
+              "focused": detailFocused.value,
+              "maxlength": props.detailMaxlength,
+              "searchResult": props.searchResult,
+              "showSearchResult": props.showSearchResult,
+              "onBlur": onDetailBlur,
+              "onFocus": () => onFocus("addressDetail"),
+              "onInput": onChangeDetail,
+              "onSelectSearch": (event) => emit("selectSearch", event)
+            }, null), (_a = slots.default) == null ? void 0 : _a.call(slots)]), renderSetDefaultCell(), vue.withDirectives(vue.createVNode("div", {
+              "class": bem$15("buttons")
+            }, [vue.createVNode(Button, {
+              "block": true,
+              "round": true,
+              "type": "primary",
+              "text": props.saveButtonText || t$h("save"),
+              "class": bem$15("button"),
+              "loading": props.isSaving,
+              "nativeType": "submit"
+            }, null), props.showDelete && vue.createVNode(Button, {
+              "block": true,
+              "round": true,
+              "class": bem$15("button"),
+              "loading": props.isDeleting,
+              "text": props.deleteButtonText || t$h("delete"),
+              "onClick": onDelete
+            }, null)]), [[vue.vShow, !hideBottomFields.value]]), vue.createVNode(Popup, {
+              "show": showAreaPopup.value,
+              "onUpdate:show": ($event) => showAreaPopup.value = $event,
+              "round": true,
+              "teleport": "body",
+              "position": "bottom",
+              "lazyRender": false
+            }, {
+              default: () => [vue.createVNode(Area, {
+                "modelValue": data.areaCode,
+                "onUpdate:modelValue": ($event) => data.areaCode = $event,
+                "ref": areaRef,
+                "loading": !areaListLoaded.value,
+                "areaList": props.areaList,
+                "columnsPlaceholder": props.areaColumnsPlaceholder,
+                "onConfirm": onAreaConfirm,
+                "onCancel": () => {
+                  showAreaPopup.value = false;
+                }
+              }, null)]
+            })];
+          }
+        });
+      };
+    }
+  });
+  const AddressEdit = withInstall(stdin_default$1j);
+  const [name$18, bem$14] = createNamespace("radio-group");
+  const radioGroupProps = {
+    disabled: Boolean,
+    iconSize: numericProp,
+    direction: String,
+    modelValue: unknownProp,
+    checkedColor: String
+  };
+  const RADIO_KEY = Symbol(name$18);
+  var stdin_default$1i = vue.defineComponent({
+    name: name$18,
+    props: radioGroupProps,
+    emits: ["change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const {
+        linkChildren
+      } = useChildren(RADIO_KEY);
+      const updateValue = (value) => emit("update:modelValue", value);
+      vue.watch(() => props.modelValue, (value) => emit("change", value));
+      linkChildren({
+        props,
+        updateValue
+      });
+      useCustomFieldValue(() => props.modelValue);
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "class": bem$14([props.direction]),
+          "role": "radiogroup"
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const RadioGroup = withInstall(stdin_default$1i);
+  const [name$17, bem$13] = createNamespace("tag");
+  const tagProps = {
+    size: String,
+    mark: Boolean,
+    show: truthProp,
+    type: makeStringProp("default"),
+    color: String,
+    plain: Boolean,
+    round: Boolean,
+    textColor: String,
+    closeable: Boolean
+  };
+  var stdin_default$1h = vue.defineComponent({
+    name: name$17,
+    props: tagProps,
+    emits: ["close"],
+    setup(props, {
+      slots,
+      emit
+    }) {
+      const onClose = (event) => {
+        event.stopPropagation();
+        emit("close", event);
+      };
+      const getStyle = () => {
+        if (props.plain) {
+          return {
+            color: props.textColor || props.color,
+            borderColor: props.color
+          };
+        }
+        return {
+          color: props.textColor,
+          background: props.color
+        };
+      };
+      const renderTag = () => {
+        var _a;
+        const {
+          type,
+          mark,
+          plain,
+          round: round2,
+          size,
+          closeable
+        } = props;
+        const classes = {
+          mark,
+          plain,
+          round: round2
+        };
+        if (size) {
+          classes[size] = size;
+        }
+        const CloseIcon = closeable && vue.createVNode(Icon, {
+          "name": "cross",
+          "class": [bem$13("close"), HAPTICS_FEEDBACK],
+          "onClick": onClose
+        }, null);
+        return vue.createVNode("span", {
+          "style": getStyle(),
+          "class": bem$13([classes, type])
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots), CloseIcon]);
+      };
+      return () => vue.createVNode(vue.Transition, {
+        "name": props.closeable ? "van-fade" : void 0
+      }, {
+        default: () => [props.show ? renderTag() : null]
+      });
+    }
+  });
+  const Tag = withInstall(stdin_default$1h);
+  const checkerProps = {
+    name: unknownProp,
+    shape: makeStringProp("round"),
+    disabled: Boolean,
+    iconSize: numericProp,
+    modelValue: unknownProp,
+    checkedColor: String,
+    labelPosition: String,
+    labelDisabled: Boolean
+  };
+  var stdin_default$1g = vue.defineComponent({
+    props: extend({}, checkerProps, {
+      bem: makeRequiredProp(Function),
+      role: String,
+      parent: Object,
+      checked: Boolean,
+      bindGroup: truthProp
+    }),
+    emits: ["click", "toggle"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const iconRef = vue.ref();
+      const getParentProp = (name2) => {
+        if (props.parent && props.bindGroup) {
+          return props.parent.props[name2];
+        }
+      };
+      const disabled = vue.computed(() => getParentProp("disabled") || props.disabled);
+      const direction = vue.computed(() => getParentProp("direction"));
+      const iconStyle = vue.computed(() => {
+        const checkedColor = props.checkedColor || getParentProp("checkedColor");
+        if (checkedColor && props.checked && !disabled.value) {
+          return {
+            borderColor: checkedColor,
+            backgroundColor: checkedColor
+          };
+        }
+      });
+      const onClick = (event) => {
+        const {
+          target
+        } = event;
+        const icon = iconRef.value;
+        const iconClicked = icon === target || (icon == null ? void 0 : icon.contains(target));
+        if (!disabled.value && (iconClicked || !props.labelDisabled)) {
+          emit("toggle");
+        }
+        emit("click", event);
+      };
+      const renderIcon = () => {
+        const {
+          bem: bem2,
+          shape,
+          checked
+        } = props;
+        const iconSize = props.iconSize || getParentProp("iconSize");
+        return vue.createVNode("div", {
+          "ref": iconRef,
+          "class": bem2("icon", [shape, {
+            disabled: disabled.value,
+            checked
+          }]),
+          "style": {
+            fontSize: addUnit(iconSize)
+          }
+        }, [slots.icon ? slots.icon({
+          checked,
+          disabled: disabled.value
+        }) : vue.createVNode(Icon, {
+          "name": "success",
+          "style": iconStyle.value
+        }, null)]);
+      };
+      const renderLabel = () => {
+        if (slots.default) {
+          return vue.createVNode("span", {
+            "class": props.bem("label", [props.labelPosition, {
+              disabled: disabled.value
+            }])
+          }, [slots.default()]);
+        }
+      };
+      return () => {
+        const nodes = props.labelPosition === "left" ? [renderLabel(), renderIcon()] : [renderIcon(), renderLabel()];
+        return vue.createVNode("div", {
+          "role": props.role,
+          "class": props.bem([{
+            disabled: disabled.value,
+            "label-disabled": props.labelDisabled
+          }, direction.value]),
+          "tabindex": disabled.value ? void 0 : 0,
+          "aria-checked": props.checked,
+          "onClick": onClick
+        }, [nodes]);
+      };
+    }
+  });
+  const radioProps = checkerProps;
+  const [name$16, bem$12] = createNamespace("radio");
+  var stdin_default$1f = vue.defineComponent({
+    name: name$16,
+    props: checkerProps,
+    emits: ["update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const {
+        parent
+      } = useParent(RADIO_KEY);
+      const checked = () => {
+        const value = parent ? parent.props.modelValue : props.modelValue;
+        return value === props.name;
+      };
+      const toggle = () => {
+        if (parent) {
+          parent.updateValue(props.name);
+        } else {
+          emit("update:modelValue", props.name);
+        }
+      };
+      return () => vue.createVNode(stdin_default$1g, vue.mergeProps({
+        "bem": bem$12,
+        "role": "radio",
+        "parent": parent,
+        "checked": checked(),
+        "onToggle": toggle
+      }, props), pick(slots, ["default", "icon"]));
+    }
+  });
+  const Radio = withInstall(stdin_default$1f);
+  const [name$15, bem$11] = createNamespace("address-item");
+  var stdin_default$1e = vue.defineComponent({
+    name: name$15,
+    props: {
+      address: makeRequiredProp(Object),
+      disabled: Boolean,
+      switchable: Boolean,
+      defaultTagText: String
+    },
+    emits: ["edit", "click", "select"],
+    setup(props, {
+      slots,
+      emit
+    }) {
+      const onClick = () => {
+        if (props.switchable) {
+          emit("select");
+        }
+        emit("click");
+      };
+      const renderRightIcon = () => vue.createVNode(Icon, {
+        "name": "edit",
+        "class": bem$11("edit"),
+        "onClick": (event) => {
+          event.stopPropagation();
+          emit("edit");
+          emit("click");
+        }
+      }, null);
+      const renderTag = () => {
+        if (slots.tag) {
+          return slots.tag(props.address);
+        }
+        if (props.address.isDefault && props.defaultTagText) {
+          return vue.createVNode(Tag, {
+            "type": "primary",
+            "round": true,
+            "class": bem$11("tag")
+          }, {
+            default: () => [props.defaultTagText]
+          });
+        }
+      };
+      const renderContent = () => {
+        const {
+          address,
+          disabled,
+          switchable
+        } = props;
+        const Info = [vue.createVNode("div", {
+          "class": bem$11("name")
+        }, [`${address.name} ${address.tel}`, renderTag()]), vue.createVNode("div", {
+          "class": bem$11("address")
+        }, [address.address])];
+        if (switchable && !disabled) {
+          return vue.createVNode(Radio, {
+            "name": address.id,
+            "iconSize": 18
+          }, {
+            default: () => [Info]
+          });
+        }
+        return Info;
+      };
+      return () => {
+        var _a;
+        const {
+          disabled
+        } = props;
+        return vue.createVNode("div", {
+          "class": bem$11({
+            disabled
+          }),
+          "onClick": onClick
+        }, [vue.createVNode(Cell, {
+          "border": false,
+          "titleClass": bem$11("title")
+        }, {
+          title: renderContent,
+          "right-icon": renderRightIcon
+        }), (_a = slots.bottom) == null ? void 0 : _a.call(slots, extend({}, props.address, {
+          disabled
+        }))]);
+      };
+    }
+  });
+  const [name$14, bem$10, t$g] = createNamespace("address-list");
+  const addressListProps = {
+    list: makeArrayProp(),
+    modelValue: numericProp,
+    switchable: truthProp,
+    disabledText: String,
+    disabledList: makeArrayProp(),
+    addButtonText: String,
+    defaultTagText: String
+  };
+  var stdin_default$1d = vue.defineComponent({
+    name: name$14,
+    props: addressListProps,
+    emits: ["add", "edit", "select", "clickItem", "editDisabled", "selectDisabled", "update:modelValue"],
+    setup(props, {
+      slots,
+      emit
+    }) {
+      const renderItem = (item, index, disabled) => {
+        const onEdit = () => emit(disabled ? "editDisabled" : "edit", item, index);
+        const onClick = () => emit("clickItem", item, index);
+        const onSelect = () => {
+          emit(disabled ? "selectDisabled" : "select", item, index);
+          if (!disabled) {
+            emit("update:modelValue", item.id);
+          }
+        };
+        return vue.createVNode(stdin_default$1e, {
+          "key": item.id,
+          "address": item,
+          "disabled": disabled,
+          "switchable": props.switchable,
+          "defaultTagText": props.defaultTagText,
+          "onEdit": onEdit,
+          "onClick": onClick,
+          "onSelect": onSelect
+        }, {
+          bottom: slots["item-bottom"],
+          tag: slots.tag
+        });
+      };
+      const renderList = (list, disabled) => {
+        if (list) {
+          return list.map((item, index) => renderItem(item, index, disabled));
+        }
+      };
+      const renderBottom = () => vue.createVNode("div", {
+        "class": [bem$10("bottom"), "van-safe-area-bottom"]
+      }, [vue.createVNode(Button, {
+        "round": true,
+        "block": true,
+        "type": "primary",
+        "text": props.addButtonText || t$g("add"),
+        "class": bem$10("add"),
+        "onClick": () => emit("add")
+      }, null)]);
+      return () => {
+        var _a, _b;
+        const List2 = renderList(props.list);
+        const DisabledList = renderList(props.disabledList, true);
+        const DisabledText = props.disabledText && vue.createVNode("div", {
+          "class": bem$10("disabled-text")
+        }, [props.disabledText]);
+        return vue.createVNode("div", {
+          "class": bem$10()
+        }, [(_a = slots.top) == null ? void 0 : _a.call(slots), vue.createVNode(RadioGroup, {
+          "modelValue": props.modelValue
+        }, {
+          default: () => [List2]
+        }), DisabledText, DisabledList, (_b = slots.default) == null ? void 0 : _b.call(slots), renderBottom()]);
+      };
+    }
+  });
+  const AddressList = withInstall(stdin_default$1d);
+  const hasIntersectionObserver = inBrowser && "IntersectionObserver" in window && "IntersectionObserverEntry" in window && "intersectionRatio" in window.IntersectionObserverEntry.prototype;
+  const modeType = {
+    event: "event",
+    observer: "observer"
+  };
+  function remove(arr, item) {
+    if (!arr.length)
+      return;
+    const index = arr.indexOf(item);
+    if (index > -1)
+      return arr.splice(index, 1);
+  }
+  function getBestSelectionFromSrcset(el, scale) {
+    if (el.tagName !== "IMG" || !el.getAttribute("data-srcset"))
+      return;
+    let options = el.getAttribute("data-srcset");
+    const container = el.parentNode;
+    const containerWidth = container.offsetWidth * scale;
+    let spaceIndex;
+    let tmpSrc;
+    let tmpWidth;
+    options = options.trim().split(",");
+    const result = options.map((item) => {
+      item = item.trim();
+      spaceIndex = item.lastIndexOf(" ");
+      if (spaceIndex === -1) {
+        tmpSrc = item;
+        tmpWidth = 999998;
+      } else {
+        tmpSrc = item.substr(0, spaceIndex);
+        tmpWidth = parseInt(
+          item.substr(spaceIndex + 1, item.length - spaceIndex - 2),
+          10
+        );
+      }
+      return [tmpWidth, tmpSrc];
+    });
+    result.sort((a, b) => {
+      if (a[0] < b[0]) {
+        return 1;
+      }
+      if (a[0] > b[0]) {
+        return -1;
+      }
+      if (a[0] === b[0]) {
+        if (b[1].indexOf(".webp", b[1].length - 5) !== -1) {
+          return 1;
+        }
+        if (a[1].indexOf(".webp", a[1].length - 5) !== -1) {
+          return -1;
+        }
+      }
+      return 0;
+    });
+    let bestSelectedSrc = "";
+    let tmpOption;
+    for (let i = 0; i < result.length; i++) {
+      tmpOption = result[i];
+      bestSelectedSrc = tmpOption[1];
+      const next = result[i + 1];
+      if (next && next[0] < containerWidth) {
+        bestSelectedSrc = tmpOption[1];
+        break;
+      } else if (!next) {
+        bestSelectedSrc = tmpOption[1];
+        break;
+      }
+    }
+    return bestSelectedSrc;
+  }
+  const getDPR = (scale = 1) => inBrowser ? window.devicePixelRatio || scale : scale;
+  function supportWebp() {
+    if (!inBrowser)
+      return false;
+    let support = true;
+    try {
+      const elem = document.createElement("canvas");
+      if (elem.getContext && elem.getContext("2d")) {
+        support = elem.toDataURL("image/webp").indexOf("data:image/webp") === 0;
+      }
+    } catch (err) {
+      support = false;
+    }
+    return support;
+  }
+  function throttle(action, delay) {
+    let timeout = null;
+    let lastRun = 0;
+    return function(...args) {
+      if (timeout) {
+        return;
+      }
+      const elapsed = Date.now() - lastRun;
+      const runCallback = () => {
+        lastRun = Date.now();
+        timeout = false;
+        action.apply(this, args);
+      };
+      if (elapsed >= delay) {
+        runCallback();
+      } else {
+        timeout = setTimeout(runCallback, delay);
+      }
+    };
+  }
+  function on(el, type, func) {
+    el.addEventListener(type, func, {
+      capture: false,
+      passive: true
+    });
+  }
+  function off(el, type, func) {
+    el.removeEventListener(type, func, false);
+  }
+  const loadImageAsync = (item, resolve, reject) => {
+    const image = new Image();
+    if (!item || !item.src) {
+      return reject(new Error("image src is required"));
+    }
+    image.src = item.src;
+    if (item.cors) {
+      image.crossOrigin = item.cors;
+    }
+    image.onload = () => resolve({
+      naturalHeight: image.naturalHeight,
+      naturalWidth: image.naturalWidth,
+      src: image.src
+    });
+    image.onerror = (e) => reject(e);
+  };
+  class ImageCache {
+    constructor({ max }) {
+      this.options = {
+        max: max || 100
+      };
+      this.caches = [];
+    }
+    has(key) {
+      return this.caches.indexOf(key) > -1;
+    }
+    add(key) {
+      if (this.has(key))
+        return;
+      this.caches.push(key);
+      if (this.caches.length > this.options.max) {
+        this.free();
+      }
+    }
+    free() {
+      this.caches.shift();
+    }
+  }
+  const [name$13, bem$$] = createNamespace("back-top");
+  const backTopProps = {
+    right: numericProp,
+    bottom: numericProp,
+    zIndex: numericProp,
+    target: [String, Object],
+    offset: makeNumericProp(200),
+    immediate: Boolean,
+    teleport: {
+      type: [String, Object],
+      default: "body"
+    }
+  };
+  var stdin_default$1c = vue.defineComponent({
+    name: name$13,
+    inheritAttrs: false,
+    props: backTopProps,
+    emits: ["click"],
+    setup(props, {
+      emit,
+      slots,
+      attrs
+    }) {
+      const show = vue.ref(false);
+      const root = vue.ref();
+      const scrollParent = vue.ref();
+      const style = vue.computed(() => extend(getZIndexStyle(props.zIndex), {
+        right: addUnit(props.right),
+        bottom: addUnit(props.bottom)
+      }));
+      const onClick = (event) => {
+        var _a;
+        emit("click", event);
+        (_a = scrollParent.value) == null ? void 0 : _a.scrollTo({
+          top: 0,
+          behavior: props.immediate ? "auto" : "smooth"
+        });
+      };
+      const scroll = () => {
+        show.value = scrollParent.value ? getScrollTop(scrollParent.value) >= +props.offset : false;
+      };
+      const getTarget = () => {
+        const {
+          target
+        } = props;
+        if (typeof target === "string") {
+          const el = document.querySelector(target);
+          if (el) {
+            return el;
+          }
+        } else {
+          return target;
+        }
+      };
+      const updateTarget = () => {
+        if (inBrowser$1) {
+          vue.nextTick(() => {
+            scrollParent.value = props.target ? getTarget() : getScrollParent$1(root.value);
+            scroll();
+          });
+        }
+      };
+      useEventListener("scroll", throttle(scroll, 100), {
+        target: scrollParent
+      });
+      vue.onMounted(updateTarget);
+      vue.watch(() => props.target, updateTarget);
+      return () => {
+        const Content = vue.createVNode("div", vue.mergeProps({
+          "ref": root,
+          "class": bem$$({
+            active: show.value
+          }),
+          "style": style.value,
+          "onClick": onClick
+        }, attrs), [slots.default ? slots.default() : vue.createVNode(Icon, {
+          "name": "back-top",
+          "class": bem$$("icon")
+        }, null)]);
+        if (props.teleport) {
+          return vue.createVNode(vue.Teleport, {
+            "to": props.teleport
+          }, {
+            default: () => [Content]
+          });
+        }
+        return Content;
+      };
+    }
+  });
+  const BackTop = withInstall(stdin_default$1c);
+  const [name$12, bem$_, t$f] = createNamespace("calendar");
+  const formatMonthTitle = (date) => t$f("monthTitle", date.getFullYear(), date.getMonth() + 1);
+  function compareMonth(date1, date2) {
+    const year1 = date1.getFullYear();
+    const year2 = date2.getFullYear();
+    if (year1 === year2) {
+      const month1 = date1.getMonth();
+      const month2 = date2.getMonth();
+      return month1 === month2 ? 0 : month1 > month2 ? 1 : -1;
+    }
+    return year1 > year2 ? 1 : -1;
+  }
+  function compareDay(day1, day2) {
+    const compareMonthResult = compareMonth(day1, day2);
+    if (compareMonthResult === 0) {
+      const date1 = day1.getDate();
+      const date2 = day2.getDate();
+      return date1 === date2 ? 0 : date1 > date2 ? 1 : -1;
+    }
+    return compareMonthResult;
+  }
+  const cloneDate = (date) => new Date(date);
+  const cloneDates = (dates) => Array.isArray(dates) ? dates.map(cloneDate) : cloneDate(dates);
+  function getDayByOffset(date, offset2) {
+    const cloned = cloneDate(date);
+    cloned.setDate(cloned.getDate() + offset2);
+    return cloned;
+  }
+  const getPrevDay = (date) => getDayByOffset(date, -1);
+  const getNextDay = (date) => getDayByOffset(date, 1);
+  const getToday = () => {
+    const today = /* @__PURE__ */ new Date();
+    today.setHours(0, 0, 0, 0);
+    return today;
+  };
+  function calcDateNum(date) {
+    const day1 = date[0].getTime();
+    const day2 = date[1].getTime();
+    return (day2 - day1) / (1e3 * 60 * 60 * 24) + 1;
+  }
+  const sharedProps = extend({}, pickerSharedProps, {
+    modelValue: makeArrayProp(),
+    filter: Function,
+    formatter: {
+      type: Function,
+      default: (type, option) => option
+    }
+  });
+  const pickerInheritKeys = Object.keys(pickerSharedProps);
+  function times(n, iteratee) {
+    if (n < 0) {
+      return [];
+    }
+    const result = Array(n);
+    let index = -1;
+    while (++index < n) {
+      result[index] = iteratee(index);
+    }
+    return result;
+  }
+  const getMonthEndDay = (year, month) => 32 - new Date(year, month - 1, 32).getDate();
+  const genOptions = (min, max, type, formatter, filter) => {
+    const options = times(max - min + 1, (index) => {
+      const value = padZero(min + index);
+      return formatter(type, {
+        text: value,
+        value
+      });
+    });
+    return filter ? filter(type, options) : options;
+  };
+  const formatValueRange = (values, columns) => values.map((value, index) => {
+    const column = columns[index];
+    if (column.length) {
+      const maxValue = +column[column.length - 1].value;
+      if (+value > maxValue) {
+        return String(maxValue);
+      }
+    }
+    return value;
+  });
+  const [name$11] = createNamespace("calendar-day");
+  var stdin_default$1b = vue.defineComponent({
+    name: name$11,
+    props: {
+      item: makeRequiredProp(Object),
+      color: String,
+      index: Number,
+      offset: makeNumberProp(0),
+      rowHeight: String
+    },
+    emits: ["click"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const style = vue.computed(() => {
+        var _a;
+        const {
+          item,
+          index,
+          color,
+          offset: offset2,
+          rowHeight
+        } = props;
+        const style2 = {
+          height: rowHeight
+        };
+        if (item.type === "placeholder") {
+          style2.width = "100%";
+          return style2;
+        }
+        if (index === 0) {
+          style2.marginLeft = `${100 * offset2 / 7}%`;
+        }
+        if (color) {
+          switch (item.type) {
+            case "end":
+            case "start":
+            case "start-end":
+            case "multiple-middle":
+            case "multiple-selected":
+              style2.background = color;
+              break;
+            case "middle":
+              style2.color = color;
+              break;
+          }
+        }
+        if (offset2 + (((_a = item.date) == null ? void 0 : _a.getDate()) || 1) > 28) {
+          style2.marginBottom = 0;
+        }
+        return style2;
+      });
+      const onClick = () => {
+        if (props.item.type !== "disabled") {
+          emit("click", props.item);
+        }
+      };
+      const renderTopInfo = () => {
+        const {
+          topInfo
+        } = props.item;
+        if (topInfo || slots["top-info"]) {
+          return vue.createVNode("div", {
+            "class": bem$_("top-info")
+          }, [slots["top-info"] ? slots["top-info"](props.item) : topInfo]);
+        }
+      };
+      const renderBottomInfo = () => {
+        const {
+          bottomInfo
+        } = props.item;
+        if (bottomInfo || slots["bottom-info"]) {
+          return vue.createVNode("div", {
+            "class": bem$_("bottom-info")
+          }, [slots["bottom-info"] ? slots["bottom-info"](props.item) : bottomInfo]);
+        }
+      };
+      const renderContent = () => {
+        const {
+          item,
+          color,
+          rowHeight
+        } = props;
+        const {
+          type,
+          text
+        } = item;
+        const Nodes = [renderTopInfo(), text, renderBottomInfo()];
+        if (type === "selected") {
+          return vue.createVNode("div", {
+            "class": bem$_("selected-day"),
+            "style": {
+              width: rowHeight,
+              height: rowHeight,
+              background: color
+            }
+          }, [Nodes]);
+        }
+        return Nodes;
+      };
+      return () => {
+        const {
+          type,
+          className
+        } = props.item;
+        if (type === "placeholder") {
+          return vue.createVNode("div", {
+            "class": bem$_("day"),
+            "style": style.value
+          }, null);
+        }
+        return vue.createVNode("div", {
+          "role": "gridcell",
+          "style": style.value,
+          "class": [bem$_("day", type), className],
+          "tabindex": type === "disabled" ? void 0 : -1,
+          "onClick": onClick
+        }, [renderContent()]);
+      };
+    }
+  });
+  const [name$10] = createNamespace("calendar-month");
+  const calendarMonthProps = {
+    date: makeRequiredProp(Date),
+    type: String,
+    color: String,
+    minDate: makeRequiredProp(Date),
+    maxDate: makeRequiredProp(Date),
+    showMark: Boolean,
+    rowHeight: numericProp,
+    formatter: Function,
+    lazyRender: Boolean,
+    currentDate: [Date, Array],
+    allowSameDay: Boolean,
+    showSubtitle: Boolean,
+    showMonthTitle: Boolean,
+    firstDayOfWeek: Number
+  };
+  var stdin_default$1a = vue.defineComponent({
+    name: name$10,
+    props: calendarMonthProps,
+    emits: ["click"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const [visible, setVisible] = useToggle();
+      const daysRef = vue.ref();
+      const monthRef = vue.ref();
+      const height2 = useHeight(monthRef);
+      const title = vue.computed(() => formatMonthTitle(props.date));
+      const rowHeight = vue.computed(() => addUnit(props.rowHeight));
+      const offset2 = vue.computed(() => {
+        const realDay = props.date.getDay();
+        if (props.firstDayOfWeek) {
+          return (realDay + 7 - props.firstDayOfWeek) % 7;
+        }
+        return realDay;
+      });
+      const totalDay = vue.computed(() => getMonthEndDay(props.date.getFullYear(), props.date.getMonth() + 1));
+      const shouldRender = vue.computed(() => visible.value || !props.lazyRender);
+      const getTitle = () => title.value;
+      const getMultipleDayType = (day) => {
+        const isSelected = (date) => props.currentDate.some((item) => compareDay(item, date) === 0);
+        if (isSelected(day)) {
+          const prevDay = getPrevDay(day);
+          const nextDay = getNextDay(day);
+          const prevSelected = isSelected(prevDay);
+          const nextSelected = isSelected(nextDay);
+          if (prevSelected && nextSelected) {
+            return "multiple-middle";
+          }
+          if (prevSelected) {
+            return "end";
+          }
+          if (nextSelected) {
+            return "start";
+          }
+          return "multiple-selected";
+        }
+        return "";
+      };
+      const getRangeDayType = (day) => {
+        const [startDay, endDay] = props.currentDate;
+        if (!startDay) {
+          return "";
+        }
+        const compareToStart = compareDay(day, startDay);
+        if (!endDay) {
+          return compareToStart === 0 ? "start" : "";
+        }
+        const compareToEnd = compareDay(day, endDay);
+        if (props.allowSameDay && compareToStart === 0 && compareToEnd === 0) {
+          return "start-end";
+        }
+        if (compareToStart === 0) {
+          return "start";
+        }
+        if (compareToEnd === 0) {
+          return "end";
+        }
+        if (compareToStart > 0 && compareToEnd < 0) {
+          return "middle";
+        }
+        return "";
+      };
+      const getDayType = (day) => {
+        const {
+          type,
+          minDate,
+          maxDate,
+          currentDate
+        } = props;
+        if (compareDay(day, minDate) < 0 || compareDay(day, maxDate) > 0) {
+          return "disabled";
+        }
+        if (currentDate === null) {
+          return "";
+        }
+        if (Array.isArray(currentDate)) {
+          if (type === "multiple") {
+            return getMultipleDayType(day);
+          }
+          if (type === "range") {
+            return getRangeDayType(day);
+          }
+        } else if (type === "single") {
+          return compareDay(day, currentDate) === 0 ? "selected" : "";
+        }
+        return "";
+      };
+      const getBottomInfo = (dayType) => {
+        if (props.type === "range") {
+          if (dayType === "start" || dayType === "end") {
+            return t$f(dayType);
+          }
+          if (dayType === "start-end") {
+            return `${t$f("start")}/${t$f("end")}`;
+          }
+        }
+      };
+      const renderTitle = () => {
+        if (props.showMonthTitle) {
+          return vue.createVNode("div", {
+            "class": bem$_("month-title")
+          }, [slots["month-title"] ? slots["month-title"]({
+            date: props.date,
+            text: title.value
+          }) : title.value]);
+        }
+      };
+      const renderMark = () => {
+        if (props.showMark && shouldRender.value) {
+          return vue.createVNode("div", {
+            "class": bem$_("month-mark")
+          }, [props.date.getMonth() + 1]);
+        }
+      };
+      const placeholders = vue.computed(() => {
+        const count = Math.ceil((totalDay.value + offset2.value) / 7);
+        return Array(count).fill({
+          type: "placeholder"
+        });
+      });
+      const days = vue.computed(() => {
+        const days2 = [];
+        const year = props.date.getFullYear();
+        const month = props.date.getMonth();
+        for (let day = 1; day <= totalDay.value; day++) {
+          const date = new Date(year, month, day);
+          const type = getDayType(date);
+          let config = {
+            date,
+            type,
+            text: day,
+            bottomInfo: getBottomInfo(type)
+          };
+          if (props.formatter) {
+            config = props.formatter(config);
+          }
+          days2.push(config);
+        }
+        return days2;
+      });
+      const disabledDays = vue.computed(() => days.value.filter((day) => day.type === "disabled"));
+      const scrollToDate = (body, targetDate) => {
+        if (daysRef.value) {
+          const daysRect = useRect(daysRef.value);
+          const totalRows = placeholders.value.length;
+          const currentRow = Math.ceil((targetDate.getDate() + offset2.value) / 7);
+          const rowOffset = (currentRow - 1) * daysRect.height / totalRows;
+          setScrollTop(body, daysRect.top + rowOffset + body.scrollTop - useRect(body).top);
+        }
+      };
+      const renderDay = (item, index) => vue.createVNode(stdin_default$1b, {
+        "item": item,
+        "index": index,
+        "color": props.color,
+        "offset": offset2.value,
+        "rowHeight": rowHeight.value,
+        "onClick": (item2) => emit("click", item2)
+      }, pick(slots, ["top-info", "bottom-info"]));
+      const renderDays = () => vue.createVNode("div", {
+        "ref": daysRef,
+        "role": "grid",
+        "class": bem$_("days")
+      }, [renderMark(), (shouldRender.value ? days : placeholders).value.map(renderDay)]);
+      useExpose({
+        getTitle,
+        getHeight: () => height2.value,
+        setVisible,
+        scrollToDate,
+        disabledDays
+      });
+      return () => vue.createVNode("div", {
+        "class": bem$_("month"),
+        "ref": monthRef
+      }, [renderTitle(), renderDays()]);
+    }
+  });
+  const [name$$] = createNamespace("calendar-header");
+  var stdin_default$19 = vue.defineComponent({
+    name: name$$,
+    props: {
+      date: Date,
+      title: String,
+      subtitle: String,
+      showTitle: Boolean,
+      showSubtitle: Boolean,
+      firstDayOfWeek: Number
+    },
+    emits: ["clickSubtitle"],
+    setup(props, {
+      slots,
+      emit
+    }) {
+      const renderTitle = () => {
+        if (props.showTitle) {
+          const text = props.title || t$f("title");
+          const title = slots.title ? slots.title() : text;
+          return vue.createVNode("div", {
+            "class": bem$_("header-title")
+          }, [title]);
+        }
+      };
+      const onClickSubtitle = (event) => emit("clickSubtitle", event);
+      const renderSubtitle = () => {
+        if (props.showSubtitle) {
+          const title = slots.subtitle ? slots.subtitle({
+            date: props.date,
+            text: props.subtitle
+          }) : props.subtitle;
+          return vue.createVNode("div", {
+            "class": bem$_("header-subtitle"),
+            "onClick": onClickSubtitle
+          }, [title]);
+        }
+      };
+      const renderWeekDays = () => {
+        const {
+          firstDayOfWeek
+        } = props;
+        const weekdays = t$f("weekdays");
+        const renderWeekDays2 = [...weekdays.slice(firstDayOfWeek, 7), ...weekdays.slice(0, firstDayOfWeek)];
+        return vue.createVNode("div", {
+          "class": bem$_("weekdays")
+        }, [renderWeekDays2.map((text) => vue.createVNode("span", {
+          "class": bem$_("weekday")
+        }, [text]))]);
+      };
+      return () => vue.createVNode("div", {
+        "class": bem$_("header")
+      }, [renderTitle(), renderSubtitle(), renderWeekDays()]);
+    }
+  });
+  const calendarProps = {
+    show: Boolean,
+    type: makeStringProp("single"),
+    title: String,
+    color: String,
+    round: truthProp,
+    readonly: Boolean,
+    poppable: truthProp,
+    maxRange: makeNumericProp(null),
+    position: makeStringProp("bottom"),
+    teleport: [String, Object],
+    showMark: truthProp,
+    showTitle: truthProp,
+    formatter: Function,
+    rowHeight: numericProp,
+    confirmText: String,
+    rangePrompt: String,
+    lazyRender: truthProp,
+    showConfirm: truthProp,
+    defaultDate: [Date, Array],
+    allowSameDay: Boolean,
+    showSubtitle: truthProp,
+    closeOnPopstate: truthProp,
+    showRangePrompt: truthProp,
+    confirmDisabledText: String,
+    closeOnClickOverlay: truthProp,
+    safeAreaInsetTop: Boolean,
+    safeAreaInsetBottom: truthProp,
+    minDate: {
+      type: Date,
+      validator: isDate,
+      default: getToday
+    },
+    maxDate: {
+      type: Date,
+      validator: isDate,
+      default: () => {
+        const now = getToday();
+        return new Date(now.getFullYear(), now.getMonth() + 6, now.getDate());
+      }
+    },
+    firstDayOfWeek: {
+      type: numericProp,
+      default: 0,
+      validator: (val) => val >= 0 && val <= 6
+    }
+  };
+  var stdin_default$18 = vue.defineComponent({
+    name: name$12,
+    props: calendarProps,
+    emits: ["select", "confirm", "unselect", "monthShow", "overRange", "update:show", "clickSubtitle"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const limitDateRange = (date, minDate = props.minDate, maxDate = props.maxDate) => {
+        if (compareDay(date, minDate) === -1) {
+          return minDate;
+        }
+        if (compareDay(date, maxDate) === 1) {
+          return maxDate;
+        }
+        return date;
+      };
+      const getInitialDate = (defaultDate = props.defaultDate) => {
+        const {
+          type,
+          minDate,
+          maxDate,
+          allowSameDay
+        } = props;
+        if (defaultDate === null) {
+          return defaultDate;
+        }
+        const now = getToday();
+        if (type === "range") {
+          if (!Array.isArray(defaultDate)) {
+            defaultDate = [];
+          }
+          const start2 = limitDateRange(defaultDate[0] || now, minDate, allowSameDay ? maxDate : getPrevDay(maxDate));
+          const end2 = limitDateRange(defaultDate[1] || now, allowSameDay ? minDate : getNextDay(minDate));
+          return [start2, end2];
+        }
+        if (type === "multiple") {
+          if (Array.isArray(defaultDate)) {
+            return defaultDate.map((date) => limitDateRange(date));
+          }
+          return [limitDateRange(now)];
+        }
+        if (!defaultDate || Array.isArray(defaultDate)) {
+          defaultDate = now;
+        }
+        return limitDateRange(defaultDate);
+      };
+      let bodyHeight;
+      const bodyRef = vue.ref();
+      const subtitle = vue.ref({
+        text: "",
+        date: void 0
+      });
+      const currentDate = vue.ref(getInitialDate());
+      const [monthRefs, setMonthRefs] = useRefs();
+      const dayOffset = vue.computed(() => props.firstDayOfWeek ? +props.firstDayOfWeek % 7 : 0);
+      const months = vue.computed(() => {
+        const months2 = [];
+        const cursor = new Date(props.minDate);
+        cursor.setDate(1);
+        do {
+          months2.push(new Date(cursor));
+          cursor.setMonth(cursor.getMonth() + 1);
+        } while (compareMonth(cursor, props.maxDate) !== 1);
+        return months2;
+      });
+      const buttonDisabled = vue.computed(() => {
+        if (currentDate.value) {
+          if (props.type === "range") {
+            return !currentDate.value[0] || !currentDate.value[1];
+          }
+          if (props.type === "multiple") {
+            return !currentDate.value.length;
+          }
+        }
+        return !currentDate.value;
+      });
+      const getSelectedDate = () => currentDate.value;
+      const onScroll = () => {
+        const top2 = getScrollTop(bodyRef.value);
+        const bottom2 = top2 + bodyHeight;
+        const heights = months.value.map((item, index) => monthRefs.value[index].getHeight());
+        const heightSum = heights.reduce((a, b) => a + b, 0);
+        if (bottom2 > heightSum && top2 > 0) {
+          return;
+        }
+        let height2 = 0;
+        let currentMonth;
+        const visibleRange = [-1, -1];
+        for (let i = 0; i < months.value.length; i++) {
+          const month = monthRefs.value[i];
+          const visible = height2 <= bottom2 && height2 + heights[i] >= top2;
+          if (visible) {
+            visibleRange[1] = i;
+            if (!currentMonth) {
+              currentMonth = month;
+              visibleRange[0] = i;
+            }
+            if (!monthRefs.value[i].showed) {
+              monthRefs.value[i].showed = true;
+              emit("monthShow", {
+                date: month.date,
+                title: month.getTitle()
+              });
+            }
+          }
+          height2 += heights[i];
+        }
+        months.value.forEach((month, index) => {
+          const visible = index >= visibleRange[0] - 1 && index <= visibleRange[1] + 1;
+          monthRefs.value[index].setVisible(visible);
+        });
+        if (currentMonth) {
+          subtitle.value = {
+            text: currentMonth.getTitle(),
+            date: currentMonth.date
+          };
+        }
+      };
+      const scrollToDate = (targetDate) => {
+        raf(() => {
+          months.value.some((month, index) => {
+            if (compareMonth(month, targetDate) === 0) {
+              if (bodyRef.value) {
+                monthRefs.value[index].scrollToDate(bodyRef.value, targetDate);
+              }
+              return true;
+            }
+            return false;
+          });
+          onScroll();
+        });
+      };
+      const scrollToCurrentDate = () => {
+        if (props.poppable && !props.show) {
+          return;
+        }
+        if (currentDate.value) {
+          const targetDate = props.type === "single" ? currentDate.value : currentDate.value[0];
+          if (isDate(targetDate)) {
+            scrollToDate(targetDate);
+          }
+        } else {
+          raf(onScroll);
+        }
+      };
+      const init = () => {
+        if (props.poppable && !props.show) {
+          return;
+        }
+        raf(() => {
+          bodyHeight = Math.floor(useRect(bodyRef).height);
+        });
+        scrollToCurrentDate();
+      };
+      const reset = (date = getInitialDate()) => {
+        currentDate.value = date;
+        scrollToCurrentDate();
+      };
+      const checkRange = (date) => {
+        const {
+          maxRange,
+          rangePrompt,
+          showRangePrompt
+        } = props;
+        if (maxRange && calcDateNum(date) > +maxRange) {
+          if (showRangePrompt) {
+            showToast(rangePrompt || t$f("rangePrompt", maxRange));
+          }
+          emit("overRange");
+          return false;
+        }
+        return true;
+      };
+      const onConfirm = () => {
+        var _a;
+        return emit("confirm", (_a = currentDate.value) != null ? _a : cloneDates(currentDate.value));
+      };
+      const select = (date, complete) => {
+        const setCurrentDate = (date2) => {
+          currentDate.value = date2;
+          emit("select", cloneDates(date2));
+        };
+        if (complete && props.type === "range") {
+          const valid = checkRange(date);
+          if (!valid) {
+            setCurrentDate([date[0], getDayByOffset(date[0], +props.maxRange - 1)]);
+            return;
+          }
+        }
+        setCurrentDate(date);
+        if (complete && !props.showConfirm) {
+          onConfirm();
+        }
+      };
+      const getDisabledDate = (disabledDays2, startDay, date) => {
+        var _a;
+        return (_a = disabledDays2.find((day) => compareDay(startDay, day.date) === -1 && compareDay(day.date, date) === -1)) == null ? void 0 : _a.date;
+      };
+      const disabledDays = vue.computed(() => monthRefs.value.reduce((arr, ref2) => {
+        var _a, _b;
+        arr.push(...(_b = (_a = ref2.disabledDays) == null ? void 0 : _a.value) != null ? _b : []);
+        return arr;
+      }, []));
+      const onClickDay = (item) => {
+        if (props.readonly || !item.date) {
+          return;
+        }
+        const {
+          date
+        } = item;
+        const {
+          type
+        } = props;
+        if (type === "range") {
+          if (!currentDate.value) {
+            select([date]);
+            return;
+          }
+          const [startDay, endDay] = currentDate.value;
+          if (startDay && !endDay) {
+            const compareToStart = compareDay(date, startDay);
+            if (compareToStart === 1) {
+              const disabledDay = getDisabledDate(disabledDays.value, startDay, date);
+              if (disabledDay) {
+                const endDay2 = getPrevDay(disabledDay);
+                if (compareDay(startDay, endDay2) === -1) {
+                  select([startDay, endDay2]);
+                } else {
+                  select([date]);
+                }
+              } else {
+                select([startDay, date], true);
+              }
+            } else if (compareToStart === -1) {
+              select([date]);
+            } else if (props.allowSameDay) {
+              select([date, date], true);
+            }
+          } else {
+            select([date]);
+          }
+        } else if (type === "multiple") {
+          if (!currentDate.value) {
+            select([date]);
+            return;
+          }
+          const dates = currentDate.value;
+          const selectedIndex = dates.findIndex((dateItem) => compareDay(dateItem, date) === 0);
+          if (selectedIndex !== -1) {
+            const [unselectedDate] = dates.splice(selectedIndex, 1);
+            emit("unselect", cloneDate(unselectedDate));
+          } else if (props.maxRange && dates.length >= +props.maxRange) {
+            showToast(props.rangePrompt || t$f("rangePrompt", props.maxRange));
+          } else {
+            select([...dates, date]);
+          }
+        } else {
+          select(date, true);
+        }
+      };
+      const updateShow = (value) => emit("update:show", value);
+      const renderMonth = (date, index) => {
+        const showMonthTitle = index !== 0 || !props.showSubtitle;
+        return vue.createVNode(stdin_default$1a, vue.mergeProps({
+          "ref": setMonthRefs(index),
+          "date": date,
+          "currentDate": currentDate.value,
+          "showMonthTitle": showMonthTitle,
+          "firstDayOfWeek": dayOffset.value
+        }, pick(props, ["type", "color", "minDate", "maxDate", "showMark", "formatter", "rowHeight", "lazyRender", "showSubtitle", "allowSameDay"]), {
+          "onClick": onClickDay
+        }), pick(slots, ["top-info", "bottom-info", "month-title"]));
+      };
+      const renderFooterButton = () => {
+        if (slots.footer) {
+          return slots.footer();
+        }
+        if (props.showConfirm) {
+          const slot = slots["confirm-text"];
+          const disabled = buttonDisabled.value;
+          const text = disabled ? props.confirmDisabledText : props.confirmText;
+          return vue.createVNode(Button, {
+            "round": true,
+            "block": true,
+            "type": "primary",
+            "color": props.color,
+            "class": bem$_("confirm"),
+            "disabled": disabled,
+            "nativeType": "button",
+            "onClick": onConfirm
+          }, {
+            default: () => [slot ? slot({
+              disabled
+            }) : text || t$f("confirm")]
+          });
+        }
+      };
+      const renderFooter = () => vue.createVNode("div", {
+        "class": [bem$_("footer"), {
+          "van-safe-area-bottom": props.safeAreaInsetBottom
+        }]
+      }, [renderFooterButton()]);
+      const renderCalendar = () => vue.createVNode("div", {
+        "class": bem$_()
+      }, [vue.createVNode(stdin_default$19, {
+        "date": subtitle.value.date,
+        "title": props.title,
+        "subtitle": subtitle.value.text,
+        "showTitle": props.showTitle,
+        "showSubtitle": props.showSubtitle,
+        "firstDayOfWeek": dayOffset.value,
+        "onClickSubtitle": (event) => emit("clickSubtitle", event)
+      }, pick(slots, ["title", "subtitle"])), vue.createVNode("div", {
+        "ref": bodyRef,
+        "class": bem$_("body"),
+        "onScroll": onScroll
+      }, [months.value.map(renderMonth)]), renderFooter()]);
+      vue.watch(() => props.show, init);
+      vue.watch(() => [props.type, props.minDate, props.maxDate], () => reset(getInitialDate(currentDate.value)));
+      vue.watch(() => props.defaultDate, (value = null) => {
+        currentDate.value = value;
+        scrollToCurrentDate();
+      });
+      useExpose({
+        reset,
+        scrollToDate,
+        getSelectedDate
+      });
+      onMountedOrActivated(init);
+      return () => {
+        if (props.poppable) {
+          return vue.createVNode(Popup, {
+            "show": props.show,
+            "class": bem$_("popup"),
+            "round": props.round,
+            "position": props.position,
+            "closeable": props.showTitle || props.showSubtitle,
+            "teleport": props.teleport,
+            "closeOnPopstate": props.closeOnPopstate,
+            "safeAreaInsetTop": props.safeAreaInsetTop,
+            "closeOnClickOverlay": props.closeOnClickOverlay,
+            "onUpdate:show": updateShow
+          }, {
+            default: renderCalendar
+          });
+        }
+        return renderCalendar();
+      };
+    }
+  });
+  const Calendar = withInstall(stdin_default$18);
+  const [name$_, bem$Z] = 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")
+  };
+  var stdin_default$17 = vue.defineComponent({
+    name: name$_,
+    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(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$Z("loading")
+          }, [renderIcon(props.loadingIcon, bem$Z("loading-icon"), slots.loading)]);
+        }
+        if (error.value && props.showError) {
+          return vue.createVNode("div", {
+            "class": bem$Z("error")
+          }, [renderIcon(props.errorIcon, bem$Z("error-icon"), slots.error)]);
+        }
+      };
+      const renderImage = () => {
+        if (error.value || !props.src) {
+          return;
+        }
+        const attrs = {
+          alt: props.alt,
+          class: bem$Z("img"),
+          style: {
+            objectFit: props.fit,
+            objectPosition: props.position
+          }
+        };
+        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) {
+            triggerLoad();
+          }
+        });
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "class": bem$Z({
+            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$17);
+  const [name$Z, bem$Y] = createNamespace("card");
+  const cardProps = {
+    tag: String,
+    num: numericProp,
+    desc: String,
+    thumb: String,
+    title: String,
+    price: numericProp,
+    centered: Boolean,
+    lazyLoad: Boolean,
+    currency: makeStringProp("¥"),
+    thumbLink: String,
+    originPrice: numericProp
+  };
+  var stdin_default$16 = vue.defineComponent({
+    name: name$Z,
+    props: cardProps,
+    emits: ["clickThumb"],
+    setup(props, {
+      slots,
+      emit
+    }) {
+      const renderTitle = () => {
+        if (slots.title) {
+          return slots.title();
+        }
+        if (props.title) {
+          return vue.createVNode("div", {
+            "class": [bem$Y("title"), "van-multi-ellipsis--l2"]
+          }, [props.title]);
+        }
+      };
+      const renderThumbTag = () => {
+        if (slots.tag || props.tag) {
+          return vue.createVNode("div", {
+            "class": bem$Y("tag")
+          }, [slots.tag ? slots.tag() : vue.createVNode(Tag, {
+            "mark": true,
+            "type": "primary"
+          }, {
+            default: () => [props.tag]
+          })]);
+        }
+      };
+      const renderThumbImage = () => {
+        if (slots.thumb) {
+          return slots.thumb();
+        }
+        return vue.createVNode(Image$1, {
+          "src": props.thumb,
+          "fit": "cover",
+          "width": "100%",
+          "height": "100%",
+          "lazyLoad": props.lazyLoad
+        }, null);
+      };
+      const renderThumb = () => {
+        if (slots.thumb || props.thumb) {
+          return vue.createVNode("a", {
+            "href": props.thumbLink,
+            "class": bem$Y("thumb"),
+            "onClick": (event) => emit("clickThumb", event)
+          }, [renderThumbImage(), renderThumbTag()]);
+        }
+      };
+      const renderDesc = () => {
+        if (slots.desc) {
+          return slots.desc();
+        }
+        if (props.desc) {
+          return vue.createVNode("div", {
+            "class": [bem$Y("desc"), "van-ellipsis"]
+          }, [props.desc]);
+        }
+      };
+      const renderPriceText = () => {
+        const priceArr = props.price.toString().split(".");
+        return vue.createVNode("div", null, [vue.createVNode("span", {
+          "class": bem$Y("price-currency")
+        }, [props.currency]), vue.createVNode("span", {
+          "class": bem$Y("price-integer")
+        }, [priceArr[0]]), vue.createTextVNode("."), vue.createVNode("span", {
+          "class": bem$Y("price-decimal")
+        }, [priceArr[1]])]);
+      };
+      return () => {
+        var _a, _b, _c;
+        const showNum = slots.num || isDef(props.num);
+        const showPrice = slots.price || isDef(props.price);
+        const showOriginPrice = slots["origin-price"] || isDef(props.originPrice);
+        const showBottom = showNum || showPrice || showOriginPrice || slots.bottom;
+        const Price = showPrice && vue.createVNode("div", {
+          "class": bem$Y("price")
+        }, [slots.price ? slots.price() : renderPriceText()]);
+        const OriginPrice = showOriginPrice && vue.createVNode("div", {
+          "class": bem$Y("origin-price")
+        }, [slots["origin-price"] ? slots["origin-price"]() : `${props.currency} ${props.originPrice}`]);
+        const Num = showNum && vue.createVNode("div", {
+          "class": bem$Y("num")
+        }, [slots.num ? slots.num() : `x${props.num}`]);
+        const Footer = slots.footer && vue.createVNode("div", {
+          "class": bem$Y("footer")
+        }, [slots.footer()]);
+        const Bottom = showBottom && vue.createVNode("div", {
+          "class": bem$Y("bottom")
+        }, [(_a = slots["price-top"]) == null ? void 0 : _a.call(slots), Price, OriginPrice, Num, (_b = slots.bottom) == null ? void 0 : _b.call(slots)]);
+        return vue.createVNode("div", {
+          "class": bem$Y()
+        }, [vue.createVNode("div", {
+          "class": bem$Y("header")
+        }, [renderThumb(), vue.createVNode("div", {
+          "class": bem$Y("content", {
+            centered: props.centered
+          })
+        }, [vue.createVNode("div", null, [renderTitle(), renderDesc(), (_c = slots.tags) == null ? void 0 : _c.call(slots)]), Bottom])]), Footer]);
+      };
+    }
+  });
+  const Card = withInstall(stdin_default$16);
+  const [name$Y, bem$X, t$e] = createNamespace("cascader");
+  const cascaderProps = {
+    title: String,
+    options: makeArrayProp(),
+    closeable: truthProp,
+    swipeable: truthProp,
+    closeIcon: makeStringProp("cross"),
+    showHeader: truthProp,
+    modelValue: numericProp,
+    fieldNames: Object,
+    placeholder: String,
+    activeColor: String
+  };
+  var stdin_default$15 = vue.defineComponent({
+    name: name$Y,
+    props: cascaderProps,
+    emits: ["close", "change", "finish", "clickTab", "update:modelValue"],
+    setup(props, {
+      slots,
+      emit
+    }) {
+      const tabs = vue.ref([]);
+      const activeTab = vue.ref(0);
+      const {
+        text: textKey,
+        value: valueKey,
+        children: childrenKey
+      } = extend({
+        text: "text",
+        value: "value",
+        children: "children"
+      }, props.fieldNames);
+      const getSelectedOptionsByValue = (options, value) => {
+        for (const option of options) {
+          if (option[valueKey] === value) {
+            return [option];
+          }
+          if (option[childrenKey]) {
+            const selectedOptions = getSelectedOptionsByValue(option[childrenKey], value);
+            if (selectedOptions) {
+              return [option, ...selectedOptions];
+            }
+          }
+        }
+      };
+      const updateTabs = () => {
+        const {
+          options,
+          modelValue
+        } = props;
+        if (modelValue !== void 0) {
+          const selectedOptions = getSelectedOptionsByValue(options, modelValue);
+          if (selectedOptions) {
+            let optionsCursor = options;
+            tabs.value = selectedOptions.map((option) => {
+              const tab = {
+                options: optionsCursor,
+                selected: option
+              };
+              const next = optionsCursor.find((item) => item[valueKey] === option[valueKey]);
+              if (next) {
+                optionsCursor = next[childrenKey];
+              }
+              return tab;
+            });
+            if (optionsCursor) {
+              tabs.value.push({
+                options: optionsCursor,
+                selected: null
+              });
+            }
+            vue.nextTick(() => {
+              activeTab.value = tabs.value.length - 1;
+            });
+            return;
+          }
+        }
+        tabs.value = [{
+          options,
+          selected: null
+        }];
+      };
+      const onSelect = (option, tabIndex) => {
+        if (option.disabled) {
+          return;
+        }
+        tabs.value[tabIndex].selected = option;
+        if (tabs.value.length > tabIndex + 1) {
+          tabs.value = tabs.value.slice(0, tabIndex + 1);
+        }
+        if (option[childrenKey]) {
+          const nextTab = {
+            options: option[childrenKey],
+            selected: null
+          };
+          if (tabs.value[tabIndex + 1]) {
+            tabs.value[tabIndex + 1] = nextTab;
+          } else {
+            tabs.value.push(nextTab);
+          }
+          vue.nextTick(() => {
+            activeTab.value++;
+          });
+        }
+        const selectedOptions = tabs.value.map((tab) => tab.selected).filter(Boolean);
+        emit("update:modelValue", option[valueKey]);
+        const params = {
+          value: option[valueKey],
+          tabIndex,
+          selectedOptions
+        };
+        emit("change", params);
+        if (!option[childrenKey]) {
+          emit("finish", params);
+        }
+      };
+      const onClose = () => emit("close");
+      const onClickTab = ({
+        name: name2,
+        title
+      }) => emit("clickTab", name2, title);
+      const renderHeader = () => props.showHeader ? vue.createVNode("div", {
+        "class": bem$X("header")
+      }, [vue.createVNode("h2", {
+        "class": bem$X("title")
+      }, [slots.title ? slots.title() : props.title]), props.closeable ? vue.createVNode(Icon, {
+        "name": props.closeIcon,
+        "class": [bem$X("close-icon"), HAPTICS_FEEDBACK],
+        "onClick": onClose
+      }, null) : null]) : null;
+      const renderOption = (option, selectedOption, tabIndex) => {
+        const {
+          disabled
+        } = option;
+        const selected = !!(selectedOption && option[valueKey] === selectedOption[valueKey]);
+        const color = option.color || (selected ? props.activeColor : void 0);
+        const Text = slots.option ? slots.option({
+          option,
+          selected
+        }) : vue.createVNode("span", null, [option[textKey]]);
+        return vue.createVNode("li", {
+          "role": "menuitemradio",
+          "class": [bem$X("option", {
+            selected,
+            disabled
+          }), option.className],
+          "style": {
+            color
+          },
+          "tabindex": disabled ? void 0 : selected ? 0 : -1,
+          "aria-checked": selected,
+          "aria-disabled": disabled || void 0,
+          "onClick": () => onSelect(option, tabIndex)
+        }, [Text, selected ? vue.createVNode(Icon, {
+          "name": "success",
+          "class": bem$X("selected-icon")
+        }, null) : null]);
+      };
+      const renderOptions = (options, selectedOption, tabIndex) => vue.createVNode("ul", {
+        "role": "menu",
+        "class": bem$X("options")
+      }, [options.map((option) => renderOption(option, selectedOption, tabIndex))]);
+      const renderTab = (tab, tabIndex) => {
+        const {
+          options,
+          selected
+        } = tab;
+        const placeholder = props.placeholder || t$e("select");
+        const title = selected ? selected[textKey] : placeholder;
+        return vue.createVNode(Tab, {
+          "title": title,
+          "titleClass": bem$X("tab", {
+            unselected: !selected
+          })
+        }, {
+          default: () => {
+            var _a, _b;
+            return [(_a = slots["options-top"]) == null ? void 0 : _a.call(slots, {
+              tabIndex
+            }), renderOptions(options, selected, tabIndex), (_b = slots["options-bottom"]) == null ? void 0 : _b.call(slots, {
+              tabIndex
+            })];
+          }
+        });
+      };
+      const renderTabs = () => vue.createVNode(Tabs, {
+        "active": activeTab.value,
+        "onUpdate:active": ($event) => activeTab.value = $event,
+        "shrink": true,
+        "animated": true,
+        "class": bem$X("tabs"),
+        "color": props.activeColor,
+        "swipeable": props.swipeable,
+        "onClickTab": onClickTab
+      }, {
+        default: () => [tabs.value.map(renderTab)]
+      });
+      updateTabs();
+      vue.watch(() => props.options, updateTabs, {
+        deep: true
+      });
+      vue.watch(() => props.modelValue, (value) => {
+        if (value !== void 0) {
+          const values = tabs.value.map((tab) => {
+            var _a;
+            return (_a = tab.selected) == null ? void 0 : _a[valueKey];
+          });
+          if (values.includes(value)) {
+            return;
+          }
+        }
+        updateTabs();
+      });
+      return () => vue.createVNode("div", {
+        "class": bem$X()
+      }, [renderHeader(), renderTabs()]);
+    }
+  });
+  const Cascader = withInstall(stdin_default$15);
+  const [name$X, bem$W] = createNamespace("cell-group");
+  const cellGroupProps = {
+    title: String,
+    inset: Boolean,
+    border: truthProp
+  };
+  var stdin_default$14 = vue.defineComponent({
+    name: name$X,
+    inheritAttrs: false,
+    props: cellGroupProps,
+    setup(props, {
+      slots,
+      attrs
+    }) {
+      const renderGroup = () => {
+        var _a;
+        return vue.createVNode("div", vue.mergeProps({
+          "class": [bem$W({
+            inset: props.inset
+          }), {
+            [BORDER_TOP_BOTTOM]: props.border && !props.inset
+          }]
+        }, attrs), [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+      const renderTitle = () => vue.createVNode("div", {
+        "class": bem$W("title", {
+          inset: props.inset
+        })
+      }, [slots.title ? slots.title() : props.title]);
+      return () => {
+        if (props.title || slots.title) {
+          return vue.createVNode(vue.Fragment, null, [renderTitle(), renderGroup()]);
+        }
+        return renderGroup();
+      };
+    }
+  });
+  const CellGroup = withInstall(stdin_default$14);
+  const [name$W, bem$V] = createNamespace("checkbox-group");
+  const checkboxGroupProps = {
+    max: numericProp,
+    disabled: Boolean,
+    iconSize: numericProp,
+    direction: String,
+    modelValue: makeArrayProp(),
+    checkedColor: String
+  };
+  const CHECKBOX_GROUP_KEY = Symbol(name$W);
+  var stdin_default$13 = vue.defineComponent({
+    name: name$W,
+    props: checkboxGroupProps,
+    emits: ["change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const {
+        children,
+        linkChildren
+      } = useChildren(CHECKBOX_GROUP_KEY);
+      const updateValue = (value) => emit("update:modelValue", value);
+      const toggleAll = (options = {}) => {
+        if (typeof options === "boolean") {
+          options = {
+            checked: options
+          };
+        }
+        const {
+          checked,
+          skipDisabled
+        } = options;
+        const checkedChildren = children.filter((item) => {
+          if (!item.props.bindGroup) {
+            return false;
+          }
+          if (item.props.disabled && skipDisabled) {
+            return item.checked.value;
+          }
+          return checked != null ? checked : !item.checked.value;
+        });
+        const names = checkedChildren.map((item) => item.name);
+        updateValue(names);
+      };
+      vue.watch(() => props.modelValue, (value) => emit("change", value));
+      useExpose({
+        toggleAll
+      });
+      useCustomFieldValue(() => props.modelValue);
+      linkChildren({
+        props,
+        updateValue
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "class": bem$V([props.direction])
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const [name$V, bem$U] = createNamespace("checkbox");
+  const checkboxProps = extend({}, checkerProps, {
+    bindGroup: truthProp
+  });
+  var stdin_default$12 = vue.defineComponent({
+    name: name$V,
+    props: checkboxProps,
+    emits: ["change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const {
+        parent
+      } = useParent(CHECKBOX_GROUP_KEY);
+      const setParentValue = (checked2) => {
+        const {
+          name: name2
+        } = props;
+        const {
+          max,
+          modelValue
+        } = parent.props;
+        const value = modelValue.slice();
+        if (checked2) {
+          const overlimit = max && value.length >= +max;
+          if (!overlimit && !value.includes(name2)) {
+            value.push(name2);
+            if (props.bindGroup) {
+              parent.updateValue(value);
+            }
+          }
+        } else {
+          const index = value.indexOf(name2);
+          if (index !== -1) {
+            value.splice(index, 1);
+            if (props.bindGroup) {
+              parent.updateValue(value);
+            }
+          }
+        }
+      };
+      const checked = vue.computed(() => {
+        if (parent && props.bindGroup) {
+          return parent.props.modelValue.indexOf(props.name) !== -1;
+        }
+        return !!props.modelValue;
+      });
+      const toggle = (newValue = !checked.value) => {
+        if (parent && props.bindGroup) {
+          setParentValue(newValue);
+        } else {
+          emit("update:modelValue", newValue);
+        }
+      };
+      vue.watch(() => props.modelValue, (value) => emit("change", value));
+      useExpose({
+        toggle,
+        props,
+        checked
+      });
+      useCustomFieldValue(() => props.modelValue);
+      return () => vue.createVNode(stdin_default$1g, vue.mergeProps({
+        "bem": bem$U,
+        "role": "checkbox",
+        "parent": parent,
+        "checked": checked.value,
+        "onToggle": toggle
+      }, props), pick(slots, ["default", "icon"]));
+    }
+  });
+  const Checkbox = withInstall(stdin_default$12);
+  const CheckboxGroup = withInstall(stdin_default$13);
+  const [name$U, bem$T] = createNamespace("circle");
+  let uid = 0;
+  const format$1 = (rate) => Math.min(Math.max(+rate, 0), 100);
+  function getPath(clockwise, viewBoxSize) {
+    const sweepFlag = clockwise ? 1 : 0;
+    return `M ${viewBoxSize / 2} ${viewBoxSize / 2} m 0, -500 a 500, 500 0 1, ${sweepFlag} 0, 1000 a 500, 500 0 1, ${sweepFlag} 0, -1000`;
+  }
+  const circleProps = {
+    text: String,
+    size: numericProp,
+    fill: makeStringProp("none"),
+    rate: makeNumericProp(100),
+    speed: makeNumericProp(0),
+    color: [String, Object],
+    clockwise: truthProp,
+    layerColor: String,
+    currentRate: makeNumberProp(0),
+    strokeWidth: makeNumericProp(40),
+    strokeLinecap: String,
+    startPosition: makeStringProp("top")
+  };
+  var stdin_default$11 = vue.defineComponent({
+    name: name$U,
+    props: circleProps,
+    emits: ["update:currentRate"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const id = `van-circle-${uid++}`;
+      const viewBoxSize = vue.computed(() => +props.strokeWidth + 1e3);
+      const path = vue.computed(() => getPath(props.clockwise, viewBoxSize.value));
+      const svgStyle = vue.computed(() => {
+        const ROTATE_ANGLE_MAP = {
+          top: 0,
+          right: 90,
+          bottom: 180,
+          left: 270
+        };
+        const angleValue = ROTATE_ANGLE_MAP[props.startPosition];
+        if (angleValue) {
+          return {
+            transform: `rotate(${angleValue}deg)`
+          };
+        }
+      });
+      vue.watch(() => props.rate, (rate) => {
+        let rafId;
+        const startTime = Date.now();
+        const startRate = props.currentRate;
+        const endRate = format$1(rate);
+        const duration = Math.abs((startRate - endRate) * 1e3 / +props.speed);
+        const animate = () => {
+          const now = Date.now();
+          const progress = Math.min((now - startTime) / duration, 1);
+          const rate2 = progress * (endRate - startRate) + startRate;
+          emit("update:currentRate", format$1(parseFloat(rate2.toFixed(1))));
+          if (endRate > startRate ? rate2 < endRate : rate2 > endRate) {
+            rafId = raf(animate);
+          }
+        };
+        if (props.speed) {
+          if (rafId) {
+            cancelRaf(rafId);
+          }
+          rafId = raf(animate);
+        } else {
+          emit("update:currentRate", endRate);
+        }
+      }, {
+        immediate: true
+      });
+      const renderHover = () => {
+        const PERIMETER = 3140;
+        const {
+          strokeWidth,
+          currentRate,
+          strokeLinecap
+        } = props;
+        const offset2 = PERIMETER * currentRate / 100;
+        const color = isObject(props.color) ? `url(#${id})` : props.color;
+        const style = {
+          stroke: color,
+          strokeWidth: `${+strokeWidth + 1}px`,
+          strokeLinecap,
+          strokeDasharray: `${offset2}px ${PERIMETER}px`
+        };
+        return vue.createVNode("path", {
+          "d": path.value,
+          "style": style,
+          "class": bem$T("hover"),
+          "stroke": color
+        }, null);
+      };
+      const renderLayer = () => {
+        const style = {
+          fill: props.fill,
+          stroke: props.layerColor,
+          strokeWidth: `${props.strokeWidth}px`
+        };
+        return vue.createVNode("path", {
+          "class": bem$T("layer"),
+          "style": style,
+          "d": path.value
+        }, null);
+      };
+      const renderGradient = () => {
+        const {
+          color
+        } = props;
+        if (!isObject(color)) {
+          return;
+        }
+        const Stops = Object.keys(color).sort((a, b) => parseFloat(a) - parseFloat(b)).map((key, index) => vue.createVNode("stop", {
+          "key": index,
+          "offset": key,
+          "stop-color": color[key]
+        }, null));
+        return vue.createVNode("defs", null, [vue.createVNode("linearGradient", {
+          "id": id,
+          "x1": "100%",
+          "y1": "0%",
+          "x2": "0%",
+          "y2": "0%"
+        }, [Stops])]);
+      };
+      const renderText = () => {
+        if (slots.default) {
+          return slots.default();
+        }
+        if (props.text) {
+          return vue.createVNode("div", {
+            "class": bem$T("text")
+          }, [props.text]);
+        }
+      };
+      return () => vue.createVNode("div", {
+        "class": bem$T(),
+        "style": getSizeStyle(props.size)
+      }, [vue.createVNode("svg", {
+        "viewBox": `0 0 ${viewBoxSize.value} ${viewBoxSize.value}`,
+        "style": svgStyle.value
+      }, [renderGradient(), renderLayer(), renderHover()]), renderText()]);
+    }
+  });
+  const Circle = withInstall(stdin_default$11);
+  const [name$T, bem$S] = createNamespace("row");
+  const ROW_KEY = Symbol(name$T);
+  const rowProps = {
+    tag: makeStringProp("div"),
+    wrap: truthProp,
+    align: String,
+    gutter: makeNumericProp(0),
+    justify: String
+  };
+  var stdin_default$10 = vue.defineComponent({
+    name: name$T,
+    props: rowProps,
+    setup(props, {
+      slots
+    }) {
+      const {
+        children,
+        linkChildren
+      } = useChildren(ROW_KEY);
+      const groups = vue.computed(() => {
+        const groups2 = [[]];
+        let totalSpan = 0;
+        children.forEach((child, index) => {
+          totalSpan += Number(child.span);
+          if (totalSpan > 24) {
+            groups2.push([index]);
+            totalSpan -= 24;
+          } else {
+            groups2[groups2.length - 1].push(index);
+          }
+        });
+        return groups2;
+      });
+      const spaces = vue.computed(() => {
+        const gutter = Number(props.gutter);
+        const spaces2 = [];
+        if (!gutter) {
+          return spaces2;
+        }
+        groups.value.forEach((group) => {
+          const averagePadding = gutter * (group.length - 1) / group.length;
+          group.forEach((item, index) => {
+            if (index === 0) {
+              spaces2.push({
+                right: averagePadding
+              });
+            } else {
+              const left2 = gutter - spaces2[item - 1].right;
+              const right2 = averagePadding - left2;
+              spaces2.push({
+                left: left2,
+                right: right2
+              });
+            }
+          });
+        });
+        return spaces2;
+      });
+      linkChildren({
+        spaces
+      });
+      return () => {
+        const {
+          tag,
+          wrap,
+          align,
+          justify
+        } = props;
+        return vue.createVNode(tag, {
+          "class": bem$S({
+            [`align-${align}`]: align,
+            [`justify-${justify}`]: justify,
+            nowrap: !wrap
+          })
+        }, {
+          default: () => {
+            var _a;
+            return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
+          }
+        });
+      };
+    }
+  });
+  const [name$S, bem$R] = createNamespace("col");
+  const colProps = {
+    tag: makeStringProp("div"),
+    span: makeNumericProp(0),
+    offset: numericProp
+  };
+  var stdin_default$$ = vue.defineComponent({
+    name: name$S,
+    props: colProps,
+    setup(props, {
+      slots
+    }) {
+      const {
+        parent,
+        index
+      } = useParent(ROW_KEY);
+      const style = vue.computed(() => {
+        if (!parent) {
+          return;
+        }
+        const {
+          spaces
+        } = parent;
+        if (spaces && spaces.value && spaces.value[index.value]) {
+          const {
+            left: left2,
+            right: right2
+          } = spaces.value[index.value];
+          return {
+            paddingLeft: left2 ? `${left2}px` : null,
+            paddingRight: right2 ? `${right2}px` : null
+          };
+        }
+      });
+      return () => {
+        const {
+          tag,
+          span,
+          offset: offset2
+        } = props;
+        return vue.createVNode(tag, {
+          "style": style.value,
+          "class": bem$R({
+            [span]: span,
+            [`offset-${offset2}`]: offset2
+          })
+        }, {
+          default: () => {
+            var _a;
+            return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
+          }
+        });
+      };
+    }
+  });
+  const Col = withInstall(stdin_default$$);
+  const [name$R, bem$Q] = createNamespace("collapse");
+  const COLLAPSE_KEY = Symbol(name$R);
+  const collapseProps = {
+    border: truthProp,
+    accordion: Boolean,
+    modelValue: {
+      type: [String, Number, Array],
+      default: ""
+    }
+  };
+  var stdin_default$_ = vue.defineComponent({
+    name: name$R,
+    props: collapseProps,
+    emits: ["change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const {
+        linkChildren,
+        children
+      } = useChildren(COLLAPSE_KEY);
+      const updateName = (name2) => {
+        emit("change", name2);
+        emit("update:modelValue", name2);
+      };
+      const toggle = (name2, expanded) => {
+        const {
+          accordion,
+          modelValue
+        } = props;
+        if (accordion) {
+          updateName(name2 === modelValue ? "" : name2);
+        } else if (expanded) {
+          updateName(modelValue.concat(name2));
+        } else {
+          updateName(modelValue.filter((activeName) => activeName !== name2));
+        }
+      };
+      const toggleAll = (options = {}) => {
+        if (props.accordion) {
+          return;
+        }
+        if (typeof options === "boolean") {
+          options = {
+            expanded: options
+          };
+        }
+        const {
+          expanded,
+          skipDisabled
+        } = options;
+        const expandedChildren = children.filter((item) => {
+          if (item.disabled && skipDisabled) {
+            return item.expanded.value;
+          }
+          return expanded != null ? expanded : !item.expanded.value;
+        });
+        const names = expandedChildren.map((item) => item.itemName.value);
+        updateName(names);
+      };
+      const isExpanded = (name2) => {
+        const {
+          accordion,
+          modelValue
+        } = props;
+        return accordion ? modelValue === name2 : modelValue.includes(name2);
+      };
+      useExpose({
+        toggleAll
+      });
+      linkChildren({
+        toggle,
+        isExpanded
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "class": [bem$Q(), {
+            [BORDER_TOP_BOTTOM]: props.border
+          }]
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const Collapse = withInstall(stdin_default$_);
+  const [name$Q, bem$P] = createNamespace("collapse-item");
+  const CELL_SLOTS = ["icon", "title", "value", "label", "right-icon"];
+  const collapseItemProps = extend({}, cellSharedProps, {
+    name: numericProp,
+    isLink: truthProp,
+    disabled: Boolean,
+    readonly: Boolean,
+    lazyRender: truthProp
+  });
+  var stdin_default$Z = vue.defineComponent({
+    name: name$Q,
+    props: collapseItemProps,
+    setup(props, {
+      slots
+    }) {
+      const wrapperRef = vue.ref();
+      const contentRef = vue.ref();
+      const {
+        parent,
+        index
+      } = useParent(COLLAPSE_KEY);
+      if (!parent) {
+        return;
+      }
+      const name2 = vue.computed(() => {
+        var _a;
+        return (_a = props.name) != null ? _a : index.value;
+      });
+      const expanded = vue.computed(() => parent.isExpanded(name2.value));
+      const show = vue.ref(expanded.value);
+      const lazyRender = useLazyRender(() => show.value || !props.lazyRender);
+      const onTransitionEnd = () => {
+        if (!expanded.value) {
+          show.value = false;
+        } else if (wrapperRef.value) {
+          wrapperRef.value.style.height = "";
+        }
+      };
+      vue.watch(expanded, (value, oldValue) => {
+        if (oldValue === null) {
+          return;
+        }
+        if (value) {
+          show.value = true;
+        }
+        const tick = value ? vue.nextTick : raf;
+        tick(() => {
+          if (!contentRef.value || !wrapperRef.value) {
+            return;
+          }
+          const {
+            offsetHeight
+          } = contentRef.value;
+          if (offsetHeight) {
+            const contentHeight = `${offsetHeight}px`;
+            wrapperRef.value.style.height = value ? "0" : contentHeight;
+            doubleRaf(() => {
+              if (wrapperRef.value) {
+                wrapperRef.value.style.height = value ? contentHeight : "0";
+              }
+            });
+          } else {
+            onTransitionEnd();
+          }
+        });
+      });
+      const toggle = (newValue = !expanded.value) => {
+        parent.toggle(name2.value, newValue);
+      };
+      const onClickTitle = () => {
+        if (!props.disabled && !props.readonly) {
+          toggle();
+        }
+      };
+      const renderTitle = () => {
+        const {
+          border,
+          disabled,
+          readonly
+        } = props;
+        const attrs = pick(props, Object.keys(cellSharedProps));
+        if (readonly) {
+          attrs.isLink = false;
+        }
+        if (disabled || readonly) {
+          attrs.clickable = false;
+        }
+        return vue.createVNode(Cell, vue.mergeProps({
+          "role": "button",
+          "class": bem$P("title", {
+            disabled,
+            expanded: expanded.value,
+            borderless: !border
+          }),
+          "aria-expanded": String(expanded.value),
+          "onClick": onClickTitle
+        }, attrs), pick(slots, CELL_SLOTS));
+      };
+      const renderContent = lazyRender(() => {
+        var _a;
+        return vue.withDirectives(vue.createVNode("div", {
+          "ref": wrapperRef,
+          "class": bem$P("wrapper"),
+          "onTransitionend": onTransitionEnd
+        }, [vue.createVNode("div", {
+          "ref": contentRef,
+          "class": bem$P("content")
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]), [[vue.vShow, show.value]]);
+      });
+      useExpose({
+        toggle,
+        expanded,
+        itemName: name2
+      });
+      return () => vue.createVNode("div", {
+        "class": [bem$P({
+          border: index.value && props.border
+        })]
+      }, [renderTitle(), renderContent()]);
+    }
+  });
+  const CollapseItem = withInstall(stdin_default$Z);
+  const ConfigProvider = withInstall(stdin_default$1K);
+  const [name$P, bem$O, t$d] = createNamespace("contact-card");
+  const contactCardProps = {
+    tel: String,
+    name: String,
+    type: makeStringProp("add"),
+    addText: String,
+    editable: truthProp
+  };
+  var stdin_default$Y = vue.defineComponent({
+    name: name$P,
+    props: contactCardProps,
+    emits: ["click"],
+    setup(props, {
+      emit
+    }) {
+      const onClick = (event) => {
+        if (props.editable) {
+          emit("click", event);
+        }
+      };
+      const renderContent = () => {
+        if (props.type === "add") {
+          return props.addText || t$d("addContact");
+        }
+        return [vue.createVNode("div", null, [`${t$d("name")}：${props.name}`]), vue.createVNode("div", null, [`${t$d("tel")}：${props.tel}`])];
+      };
+      return () => vue.createVNode(Cell, {
+        "center": true,
+        "icon": props.type === "edit" ? "contact" : "add-square",
+        "class": bem$O([props.type]),
+        "border": false,
+        "isLink": props.editable,
+        "titleClass": bem$O("title"),
+        "onClick": onClick
+      }, {
+        title: renderContent
+      });
+    }
+  });
+  const ContactCard = withInstall(stdin_default$Y);
+  const [name$O, bem$N, t$c] = createNamespace("contact-edit");
+  const DEFAULT_CONTACT = {
+    tel: "",
+    name: ""
+  };
+  const contactEditProps = {
+    isEdit: Boolean,
+    isSaving: Boolean,
+    isDeleting: Boolean,
+    showSetDefault: Boolean,
+    setDefaultLabel: String,
+    contactInfo: {
+      type: Object,
+      default: () => extend({}, DEFAULT_CONTACT)
+    },
+    telValidator: {
+      type: Function,
+      default: isMobile
+    }
+  };
+  var stdin_default$X = vue.defineComponent({
+    name: name$O,
+    props: contactEditProps,
+    emits: ["save", "delete", "changeDefault"],
+    setup(props, {
+      emit
+    }) {
+      const contact = vue.reactive(extend({}, DEFAULT_CONTACT, props.contactInfo));
+      const onSave = () => {
+        if (!props.isSaving) {
+          emit("save", contact);
+        }
+      };
+      const onDelete = () => emit("delete", contact);
+      const renderButtons = () => vue.createVNode("div", {
+        "class": bem$N("buttons")
+      }, [vue.createVNode(Button, {
+        "block": true,
+        "round": true,
+        "type": "primary",
+        "text": t$c("save"),
+        "class": bem$N("button"),
+        "loading": props.isSaving,
+        "nativeType": "submit"
+      }, null), props.isEdit && vue.createVNode(Button, {
+        "block": true,
+        "round": true,
+        "text": t$c("delete"),
+        "class": bem$N("button"),
+        "loading": props.isDeleting,
+        "onClick": onDelete
+      }, null)]);
+      const renderSwitch = () => vue.createVNode(Switch, {
+        "modelValue": contact.isDefault,
+        "onUpdate:modelValue": ($event) => contact.isDefault = $event,
+        "onChange": (checked) => emit("changeDefault", checked)
+      }, null);
+      const renderSetDefault = () => {
+        if (props.showSetDefault) {
+          return vue.createVNode(Cell, {
+            "title": props.setDefaultLabel,
+            "class": bem$N("switch-cell"),
+            "border": false
+          }, {
+            "right-icon": renderSwitch
+          });
+        }
+      };
+      vue.watch(() => props.contactInfo, (value) => extend(contact, DEFAULT_CONTACT, value));
+      return () => vue.createVNode(Form, {
+        "class": bem$N(),
+        "onSubmit": onSave
+      }, {
+        default: () => [vue.createVNode("div", {
+          "class": bem$N("fields")
+        }, [vue.createVNode(Field, {
+          "modelValue": contact.name,
+          "onUpdate:modelValue": ($event) => contact.name = $event,
+          "clearable": true,
+          "label": t$c("name"),
+          "rules": [{
+            required: true,
+            message: t$c("nameEmpty")
+          }],
+          "maxlength": "30",
+          "placeholder": t$c("name")
+        }, null), vue.createVNode(Field, {
+          "modelValue": contact.tel,
+          "onUpdate:modelValue": ($event) => contact.tel = $event,
+          "clearable": true,
+          "type": "tel",
+          "label": t$c("tel"),
+          "rules": [{
+            validator: props.telValidator,
+            message: t$c("telInvalid")
+          }],
+          "placeholder": t$c("tel")
+        }, null)]), renderSetDefault(), renderButtons()]
+      });
+    }
+  });
+  const ContactEdit = withInstall(stdin_default$X);
+  const [name$N, bem$M, t$b] = createNamespace("contact-list");
+  const contactListProps = {
+    list: Array,
+    addText: String,
+    modelValue: unknownProp,
+    defaultTagText: String
+  };
+  var stdin_default$W = vue.defineComponent({
+    name: name$N,
+    props: contactListProps,
+    emits: ["add", "edit", "select", "update:modelValue"],
+    setup(props, {
+      emit
+    }) {
+      const renderItem = (item, index) => {
+        const onClick = () => {
+          emit("update:modelValue", item.id);
+          emit("select", item, index);
+        };
+        const renderRightIcon = () => vue.createVNode(Radio, {
+          "class": bem$M("radio"),
+          "name": item.id,
+          "iconSize": 16
+        }, null);
+        const renderEditIcon = () => vue.createVNode(Icon, {
+          "name": "edit",
+          "class": bem$M("edit"),
+          "onClick": (event) => {
+            event.stopPropagation();
+            emit("edit", item, index);
+          }
+        }, null);
+        const renderContent = () => {
+          const nodes = [`${item.name}，${item.tel}`];
+          if (item.isDefault && props.defaultTagText) {
+            nodes.push(vue.createVNode(Tag, {
+              "type": "primary",
+              "round": true,
+              "class": bem$M("item-tag")
+            }, {
+              default: () => [props.defaultTagText]
+            }));
+          }
+          return nodes;
+        };
+        return vue.createVNode(Cell, {
+          "key": item.id,
+          "isLink": true,
+          "center": true,
+          "class": bem$M("item"),
+          "titleClass": bem$M("item-title"),
+          "onClick": onClick
+        }, {
+          icon: renderEditIcon,
+          title: renderContent,
+          "right-icon": renderRightIcon
+        });
+      };
+      return () => vue.createVNode("div", {
+        "class": bem$M()
+      }, [vue.createVNode(RadioGroup, {
+        "modelValue": props.modelValue,
+        "class": bem$M("group")
+      }, {
+        default: () => [props.list && props.list.map(renderItem)]
+      }), vue.createVNode("div", {
+        "class": [bem$M("bottom"), "van-safe-area-bottom"]
+      }, [vue.createVNode(Button, {
+        "round": true,
+        "block": true,
+        "type": "primary",
+        "class": bem$M("add"),
+        "text": props.addText || t$b("addContact"),
+        "onClick": () => emit("add")
+      }, null)])]);
+    }
+  });
+  const ContactList = withInstall(stdin_default$W);
+  function parseFormat(format2, currentTime) {
+    const { days } = currentTime;
+    let { hours, minutes, seconds, milliseconds } = currentTime;
+    if (format2.includes("DD")) {
+      format2 = format2.replace("DD", padZero(days));
+    } else {
+      hours += days * 24;
+    }
+    if (format2.includes("HH")) {
+      format2 = format2.replace("HH", padZero(hours));
+    } else {
+      minutes += hours * 60;
+    }
+    if (format2.includes("mm")) {
+      format2 = format2.replace("mm", padZero(minutes));
+    } else {
+      seconds += minutes * 60;
+    }
+    if (format2.includes("ss")) {
+      format2 = format2.replace("ss", padZero(seconds));
+    } else {
+      milliseconds += seconds * 1e3;
+    }
+    if (format2.includes("S")) {
+      const ms = padZero(milliseconds, 3);
+      if (format2.includes("SSS")) {
+        format2 = format2.replace("SSS", ms);
+      } else if (format2.includes("SS")) {
+        format2 = format2.replace("SS", ms.slice(0, 2));
+      } else {
+        format2 = format2.replace("S", ms.charAt(0));
+      }
+    }
+    return format2;
+  }
+  const [name$M, bem$L] = createNamespace("count-down");
+  const countDownProps = {
+    time: makeNumericProp(0),
+    format: makeStringProp("HH:mm:ss"),
+    autoStart: truthProp,
+    millisecond: Boolean
+  };
+  var stdin_default$V = vue.defineComponent({
+    name: name$M,
+    props: countDownProps,
+    emits: ["change", "finish"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const {
+        start: start2,
+        pause,
+        reset,
+        current: current2
+      } = useCountDown({
+        time: +props.time,
+        millisecond: props.millisecond,
+        onChange: (current22) => emit("change", current22),
+        onFinish: () => emit("finish")
+      });
+      const timeText = vue.computed(() => parseFormat(props.format, current2.value));
+      const resetTime = () => {
+        reset(+props.time);
+        if (props.autoStart) {
+          start2();
+        }
+      };
+      vue.watch(() => props.time, resetTime, {
+        immediate: true
+      });
+      useExpose({
+        start: start2,
+        pause,
+        reset: resetTime
+      });
+      return () => vue.createVNode("div", {
+        "role": "timer",
+        "class": bem$L()
+      }, [slots.default ? slots.default(current2.value) : timeText.value]);
+    }
+  });
+  const CountDown = withInstall(stdin_default$V);
+  function getDate(timeStamp) {
+    const date = new Date(timeStamp * 1e3);
+    return `${date.getFullYear()}.${padZero(date.getMonth() + 1)}.${padZero(
+      date.getDate()
+    )}`;
+  }
+  const formatDiscount = (discount) => (discount / 10).toFixed(discount % 10 === 0 ? 0 : 1);
+  const formatAmount = (amount) => (amount / 100).toFixed(amount % 100 === 0 ? 0 : amount % 10 === 0 ? 1 : 2);
+  const [name$L, bem$K, t$a] = createNamespace("coupon");
+  var stdin_default$U = vue.defineComponent({
+    name: name$L,
+    props: {
+      chosen: Boolean,
+      coupon: makeRequiredProp(Object),
+      disabled: Boolean,
+      currency: makeStringProp("¥")
+    },
+    setup(props) {
+      const validPeriod = vue.computed(() => {
+        const {
+          startAt,
+          endAt
+        } = props.coupon;
+        return `${getDate(startAt)} - ${getDate(endAt)}`;
+      });
+      const faceAmount = vue.computed(() => {
+        const {
+          coupon,
+          currency
+        } = props;
+        if (coupon.valueDesc) {
+          return [coupon.valueDesc, vue.createVNode("span", null, [coupon.unitDesc || ""])];
+        }
+        if (coupon.denominations) {
+          const denominations = formatAmount(coupon.denominations);
+          return [vue.createVNode("span", null, [currency]), ` ${denominations}`];
+        }
+        if (coupon.discount) {
+          return t$a("discount", formatDiscount(coupon.discount));
+        }
+        return "";
+      });
+      const conditionMessage = vue.computed(() => {
+        const condition = formatAmount(props.coupon.originCondition || 0);
+        return condition === "0" ? t$a("unlimited") : t$a("condition", condition);
+      });
+      return () => {
+        const {
+          chosen,
+          coupon,
+          disabled
+        } = props;
+        const description = disabled && coupon.reason || coupon.description;
+        return vue.createVNode("div", {
+          "class": bem$K({
+            disabled
+          })
+        }, [vue.createVNode("div", {
+          "class": bem$K("content")
+        }, [vue.createVNode("div", {
+          "class": bem$K("head")
+        }, [vue.createVNode("h2", {
+          "class": bem$K("amount")
+        }, [faceAmount.value]), vue.createVNode("p", {
+          "class": bem$K("condition")
+        }, [coupon.condition || conditionMessage.value])]), vue.createVNode("div", {
+          "class": bem$K("body")
+        }, [vue.createVNode("p", {
+          "class": bem$K("name")
+        }, [coupon.name]), vue.createVNode("p", {
+          "class": bem$K("valid")
+        }, [validPeriod.value]), !disabled && vue.createVNode(Checkbox, {
+          "class": bem$K("corner"),
+          "modelValue": chosen
+        }, null)])]), description && vue.createVNode("p", {
+          "class": bem$K("description")
+        }, [description])]);
+      };
+    }
+  });
+  const Coupon = withInstall(stdin_default$U);
+  const [name$K, bem$J, t$9] = createNamespace("coupon-cell");
+  const couponCellProps = {
+    title: String,
+    border: truthProp,
+    editable: truthProp,
+    coupons: makeArrayProp(),
+    currency: makeStringProp("¥"),
+    chosenCoupon: makeNumericProp(-1)
+  };
+  function formatValue({
+    coupons,
+    chosenCoupon,
+    currency
+  }) {
+    const coupon = coupons[+chosenCoupon];
+    if (coupon) {
+      let value = 0;
+      if (isDef(coupon.value)) {
+        ({
+          value
+        } = coupon);
+      } else if (isDef(coupon.denominations)) {
+        value = coupon.denominations;
+      }
+      return `-${currency} ${(value / 100).toFixed(2)}`;
+    }
+    return coupons.length === 0 ? t$9("noCoupon") : t$9("count", coupons.length);
+  }
+  var stdin_default$T = vue.defineComponent({
+    name: name$K,
+    props: couponCellProps,
+    setup(props) {
+      return () => {
+        const selected = props.coupons[+props.chosenCoupon];
+        return vue.createVNode(Cell, {
+          "class": bem$J(),
+          "value": formatValue(props),
+          "title": props.title || t$9("title"),
+          "border": props.border,
+          "isLink": props.editable,
+          "valueClass": bem$J("value", {
+            selected
+          })
+        }, null);
+      };
+    }
+  });
+  const CouponCell = withInstall(stdin_default$T);
+  const [name$J, bem$I] = createNamespace("empty");
+  const emptyProps = {
+    image: makeStringProp("default"),
+    imageSize: [Number, String, Array],
+    description: String
+  };
+  var stdin_default$S = vue.defineComponent({
+    name: name$J,
+    props: emptyProps,
+    setup(props, {
+      slots
+    }) {
+      const renderDescription = () => {
+        const description = slots.description ? slots.description() : props.description;
+        if (description) {
+          return vue.createVNode("p", {
+            "class": bem$I("description")
+          }, [description]);
+        }
+      };
+      const renderBottom = () => {
+        if (slots.default) {
+          return vue.createVNode("div", {
+            "class": bem$I("bottom")
+          }, [slots.default()]);
+        }
+      };
+      const baseId = useId();
+      const getId = (num) => `${baseId}-${num}`;
+      const getUrlById = (num) => `url(#${getId(num)})`;
+      const renderStop = (color, offset2, opacity) => vue.createVNode("stop", {
+        "stop-color": color,
+        "offset": `${offset2}%`,
+        "stop-opacity": opacity
+      }, null);
+      const renderStops = (fromColor, toColor) => [renderStop(fromColor, 0), renderStop(toColor, 100)];
+      const renderShadow = (id) => [vue.createVNode("defs", null, [vue.createVNode("radialGradient", {
+        "id": getId(id),
+        "cx": "50%",
+        "cy": "54%",
+        "fx": "50%",
+        "fy": "54%",
+        "r": "297%",
+        "gradientTransform": "matrix(-.16 0 0 -.33 .58 .72)"
+      }, [renderStop("#EBEDF0", 0), renderStop("#F2F3F5", 100, 0.3)])]), vue.createVNode("ellipse", {
+        "fill": getUrlById(id),
+        "opacity": ".8",
+        "cx": "80",
+        "cy": "140",
+        "rx": "46",
+        "ry": "8"
+      }, null)];
+      const renderBuilding = () => [vue.createVNode("defs", null, [vue.createVNode("linearGradient", {
+        "id": getId("a"),
+        "x1": "64%",
+        "y1": "100%",
+        "x2": "64%"
+      }, [renderStop("#FFF", 0, 0.5), renderStop("#F2F3F5", 100)])]), vue.createVNode("g", {
+        "opacity": ".8"
+      }, [vue.createVNode("path", {
+        "d": "M36 131V53H16v20H2v58h34z",
+        "fill": getUrlById("a")
+      }, null), vue.createVNode("path", {
+        "d": "M123 15h22v14h9v77h-31V15z",
+        "fill": getUrlById("a")
+      }, null)])];
+      const renderCloud = () => [vue.createVNode("defs", null, [vue.createVNode("linearGradient", {
+        "id": getId("b"),
+        "x1": "64%",
+        "y1": "97%",
+        "x2": "64%",
+        "y2": "0%"
+      }, [renderStop("#F2F3F5", 0, 0.3), renderStop("#F2F3F5", 100)])]), vue.createVNode("g", {
+        "opacity": ".8"
+      }, [vue.createVNode("path", {
+        "d": "M87 6c3 0 7 3 8 6a8 8 0 1 1-1 16H80a7 7 0 0 1-8-6c0-4 3-7 6-7 0-5 4-9 9-9Z",
+        "fill": getUrlById("b")
+      }, null), vue.createVNode("path", {
+        "d": "M19 23c2 0 3 1 4 3 2 0 4 2 4 4a4 4 0 0 1-4 3v1h-7v-1l-1 1c-2 0-3-2-3-4 0-1 1-3 3-3 0-2 2-4 4-4Z",
+        "fill": getUrlById("b")
+      }, null)])];
+      const renderNetwork = () => vue.createVNode("svg", {
+        "viewBox": "0 0 160 160"
+      }, [vue.createVNode("defs", null, [vue.createVNode("linearGradient", {
+        "id": getId(1),
+        "x1": "64%",
+        "y1": "100%",
+        "x2": "64%"
+      }, [renderStop("#FFF", 0, 0.5), renderStop("#F2F3F5", 100)]), vue.createVNode("linearGradient", {
+        "id": getId(2),
+        "x1": "50%",
+        "x2": "50%",
+        "y2": "84%"
+      }, [renderStop("#EBEDF0", 0), renderStop("#DCDEE0", 100, 0)]), vue.createVNode("linearGradient", {
+        "id": getId(3),
+        "x1": "100%",
+        "x2": "100%",
+        "y2": "100%"
+      }, [renderStops("#EAEDF0", "#DCDEE0")]), vue.createVNode("radialGradient", {
+        "id": getId(4),
+        "cx": "50%",
+        "cy": "0%",
+        "fx": "50%",
+        "fy": "0%",
+        "r": "100%",
+        "gradientTransform": "matrix(0 1 -.54 0 .5 -.5)"
+      }, [renderStop("#EBEDF0", 0), renderStop("#FFF", 100, 0)])]), vue.createVNode("g", {
+        "fill": "none"
+      }, [renderBuilding(), vue.createVNode("path", {
+        "fill": getUrlById(4),
+        "d": "M0 139h160v21H0z"
+      }, null), vue.createVNode("path", {
+        "d": "M80 54a7 7 0 0 1 3 13v27l-2 2h-2a2 2 0 0 1-2-2V67a7 7 0 0 1 3-13z",
+        "fill": getUrlById(2)
+      }, null), vue.createVNode("g", {
+        "opacity": ".6",
+        "stroke-linecap": "round",
+        "stroke-width": "7"
+      }, [vue.createVNode("path", {
+        "d": "M64 47a19 19 0 0 0-5 13c0 5 2 10 5 13",
+        "stroke": getUrlById(3)
+      }, null), vue.createVNode("path", {
+        "d": "M53 36a34 34 0 0 0 0 48",
+        "stroke": getUrlById(3)
+      }, null), vue.createVNode("path", {
+        "d": "M95 73a19 19 0 0 0 6-13c0-5-2-9-6-13",
+        "stroke": getUrlById(3)
+      }, null), vue.createVNode("path", {
+        "d": "M106 84a34 34 0 0 0 0-48",
+        "stroke": getUrlById(3)
+      }, null)]), vue.createVNode("g", {
+        "transform": "translate(31 105)"
+      }, [vue.createVNode("rect", {
+        "fill": "#EBEDF0",
+        "width": "98",
+        "height": "34",
+        "rx": "2"
+      }, null), vue.createVNode("rect", {
+        "fill": "#FFF",
+        "x": "9",
+        "y": "8",
+        "width": "80",
+        "height": "18",
+        "rx": "1.1"
+      }, null), vue.createVNode("rect", {
+        "fill": "#EBEDF0",
+        "x": "15",
+        "y": "12",
+        "width": "18",
+        "height": "6",
+        "rx": "1.1"
+      }, null)])])]);
+      const renderMaterial = () => vue.createVNode("svg", {
+        "viewBox": "0 0 160 160"
+      }, [vue.createVNode("defs", null, [vue.createVNode("linearGradient", {
+        "x1": "50%",
+        "x2": "50%",
+        "y2": "100%",
+        "id": getId(5)
+      }, [renderStops("#F2F3F5", "#DCDEE0")]), vue.createVNode("linearGradient", {
+        "x1": "95%",
+        "y1": "48%",
+        "x2": "5.5%",
+        "y2": "51%",
+        "id": getId(6)
+      }, [renderStops("#EAEDF1", "#DCDEE0")]), vue.createVNode("linearGradient", {
+        "y1": "45%",
+        "x2": "100%",
+        "y2": "54%",
+        "id": getId(7)
+      }, [renderStops("#EAEDF1", "#DCDEE0")])]), renderBuilding(), renderCloud(), vue.createVNode("g", {
+        "transform": "translate(36 50)",
+        "fill": "none"
+      }, [vue.createVNode("g", {
+        "transform": "translate(8)"
+      }, [vue.createVNode("rect", {
+        "fill": "#EBEDF0",
+        "opacity": ".6",
+        "x": "38",
+        "y": "13",
+        "width": "36",
+        "height": "53",
+        "rx": "2"
+      }, null), vue.createVNode("rect", {
+        "fill": getUrlById(5),
+        "width": "64",
+        "height": "66",
+        "rx": "2"
+      }, null), vue.createVNode("rect", {
+        "fill": "#FFF",
+        "x": "6",
+        "y": "6",
+        "width": "52",
+        "height": "55",
+        "rx": "1"
+      }, null), vue.createVNode("g", {
+        "transform": "translate(15 17)",
+        "fill": getUrlById(6)
+      }, [vue.createVNode("rect", {
+        "width": "34",
+        "height": "6",
+        "rx": "1"
+      }, null), vue.createVNode("path", {
+        "d": "M0 14h34v6H0z"
+      }, null), vue.createVNode("rect", {
+        "y": "28",
+        "width": "34",
+        "height": "6",
+        "rx": "1"
+      }, null)])]), vue.createVNode("rect", {
+        "fill": getUrlById(7),
+        "y": "61",
+        "width": "88",
+        "height": "28",
+        "rx": "1"
+      }, null), vue.createVNode("rect", {
+        "fill": "#F7F8FA",
+        "x": "29",
+        "y": "72",
+        "width": "30",
+        "height": "6",
+        "rx": "1"
+      }, null)])]);
+      const renderError = () => vue.createVNode("svg", {
+        "viewBox": "0 0 160 160"
+      }, [vue.createVNode("defs", null, [vue.createVNode("linearGradient", {
+        "x1": "50%",
+        "x2": "50%",
+        "y2": "100%",
+        "id": getId(8)
+      }, [renderStops("#EAEDF1", "#DCDEE0")])]), renderBuilding(), renderCloud(), renderShadow("c"), vue.createVNode("path", {
+        "d": "m59 60 21 21 21-21h3l9 9v3L92 93l21 21v3l-9 9h-3l-21-21-21 21h-3l-9-9v-3l21-21-21-21v-3l9-9h3Z",
+        "fill": getUrlById(8)
+      }, null)]);
+      const renderSearch = () => vue.createVNode("svg", {
+        "viewBox": "0 0 160 160"
+      }, [vue.createVNode("defs", null, [vue.createVNode("linearGradient", {
+        "x1": "50%",
+        "y1": "100%",
+        "x2": "50%",
+        "id": getId(9)
+      }, [renderStops("#EEE", "#D8D8D8")]), vue.createVNode("linearGradient", {
+        "x1": "100%",
+        "y1": "50%",
+        "y2": "50%",
+        "id": getId(10)
+      }, [renderStops("#F2F3F5", "#DCDEE0")]), vue.createVNode("linearGradient", {
+        "x1": "50%",
+        "x2": "50%",
+        "y2": "100%",
+        "id": getId(11)
+      }, [renderStops("#F2F3F5", "#DCDEE0")]), vue.createVNode("linearGradient", {
+        "x1": "50%",
+        "x2": "50%",
+        "y2": "100%",
+        "id": getId(12)
+      }, [renderStops("#FFF", "#F7F8FA")])]), renderBuilding(), renderCloud(), renderShadow("d"), vue.createVNode("g", {
+        "transform": "rotate(-45 113 -4)",
+        "fill": "none"
+      }, [vue.createVNode("rect", {
+        "fill": getUrlById(9),
+        "x": "24",
+        "y": "52.8",
+        "width": "5.8",
+        "height": "19",
+        "rx": "1"
+      }, null), vue.createVNode("rect", {
+        "fill": getUrlById(10),
+        "x": "22.1",
+        "y": "67.3",
+        "width": "9.9",
+        "height": "28",
+        "rx": "1"
+      }, null), vue.createVNode("circle", {
+        "stroke": getUrlById(11),
+        "stroke-width": "8",
+        "cx": "27",
+        "cy": "27",
+        "r": "27"
+      }, null), vue.createVNode("circle", {
+        "fill": getUrlById(12),
+        "cx": "27",
+        "cy": "27",
+        "r": "16"
+      }, null), vue.createVNode("path", {
+        "d": "M37 7c-8 0-15 5-16 12",
+        "stroke": getUrlById(11),
+        "stroke-width": "3",
+        "opacity": ".5",
+        "stroke-linecap": "round",
+        "transform": "rotate(45 29 13)"
+      }, null)])]);
+      const renderImage = () => {
+        var _a;
+        if (slots.image) {
+          return slots.image();
+        }
+        const PRESET_IMAGES = {
+          error: renderError,
+          search: renderSearch,
+          network: renderNetwork,
+          default: renderMaterial
+        };
+        return ((_a = PRESET_IMAGES[props.image]) == null ? void 0 : _a.call(PRESET_IMAGES)) || vue.createVNode("img", {
+          "src": props.image
+        }, null);
+      };
+      return () => vue.createVNode("div", {
+        "class": bem$I()
+      }, [vue.createVNode("div", {
+        "class": bem$I("image"),
+        "style": getSizeStyle(props.imageSize)
+      }, [renderImage()]), renderDescription(), renderBottom()]);
+    }
+  });
+  const Empty = withInstall(stdin_default$S);
+  const [name$I, bem$H, t$8] = createNamespace("coupon-list");
+  const couponListProps = {
+    code: makeStringProp(""),
+    coupons: makeArrayProp(),
+    currency: makeStringProp("¥"),
+    showCount: truthProp,
+    emptyImage: String,
+    chosenCoupon: makeNumberProp(-1),
+    enabledTitle: String,
+    disabledTitle: String,
+    disabledCoupons: makeArrayProp(),
+    showExchangeBar: truthProp,
+    showCloseButton: truthProp,
+    closeButtonText: String,
+    inputPlaceholder: String,
+    exchangeMinLength: makeNumberProp(1),
+    exchangeButtonText: String,
+    displayedCouponIndex: makeNumberProp(-1),
+    exchangeButtonLoading: Boolean,
+    exchangeButtonDisabled: Boolean
+  };
+  var stdin_default$R = vue.defineComponent({
+    name: name$I,
+    props: couponListProps,
+    emits: ["change", "exchange", "update:code"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const [couponRefs, setCouponRefs] = useRefs();
+      const root = vue.ref();
+      const barRef = vue.ref();
+      const activeTab = vue.ref(0);
+      const listHeight = vue.ref(0);
+      const currentCode = vue.ref(props.code);
+      const buttonDisabled = vue.computed(() => !props.exchangeButtonLoading && (props.exchangeButtonDisabled || !currentCode.value || currentCode.value.length < props.exchangeMinLength));
+      const updateListHeight = () => {
+        const TABS_HEIGHT = 44;
+        const rootHeight = useRect(root).height;
+        const headerHeight = useRect(barRef).height + TABS_HEIGHT;
+        listHeight.value = (rootHeight > headerHeight ? rootHeight : windowHeight.value) - headerHeight;
+      };
+      const onExchange = () => {
+        emit("exchange", currentCode.value);
+        if (!props.code) {
+          currentCode.value = "";
+        }
+      };
+      const scrollToCoupon = (index) => {
+        vue.nextTick(() => {
+          var _a;
+          return (_a = couponRefs.value[index]) == null ? void 0 : _a.scrollIntoView();
+        });
+      };
+      const renderEmpty = () => vue.createVNode(Empty, {
+        "image": props.emptyImage
+      }, {
+        default: () => [vue.createVNode("p", {
+          "class": bem$H("empty-tip")
+        }, [t$8("noCoupon")])]
+      });
+      const renderExchangeBar = () => {
+        if (props.showExchangeBar) {
+          return vue.createVNode("div", {
+            "ref": barRef,
+            "class": bem$H("exchange-bar")
+          }, [vue.createVNode(Field, {
+            "modelValue": currentCode.value,
+            "onUpdate:modelValue": ($event) => currentCode.value = $event,
+            "clearable": true,
+            "border": false,
+            "class": bem$H("field"),
+            "placeholder": props.inputPlaceholder || t$8("placeholder"),
+            "maxlength": "20"
+          }, null), vue.createVNode(Button, {
+            "plain": true,
+            "type": "primary",
+            "class": bem$H("exchange"),
+            "text": props.exchangeButtonText || t$8("exchange"),
+            "loading": props.exchangeButtonLoading,
+            "disabled": buttonDisabled.value,
+            "onClick": onExchange
+          }, null)]);
+        }
+      };
+      const renderCouponTab = () => {
+        const {
+          coupons
+        } = props;
+        const count = props.showCount ? ` (${coupons.length})` : "";
+        const title = (props.enabledTitle || t$8("enable")) + count;
+        return vue.createVNode(Tab, {
+          "title": title
+        }, {
+          default: () => {
+            var _a;
+            return [vue.createVNode("div", {
+              "class": bem$H("list", {
+                "with-bottom": props.showCloseButton
+              }),
+              "style": {
+                height: `${listHeight.value}px`
+              }
+            }, [coupons.map((coupon, index) => vue.createVNode(Coupon, {
+              "key": coupon.id,
+              "ref": setCouponRefs(index),
+              "coupon": coupon,
+              "chosen": index === props.chosenCoupon,
+              "currency": props.currency,
+              "onClick": () => emit("change", index)
+            }, null)), !coupons.length && renderEmpty(), (_a = slots["list-footer"]) == null ? void 0 : _a.call(slots)])];
+          }
+        });
+      };
+      const renderDisabledTab = () => {
+        const {
+          disabledCoupons
+        } = props;
+        const count = props.showCount ? ` (${disabledCoupons.length})` : "";
+        const title = (props.disabledTitle || t$8("disabled")) + count;
+        return vue.createVNode(Tab, {
+          "title": title
+        }, {
+          default: () => {
+            var _a;
+            return [vue.createVNode("div", {
+              "class": bem$H("list", {
+                "with-bottom": props.showCloseButton
+              }),
+              "style": {
+                height: `${listHeight.value}px`
+              }
+            }, [disabledCoupons.map((coupon) => vue.createVNode(Coupon, {
+              "disabled": true,
+              "key": coupon.id,
+              "coupon": coupon,
+              "currency": props.currency
+            }, null)), !disabledCoupons.length && renderEmpty(), (_a = slots["disabled-list-footer"]) == null ? void 0 : _a.call(slots)])];
+          }
+        });
+      };
+      vue.watch(() => props.code, (value) => {
+        currentCode.value = value;
+      });
+      vue.watch(windowHeight, updateListHeight);
+      vue.watch(currentCode, (value) => emit("update:code", value));
+      vue.watch(() => props.displayedCouponIndex, scrollToCoupon);
+      vue.onMounted(() => {
+        updateListHeight();
+        scrollToCoupon(props.displayedCouponIndex);
+      });
+      return () => vue.createVNode("div", {
+        "ref": root,
+        "class": bem$H()
+      }, [renderExchangeBar(), vue.createVNode(Tabs, {
+        "active": activeTab.value,
+        "onUpdate:active": ($event) => activeTab.value = $event,
+        "class": bem$H("tab")
+      }, {
+        default: () => [renderCouponTab(), renderDisabledTab()]
+      }), vue.createVNode("div", {
+        "class": bem$H("bottom")
+      }, [vue.withDirectives(vue.createVNode(Button, {
+        "round": true,
+        "block": true,
+        "type": "primary",
+        "class": bem$H("close"),
+        "text": props.closeButtonText || t$8("close"),
+        "onClick": () => emit("change", -1)
+      }, null), [[vue.vShow, props.showCloseButton]])])]);
+    }
+  });
+  const CouponList = withInstall(stdin_default$R);
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  const [name$H] = createNamespace("date-picker");
+  const datePickerProps = extend({}, sharedProps, {
+    columnsType: {
+      type: Array,
+      default: () => ["year", "month", "day"]
+    },
+    minDate: {
+      type: Date,
+      default: () => new Date(currentYear - 10, 0, 1),
+      validator: isDate
+    },
+    maxDate: {
+      type: Date,
+      default: () => new Date(currentYear + 10, 11, 31),
+      validator: isDate
+    }
+  });
+  var stdin_default$Q = vue.defineComponent({
+    name: name$H,
+    props: datePickerProps,
+    emits: ["confirm", "cancel", "change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const currentValues = vue.ref(props.modelValue);
+      const genYearOptions = () => {
+        const minYear = props.minDate.getFullYear();
+        const maxYear = props.maxDate.getFullYear();
+        return genOptions(minYear, maxYear, "year", props.formatter, props.filter);
+      };
+      const isMinYear = (year) => year === props.minDate.getFullYear();
+      const isMaxYear = (year) => year === props.maxDate.getFullYear();
+      const isMinMonth = (month) => month === props.minDate.getMonth() + 1;
+      const isMaxMonth = (month) => month === props.maxDate.getMonth() + 1;
+      const getValue = (type) => {
+        const {
+          minDate,
+          columnsType
+        } = props;
+        const index = columnsType.indexOf(type);
+        const value = currentValues.value[index];
+        if (value) {
+          return +value;
+        }
+        switch (type) {
+          case "year":
+            return minDate.getFullYear();
+          case "month":
+            return minDate.getMonth() + 1;
+          case "day":
+            return minDate.getDate();
+        }
+      };
+      const genMonthOptions = () => {
+        const year = getValue("year");
+        const minMonth = isMinYear(year) ? props.minDate.getMonth() + 1 : 1;
+        const maxMonth = isMaxYear(year) ? props.maxDate.getMonth() + 1 : 12;
+        return genOptions(minMonth, maxMonth, "month", props.formatter, props.filter);
+      };
+      const genDayOptions = () => {
+        const year = getValue("year");
+        const month = getValue("month");
+        const minDate = isMinYear(year) && isMinMonth(month) ? props.minDate.getDate() : 1;
+        const maxDate = isMaxYear(year) && isMaxMonth(month) ? props.maxDate.getDate() : getMonthEndDay(year, month);
+        return genOptions(minDate, maxDate, "day", props.formatter, props.filter);
+      };
+      const columns = vue.computed(() => props.columnsType.map((type) => {
+        switch (type) {
+          case "year":
+            return genYearOptions();
+          case "month":
+            return genMonthOptions();
+          case "day":
+            return genDayOptions();
+          default:
+            return [];
+        }
+      }));
+      vue.watch(currentValues, (newValues) => {
+        if (!isSameValue(newValues, props.modelValue)) {
+          emit("update:modelValue", newValues);
+        }
+      });
+      vue.watch(() => props.modelValue, (newValues) => {
+        newValues = formatValueRange(newValues, columns.value);
+        if (!isSameValue(newValues, currentValues.value)) {
+          currentValues.value = newValues;
+        }
+      }, {
+        immediate: true
+      });
+      const onChange = (...args) => emit("change", ...args);
+      const onCancel = (...args) => emit("cancel", ...args);
+      const onConfirm = (...args) => emit("confirm", ...args);
+      return () => vue.createVNode(Picker, vue.mergeProps({
+        "modelValue": currentValues.value,
+        "onUpdate:modelValue": ($event) => currentValues.value = $event,
+        "columns": columns.value,
+        "onChange": onChange,
+        "onCancel": onCancel,
+        "onConfirm": onConfirm
+      }, pick(props, pickerInheritKeys)), slots);
+    }
+  });
+  const DatePicker = withInstall(stdin_default$Q);
+  const [name$G, bem$G, t$7] = createNamespace("dialog");
+  const dialogProps = extend({}, popupSharedProps, {
+    title: String,
+    theme: String,
+    width: numericProp,
+    message: [String, Function],
+    callback: Function,
+    allowHtml: Boolean,
+    className: unknownProp,
+    transition: makeStringProp("van-dialog-bounce"),
+    messageAlign: String,
+    closeOnPopstate: truthProp,
+    showCancelButton: Boolean,
+    cancelButtonText: String,
+    cancelButtonColor: String,
+    cancelButtonDisabled: Boolean,
+    confirmButtonText: String,
+    confirmButtonColor: String,
+    confirmButtonDisabled: Boolean,
+    showConfirmButton: truthProp,
+    closeOnClickOverlay: Boolean
+  });
+  const popupInheritKeys$1 = [...popupSharedPropKeys, "transition", "closeOnPopstate"];
+  var stdin_default$P = vue.defineComponent({
+    name: name$G,
+    props: dialogProps,
+    emits: ["confirm", "cancel", "keydown", "update:show"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const root = vue.ref();
+      const loading = vue.reactive({
+        confirm: false,
+        cancel: false
+      });
+      const updateShow = (value) => emit("update:show", value);
+      const close = (action) => {
+        var _a;
+        updateShow(false);
+        (_a = props.callback) == null ? void 0 : _a.call(props, action);
+      };
+      const getActionHandler = (action) => () => {
+        if (!props.show) {
+          return;
+        }
+        emit(action);
+        if (props.beforeClose) {
+          loading[action] = true;
+          callInterceptor(props.beforeClose, {
+            args: [action],
+            done() {
+              close(action);
+              loading[action] = false;
+            },
+            canceled() {
+              loading[action] = false;
+            }
+          });
+        } else {
+          close(action);
+        }
+      };
+      const onCancel = getActionHandler("cancel");
+      const onConfirm = getActionHandler("confirm");
+      const onKeydown = vue.withKeys((event) => {
+        var _a, _b;
+        if (event.target !== ((_b = (_a = root.value) == null ? void 0 : _a.popupRef) == null ? void 0 : _b.value)) {
+          return;
+        }
+        const onEventType = {
+          Enter: props.showConfirmButton ? onConfirm : noop,
+          Escape: props.showCancelButton ? onCancel : noop
+        };
+        onEventType[event.key]();
+        emit("keydown", event);
+      }, ["enter", "esc"]);
+      const renderTitle = () => {
+        const title = slots.title ? slots.title() : props.title;
+        if (title) {
+          return vue.createVNode("div", {
+            "class": bem$G("header", {
+              isolated: !props.message && !slots.default
+            })
+          }, [title]);
+        }
+      };
+      const renderMessage = (hasTitle) => {
+        const {
+          message,
+          allowHtml,
+          messageAlign
+        } = props;
+        const classNames = bem$G("message", {
+          "has-title": hasTitle,
+          [messageAlign]: messageAlign
+        });
+        const content = isFunction(message) ? message() : message;
+        if (allowHtml && typeof content === "string") {
+          return vue.createVNode("div", {
+            "class": classNames,
+            "innerHTML": content
+          }, null);
+        }
+        return vue.createVNode("div", {
+          "class": classNames
+        }, [content]);
+      };
+      const renderContent = () => {
+        if (slots.default) {
+          return vue.createVNode("div", {
+            "class": bem$G("content")
+          }, [slots.default()]);
+        }
+        const {
+          title,
+          message,
+          allowHtml
+        } = props;
+        if (message) {
+          const hasTitle = !!(title || slots.title);
+          return vue.createVNode("div", {
+            "key": allowHtml ? 1 : 0,
+            "class": bem$G("content", {
+              isolated: !hasTitle
+            })
+          }, [renderMessage(hasTitle)]);
+        }
+      };
+      const renderButtons = () => vue.createVNode("div", {
+        "class": [BORDER_TOP, bem$G("footer")]
+      }, [props.showCancelButton && vue.createVNode(Button, {
+        "size": "large",
+        "text": props.cancelButtonText || t$7("cancel"),
+        "class": bem$G("cancel"),
+        "style": {
+          color: props.cancelButtonColor
+        },
+        "loading": loading.cancel,
+        "disabled": props.cancelButtonDisabled,
+        "onClick": onCancel
+      }, null), props.showConfirmButton && vue.createVNode(Button, {
+        "size": "large",
+        "text": props.confirmButtonText || t$7("confirm"),
+        "class": [bem$G("confirm"), {
+          [BORDER_LEFT]: props.showCancelButton
+        }],
+        "style": {
+          color: props.confirmButtonColor
+        },
+        "loading": loading.confirm,
+        "disabled": props.confirmButtonDisabled,
+        "onClick": onConfirm
+      }, null)]);
+      const renderRoundButtons = () => vue.createVNode(ActionBar, {
+        "class": bem$G("footer")
+      }, {
+        default: () => [props.showCancelButton && vue.createVNode(ActionBarButton, {
+          "type": "warning",
+          "text": props.cancelButtonText || t$7("cancel"),
+          "class": bem$G("cancel"),
+          "color": props.cancelButtonColor,
+          "loading": loading.cancel,
+          "disabled": props.cancelButtonDisabled,
+          "onClick": onCancel
+        }, null), props.showConfirmButton && vue.createVNode(ActionBarButton, {
+          "type": "danger",
+          "text": props.confirmButtonText || t$7("confirm"),
+          "class": bem$G("confirm"),
+          "color": props.confirmButtonColor,
+          "loading": loading.confirm,
+          "disabled": props.confirmButtonDisabled,
+          "onClick": onConfirm
+        }, null)]
+      });
+      const renderFooter = () => {
+        if (slots.footer) {
+          return slots.footer();
+        }
+        return props.theme === "round-button" ? renderRoundButtons() : renderButtons();
+      };
+      return () => {
+        const {
+          width: width2,
+          title,
+          theme,
+          message,
+          className
+        } = props;
+        return vue.createVNode(Popup, vue.mergeProps({
+          "ref": root,
+          "role": "dialog",
+          "class": [bem$G([theme]), className],
+          "style": {
+            width: addUnit(width2)
+          },
+          "tabindex": 0,
+          "aria-labelledby": title || message,
+          "onKeydown": onKeydown,
+          "onUpdate:show": updateShow
+        }, pick(props, popupInheritKeys$1)), {
+          default: () => [renderTitle(), renderContent(), renderFooter()]
+        });
+      };
+    }
+  });
+  let instance$2;
+  const DEFAULT_OPTIONS$1 = {
+    title: "",
+    width: "",
+    theme: null,
+    message: "",
+    overlay: true,
+    callback: null,
+    teleport: "body",
+    className: "",
+    allowHtml: false,
+    lockScroll: true,
+    transition: void 0,
+    beforeClose: null,
+    overlayClass: "",
+    overlayStyle: void 0,
+    messageAlign: "",
+    cancelButtonText: "",
+    cancelButtonColor: null,
+    cancelButtonDisabled: false,
+    confirmButtonText: "",
+    confirmButtonColor: null,
+    confirmButtonDisabled: false,
+    showConfirmButton: true,
+    showCancelButton: false,
+    closeOnPopstate: true,
+    closeOnClickOverlay: false
+  };
+  let currentOptions$1 = extend({}, DEFAULT_OPTIONS$1);
+  function initInstance$2() {
+    const Wrapper = {
+      setup() {
+        const {
+          state,
+          toggle
+        } = usePopupState();
+        return () => vue.createVNode(stdin_default$P, vue.mergeProps(state, {
+          "onUpdate:show": toggle
+        }), null);
+      }
+    };
+    ({
+      instance: instance$2
+    } = mountComponent(Wrapper));
+  }
+  function showDialog(options) {
+    if (!inBrowser$1) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      if (!instance$2) {
+        initInstance$2();
+      }
+      instance$2.open(extend({}, currentOptions$1, options, {
+        callback: (action) => {
+          (action === "confirm" ? resolve : reject)(action);
+        }
+      }));
+    });
+  }
+  const setDialogDefaultOptions = (options) => {
+    extend(currentOptions$1, options);
+  };
+  const resetDialogDefaultOptions = () => {
+    currentOptions$1 = extend({}, DEFAULT_OPTIONS$1);
+  };
+  const showConfirmDialog = (options) => showDialog(extend({
+    showCancelButton: true
+  }, options));
+  const closeDialog = () => {
+    if (instance$2) {
+      instance$2.toggle(false);
+    }
+  };
+  const Dialog = withInstall(stdin_default$P);
+  const [name$F, bem$F] = createNamespace("divider");
+  const dividerProps = {
+    dashed: Boolean,
+    hairline: truthProp,
+    contentPosition: makeStringProp("center")
+  };
+  var stdin_default$O = vue.defineComponent({
+    name: name$F,
+    props: dividerProps,
+    setup(props, {
+      slots
+    }) {
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "role": "separator",
+          "class": bem$F({
+            dashed: props.dashed,
+            hairline: props.hairline,
+            [`content-${props.contentPosition}`]: !!slots.default
+          })
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const Divider = withInstall(stdin_default$O);
+  const [name$E, bem$E] = createNamespace("dropdown-menu");
+  const dropdownMenuProps = {
+    overlay: truthProp,
+    zIndex: numericProp,
+    duration: makeNumericProp(0.2),
+    direction: makeStringProp("down"),
+    activeColor: String,
+    closeOnClickOutside: truthProp,
+    closeOnClickOverlay: truthProp
+  };
+  const DROPDOWN_KEY = Symbol(name$E);
+  var stdin_default$N = vue.defineComponent({
+    name: name$E,
+    props: dropdownMenuProps,
+    setup(props, {
+      slots
+    }) {
+      const id = useId();
+      const root = vue.ref();
+      const barRef = vue.ref();
+      const offset2 = vue.ref(0);
+      const {
+        children,
+        linkChildren
+      } = useChildren(DROPDOWN_KEY);
+      const scrollParent = useScrollParent(root);
+      const opened = vue.computed(() => children.some((item) => item.state.showWrapper));
+      const barStyle = vue.computed(() => {
+        if (opened.value && isDef(props.zIndex)) {
+          return {
+            zIndex: +props.zIndex + 1
+          };
+        }
+      });
+      const onClickAway = () => {
+        if (props.closeOnClickOutside) {
+          children.forEach((item) => {
+            item.toggle(false);
+          });
+        }
+      };
+      const updateOffset = () => {
+        if (barRef.value) {
+          const rect = useRect(barRef);
+          if (props.direction === "down") {
+            offset2.value = rect.bottom;
+          } else {
+            offset2.value = windowHeight.value - rect.top;
+          }
+        }
+      };
+      const onScroll = () => {
+        if (opened.value) {
+          updateOffset();
+        }
+      };
+      const toggleItem = (active) => {
+        children.forEach((item, index) => {
+          if (index === active) {
+            item.toggle();
+          } else if (item.state.showPopup) {
+            item.toggle(false, {
+              immediate: true
+            });
+          }
+        });
+      };
+      const renderTitle = (item, index) => {
+        const {
+          showPopup
+        } = item.state;
+        const {
+          disabled,
+          titleClass
+        } = item;
+        return vue.createVNode("div", {
+          "id": `${id}-${index}`,
+          "role": "button",
+          "tabindex": disabled ? void 0 : 0,
+          "class": [bem$E("item", {
+            disabled
+          }), {
+            [HAPTICS_FEEDBACK]: !disabled
+          }],
+          "onClick": () => {
+            if (!disabled) {
+              toggleItem(index);
+            }
+          }
+        }, [vue.createVNode("span", {
+          "class": [bem$E("title", {
+            down: showPopup === (props.direction === "down"),
+            active: showPopup
+          }), titleClass],
+          "style": {
+            color: showPopup ? props.activeColor : ""
+          }
+        }, [vue.createVNode("div", {
+          "class": "van-ellipsis"
+        }, [item.renderTitle()])])]);
+      };
+      linkChildren({
+        id,
+        props,
+        offset: offset2,
+        updateOffset
+      });
+      useClickAway(root, onClickAway);
+      useEventListener("scroll", onScroll, {
+        target: scrollParent,
+        passive: true
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "ref": root,
+          "class": bem$E()
+        }, [vue.createVNode("div", {
+          "ref": barRef,
+          "style": barStyle.value,
+          "class": bem$E("bar", {
+            opened: opened.value
+          })
+        }, [children.map(renderTitle)]), (_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const [name$D, bem$D] = createNamespace("dropdown-item");
+  const dropdownItemProps = {
+    title: String,
+    options: makeArrayProp(),
+    disabled: Boolean,
+    teleport: [String, Object],
+    lazyRender: truthProp,
+    modelValue: unknownProp,
+    titleClass: unknownProp
+  };
+  var stdin_default$M = vue.defineComponent({
+    name: name$D,
+    inheritAttrs: false,
+    props: dropdownItemProps,
+    emits: ["open", "opened", "close", "closed", "change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots,
+      attrs
+    }) {
+      const state = vue.reactive({
+        showPopup: false,
+        transition: true,
+        showWrapper: false
+      });
+      const {
+        parent,
+        index
+      } = useParent(DROPDOWN_KEY);
+      if (!parent) {
+        return;
+      }
+      const getEmitter = (name2) => () => emit(name2);
+      const onOpen = getEmitter("open");
+      const onClose = getEmitter("close");
+      const onOpened = getEmitter("opened");
+      const onClosed = () => {
+        state.showWrapper = false;
+        emit("closed");
+      };
+      const onClickWrapper = (event) => {
+        if (props.teleport) {
+          event.stopPropagation();
+        }
+      };
+      const toggle = (show = !state.showPopup, options = {}) => {
+        if (show === state.showPopup) {
+          return;
+        }
+        state.showPopup = show;
+        state.transition = !options.immediate;
+        if (show) {
+          parent.updateOffset();
+          state.showWrapper = true;
+        }
+      };
+      const renderTitle = () => {
+        if (slots.title) {
+          return slots.title();
+        }
+        if (props.title) {
+          return props.title;
+        }
+        const match = props.options.find((option) => option.value === props.modelValue);
+        return match ? match.text : "";
+      };
+      const renderOption = (option) => {
+        const {
+          activeColor
+        } = parent.props;
+        const active = option.value === props.modelValue;
+        const onClick = () => {
+          state.showPopup = false;
+          if (option.value !== props.modelValue) {
+            emit("update:modelValue", option.value);
+            emit("change", option.value);
+          }
+        };
+        const renderIcon = () => {
+          if (active) {
+            return vue.createVNode(Icon, {
+              "class": bem$D("icon"),
+              "color": activeColor,
+              "name": "success"
+            }, null);
+          }
+        };
+        return vue.createVNode(Cell, {
+          "role": "menuitem",
+          "key": option.value,
+          "icon": option.icon,
+          "title": option.text,
+          "class": bem$D("option", {
+            active
+          }),
+          "style": {
+            color: active ? activeColor : ""
+          },
+          "tabindex": active ? 0 : -1,
+          "clickable": true,
+          "onClick": onClick
+        }, {
+          value: renderIcon
+        });
+      };
+      const renderContent = () => {
+        const {
+          offset: offset2
+        } = parent;
+        const {
+          zIndex,
+          overlay,
+          duration,
+          direction,
+          closeOnClickOverlay
+        } = parent.props;
+        const style = getZIndexStyle(zIndex);
+        if (direction === "down") {
+          style.top = `${offset2.value}px`;
+        } else {
+          style.bottom = `${offset2.value}px`;
+        }
+        return vue.withDirectives(vue.createVNode("div", vue.mergeProps({
+          "style": style,
+          "class": bem$D([direction]),
+          "onClick": onClickWrapper
+        }, attrs), [vue.createVNode(Popup, {
+          "show": state.showPopup,
+          "onUpdate:show": ($event) => state.showPopup = $event,
+          "role": "menu",
+          "class": bem$D("content"),
+          "overlay": overlay,
+          "position": direction === "down" ? "top" : "bottom",
+          "duration": state.transition ? duration : 0,
+          "lazyRender": props.lazyRender,
+          "overlayStyle": {
+            position: "absolute"
+          },
+          "aria-labelledby": `${parent.id}-${index.value}`,
+          "closeOnClickOverlay": closeOnClickOverlay,
+          "onOpen": onOpen,
+          "onClose": onClose,
+          "onOpened": onOpened,
+          "onClosed": onClosed
+        }, {
+          default: () => {
+            var _a;
+            return [props.options.map(renderOption), (_a = slots.default) == null ? void 0 : _a.call(slots)];
+          }
+        })]), [[vue.vShow, state.showWrapper]]);
+      };
+      useExpose({
+        state,
+        toggle,
+        renderTitle
+      });
+      return () => {
+        if (props.teleport) {
+          return vue.createVNode(vue.Teleport, {
+            "to": props.teleport
+          }, {
+            default: () => [renderContent()]
+          });
+        }
+        return renderContent();
+      };
+    }
+  });
+  const DropdownItem = withInstall(stdin_default$M);
+  const DropdownMenu = withInstall(stdin_default$N);
+  const [name$C, bem$C] = createNamespace("grid");
+  const gridProps = {
+    square: Boolean,
+    center: truthProp,
+    border: truthProp,
+    gutter: numericProp,
+    reverse: Boolean,
+    iconSize: numericProp,
+    direction: String,
+    clickable: Boolean,
+    columnNum: makeNumericProp(4)
+  };
+  const GRID_KEY = Symbol(name$C);
+  var stdin_default$L = vue.defineComponent({
+    name: name$C,
+    props: gridProps,
+    setup(props, {
+      slots
+    }) {
+      const {
+        linkChildren
+      } = useChildren(GRID_KEY);
+      linkChildren({
+        props
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "style": {
+            paddingLeft: addUnit(props.gutter)
+          },
+          "class": [bem$C(), {
+            [BORDER_TOP]: props.border && !props.gutter
+          }]
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const Grid = withInstall(stdin_default$L);
+  const [name$B, bem$B] = createNamespace("grid-item");
+  const gridItemProps = extend({}, routeProps, {
+    dot: Boolean,
+    text: String,
+    icon: String,
+    badge: numericProp,
+    iconColor: String,
+    iconPrefix: String,
+    badgeProps: Object
+  });
+  var stdin_default$K = vue.defineComponent({
+    name: name$B,
+    props: gridItemProps,
+    setup(props, {
+      slots
+    }) {
+      const {
+        parent,
+        index
+      } = useParent(GRID_KEY);
+      const route2 = useRoute();
+      if (!parent) {
+        return;
+      }
+      const rootStyle = vue.computed(() => {
+        const {
+          square,
+          gutter,
+          columnNum
+        } = parent.props;
+        const percent = `${100 / +columnNum}%`;
+        const style = {
+          flexBasis: percent
+        };
+        if (square) {
+          style.paddingTop = percent;
+        } else if (gutter) {
+          const gutterValue = addUnit(gutter);
+          style.paddingRight = gutterValue;
+          if (index.value >= +columnNum) {
+            style.marginTop = gutterValue;
+          }
+        }
+        return style;
+      });
+      const contentStyle = vue.computed(() => {
+        const {
+          square,
+          gutter
+        } = parent.props;
+        if (square && gutter) {
+          const gutterValue = addUnit(gutter);
+          return {
+            right: gutterValue,
+            bottom: gutterValue,
+            height: "auto"
+          };
+        }
+      });
+      const renderIcon = () => {
+        if (slots.icon) {
+          return vue.createVNode(Badge, vue.mergeProps({
+            "dot": props.dot,
+            "content": props.badge
+          }, props.badgeProps), {
+            default: slots.icon
+          });
+        }
+        if (props.icon) {
+          return vue.createVNode(Icon, {
+            "dot": props.dot,
+            "name": props.icon,
+            "size": parent.props.iconSize,
+            "badge": props.badge,
+            "class": bem$B("icon"),
+            "color": props.iconColor,
+            "badgeProps": props.badgeProps,
+            "classPrefix": props.iconPrefix
+          }, null);
+        }
+      };
+      const renderText = () => {
+        if (slots.text) {
+          return slots.text();
+        }
+        if (props.text) {
+          return vue.createVNode("span", {
+            "class": bem$B("text")
+          }, [props.text]);
+        }
+      };
+      const renderContent = () => {
+        if (slots.default) {
+          return slots.default();
+        }
+        return [renderIcon(), renderText()];
+      };
+      return () => {
+        const {
+          center,
+          border,
+          square,
+          gutter,
+          reverse,
+          direction,
+          clickable
+        } = parent.props;
+        const classes = [bem$B("content", [direction, {
+          center,
+          square,
+          reverse,
+          clickable,
+          surround: border && gutter
+        }]), {
+          [BORDER]: border
+        }];
+        return vue.createVNode("div", {
+          "class": [bem$B({
+            square
+          })],
+          "style": rootStyle.value
+        }, [vue.createVNode("div", {
+          "role": clickable ? "button" : void 0,
+          "class": classes,
+          "style": contentStyle.value,
+          "tabindex": clickable ? 0 : void 0,
+          "onClick": route2
+        }, [renderContent()])]);
+      };
+    }
+  });
+  const GridItem = withInstall(stdin_default$K);
+  const getDistance = (touches) => Math.sqrt((touches[0].clientX - touches[1].clientX) ** 2 + (touches[0].clientY - touches[1].clientY) ** 2);
+  const bem$A = createNamespace("image-preview")[1];
+  var stdin_default$J = vue.defineComponent({
+    props: {
+      src: String,
+      show: Boolean,
+      active: Number,
+      minZoom: makeRequiredProp(numericProp),
+      maxZoom: makeRequiredProp(numericProp),
+      rootWidth: makeRequiredProp(Number),
+      rootHeight: makeRequiredProp(Number),
+      disableZoom: Boolean
+    },
+    emits: ["scale", "close", "longPress"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const state = vue.reactive({
+        scale: 1,
+        moveX: 0,
+        moveY: 0,
+        moving: false,
+        zooming: false,
+        imageRatio: 0,
+        displayWidth: 0,
+        displayHeight: 0
+      });
+      const touch = useTouch();
+      const swipeItem = vue.ref();
+      const vertical = vue.computed(() => {
+        const {
+          rootWidth,
+          rootHeight
+        } = props;
+        const rootRatio = rootHeight / rootWidth;
+        return state.imageRatio > rootRatio;
+      });
+      const imageStyle = vue.computed(() => {
+        const {
+          scale,
+          moveX,
+          moveY,
+          moving,
+          zooming
+        } = state;
+        const style = {
+          transitionDuration: zooming || moving ? "0s" : ".3s"
+        };
+        if (scale !== 1) {
+          const offsetX = moveX / scale;
+          const offsetY = moveY / scale;
+          style.transform = `scale(${scale}, ${scale}) translate(${offsetX}px, ${offsetY}px)`;
+        }
+        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) => {
+        scale = clamp(scale, +props.minZoom, +props.maxZoom + 1);
+        if (scale !== state.scale) {
+          state.scale = scale;
+          emit("scale", {
+            scale,
+            index: props.active
+          });
+        }
+      };
+      const resetScale = () => {
+        setScale(1);
+        state.moveX = 0;
+        state.moveY = 0;
+      };
+      const toggleScale = () => {
+        const scale = state.scale > 1 ? 1 : 2;
+        setScale(scale);
+        state.moveX = 0;
+        state.moveY = 0;
+      };
+      let fingerNum;
+      let startMoveX;
+      let startMoveY;
+      let startScale;
+      let startDistance;
+      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;
+        state.zooming = fingerNum === 2 && !offsetX.value;
+        if (state.zooming) {
+          startScale = state.scale;
+          startDistance = getDistance(event.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 ((moveX > maxMoveX.value || moveX < -maxMoveX.value) && !isImageMoved && touch.isHorizontal()) {
+            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;
+            setScale(scale);
+          }
+        }
+      };
+      const checkTap = () => {
+        if (fingerNum > 1) {
+          return;
+        }
+        const {
+          offsetX,
+          offsetY
+        } = touch;
+        const deltaTime = Date.now() - touchStartTime;
+        const TAP_TIME = 250;
+        const TAP_OFFSET = 5;
+        if (offsetX.value < TAP_OFFSET && offsetY.value < TAP_OFFSET) {
+          if (deltaTime < TAP_TIME) {
+            if (doubleTapTimer) {
+              clearTimeout(doubleTapTimer);
+              doubleTapTimer = null;
+              toggleScale();
+            } else {
+              doubleTapTimer = setTimeout(() => {
+                emit("close");
+                doubleTapTimer = null;
+              }, TAP_TIME);
+            }
+          } 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) {
+              state.scale = maxZoom;
+            }
+          }
+        }
+        preventDefault(event, stopPropagation2);
+        checkTap();
+        touch.reset();
+      };
+      const onLoad = (event) => {
+        const {
+          naturalWidth,
+          naturalHeight
+        } = event.target;
+        state.imageRatio = naturalHeight / naturalWidth;
+      };
+      vue.watch(() => props.active, resetScale);
+      vue.watch(() => props.show, (value) => {
+        if (!value) {
+          resetScale();
+        }
+      });
+      useEventListener("touchmove", onTouchMove, {
+        target: vue.computed(() => {
+          var _a;
+          return (_a = swipeItem.value) == null ? void 0 : _a.$el;
+        })
+      });
+      return () => {
+        const imageSlots = {
+          loading: () => vue.createVNode(Loading, {
+            "type": "spinner"
+          }, null)
+        };
+        return vue.createVNode(SwipeItem, {
+          "ref": swipeItem,
+          "class": bem$A("swipe-item"),
+          "onTouchstartPassive": onTouchStart,
+          "onTouchend": onTouchEnd,
+          "onTouchcancel": onTouchEnd
+        }, {
+          default: () => [slots.image ? vue.createVNode("div", {
+            "class": bem$A("image-wrap")
+          }, [slots.image({
+            src: props.src
+          })]) : vue.createVNode(Image$1, {
+            "src": props.src,
+            "fit": "contain",
+            "class": bem$A("image", {
+              vertical: vertical.value
+            }),
+            "style": imageStyle.value,
+            "onLoad": onLoad
+          }, imageSlots)]
+        });
+      };
+    }
+  });
+  const [name$A, bem$z] = createNamespace("image-preview");
+  const popupProps$1 = ["show", "teleport", "transition", "overlayStyle", "closeOnPopstate"];
+  const imagePreviewProps = {
+    show: Boolean,
+    loop: truthProp,
+    images: makeArrayProp(),
+    minZoom: makeNumericProp(1 / 3),
+    maxZoom: makeNumericProp(3),
+    overlay: truthProp,
+    closeable: Boolean,
+    showIndex: truthProp,
+    className: unknownProp,
+    closeIcon: makeStringProp("clear"),
+    transition: String,
+    beforeClose: Function,
+    overlayClass: unknownProp,
+    overlayStyle: Object,
+    swipeDuration: makeNumericProp(300),
+    startPosition: makeNumericProp(0),
+    showIndicators: Boolean,
+    closeOnPopstate: truthProp,
+    closeIconPosition: makeStringProp("top-right"),
+    teleport: [String, Object]
+  };
+  var stdin_default$I = vue.defineComponent({
+    name: name$A,
+    props: imagePreviewProps,
+    emits: ["scale", "close", "closed", "change", "longPress", "update:show"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const swipeRef = 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$z("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$z("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$z("swipe"),
+        "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$J, {
+          "src": image,
+          "show": props.show,
+          "active": state.active,
+          "maxZoom": props.maxZoom,
+          "minZoom": props.minZoom,
+          "rootWidth": state.rootWidth,
+          "rootHeight": state.rootHeight,
+          "disableZoom": state.disableZoom,
+          "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$z("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({
+        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$z(), props.className],
+        "overlayClass": [bem$z("overlay"), props.overlayClass],
+        "onClosed": onClosed,
+        "onUpdate:show": updateShow
+      }, pick(props, popupProps$1)), {
+        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,
+    teleport: "body",
+    className: "",
+    showIndex: true,
+    closeable: false,
+    closeIcon: "clear",
+    transition: void 0,
+    beforeClose: void 0,
+    overlayStyle: void 0,
+    overlayClass: void 0,
+    startPosition: 0,
+    swipeDuration: 300,
+    showIndicators: false,
+    closeOnPopstate: 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$I, 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({}, defaultConfig, options));
+    return instance$1;
+  };
+  const ImagePreview = withInstall(stdin_default$I);
+  function genAlphabet() {
+    const charCodeOfA = "A".charCodeAt(0);
+    const indexList = Array(26).fill("").map((_, i) => String.fromCharCode(charCodeOfA + i));
+    return indexList;
+  }
+  const [name$z, bem$y] = createNamespace("index-bar");
+  const indexBarProps = {
+    sticky: truthProp,
+    zIndex: numericProp,
+    teleport: [String, Object],
+    highlightColor: String,
+    stickyOffsetTop: makeNumberProp(0),
+    indexList: {
+      type: Array,
+      default: genAlphabet
+    }
+  };
+  const INDEX_BAR_KEY = Symbol(name$z);
+  var stdin_default$H = vue.defineComponent({
+    name: name$z,
+    props: indexBarProps,
+    emits: ["select", "change"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const root = vue.ref();
+      const sidebar = vue.ref();
+      const activeAnchor = vue.ref("");
+      const touch = useTouch();
+      const scrollParent = useScrollParent(root);
+      const {
+        children,
+        linkChildren
+      } = useChildren(INDEX_BAR_KEY);
+      let selectActiveIndex;
+      linkChildren({
+        props
+      });
+      const sidebarStyle = vue.computed(() => {
+        if (isDef(props.zIndex)) {
+          return {
+            zIndex: +props.zIndex + 1
+          };
+        }
+      });
+      const highlightStyle = vue.computed(() => {
+        if (props.highlightColor) {
+          return {
+            color: props.highlightColor
+          };
+        }
+      });
+      const getActiveAnchor = (scrollTop, rects) => {
+        for (let i = children.length - 1; i >= 0; i--) {
+          const prevHeight = i > 0 ? rects[i - 1].height : 0;
+          const reachTop = props.sticky ? prevHeight + props.stickyOffsetTop : 0;
+          if (scrollTop + reachTop >= rects[i].top) {
+            return i;
+          }
+        }
+        return -1;
+      };
+      const getMatchAnchor = (index) => children.find((item) => String(item.index) === index);
+      const onScroll = () => {
+        if (isHidden(root)) {
+          return;
+        }
+        const {
+          sticky,
+          indexList
+        } = props;
+        const scrollTop = getScrollTop(scrollParent.value);
+        const scrollParentRect = useRect(scrollParent);
+        const rects = children.map((item) => item.getRect(scrollParent.value, scrollParentRect));
+        let active = -1;
+        if (selectActiveIndex) {
+          const match = getMatchAnchor(selectActiveIndex);
+          if (match) {
+            const rect = match.getRect(scrollParent.value, scrollParentRect);
+            active = getActiveAnchor(rect.top, rects);
+          }
+        } else {
+          active = getActiveAnchor(scrollTop, rects);
+        }
+        activeAnchor.value = indexList[active];
+        if (sticky) {
+          children.forEach((item, index) => {
+            const {
+              state,
+              $el
+            } = item;
+            if (index === active || index === active - 1) {
+              const rect = $el.getBoundingClientRect();
+              state.left = rect.left;
+              state.width = rect.width;
+            } else {
+              state.left = null;
+              state.width = null;
+            }
+            if (index === active) {
+              state.active = true;
+              state.top = Math.max(props.stickyOffsetTop, rects[index].top - scrollTop) + scrollParentRect.top;
+            } else if (index === active - 1 && selectActiveIndex === "") {
+              const activeItemTop = rects[active].top - scrollTop;
+              state.active = activeItemTop > 0;
+              state.top = activeItemTop + scrollParentRect.top - rects[index].height;
+            } else {
+              state.active = false;
+            }
+          });
+        }
+        selectActiveIndex = "";
+      };
+      const init = () => {
+        vue.nextTick(onScroll);
+      };
+      useEventListener("scroll", onScroll, {
+        target: scrollParent,
+        passive: true
+      });
+      vue.onMounted(init);
+      vue.watch(() => props.indexList, init);
+      vue.watch(activeAnchor, (value) => {
+        if (value) {
+          emit("change", value);
+        }
+      });
+      const renderIndexes = () => props.indexList.map((index) => {
+        const active = index === activeAnchor.value;
+        return vue.createVNode("span", {
+          "class": bem$y("index", {
+            active
+          }),
+          "style": active ? highlightStyle.value : void 0,
+          "data-index": index
+        }, [index]);
+      });
+      const scrollTo = (index) => {
+        selectActiveIndex = String(index);
+        const match = getMatchAnchor(selectActiveIndex);
+        if (match) {
+          const scrollTop = getScrollTop(scrollParent.value);
+          const scrollParentRect = useRect(scrollParent);
+          const {
+            offsetHeight
+          } = document.documentElement;
+          match.$el.scrollIntoView();
+          if (scrollTop === offsetHeight - scrollParentRect.height) {
+            onScroll();
+            return;
+          }
+          if (props.sticky && props.stickyOffsetTop) {
+            setRootScrollTop(getRootScrollTop() - props.stickyOffsetTop);
+          }
+          emit("select", match.index);
+        }
+      };
+      const scrollToElement = (element) => {
+        const {
+          index
+        } = element.dataset;
+        if (index) {
+          scrollTo(index);
+        }
+      };
+      const onClickSidebar = (event) => {
+        scrollToElement(event.target);
+      };
+      let touchActiveIndex;
+      const onTouchMove = (event) => {
+        touch.move(event);
+        if (touch.isVertical()) {
+          preventDefault(event);
+          const {
+            clientX,
+            clientY
+          } = event.touches[0];
+          const target = document.elementFromPoint(clientX, clientY);
+          if (target) {
+            const {
+              index
+            } = target.dataset;
+            if (index && touchActiveIndex !== index) {
+              touchActiveIndex = index;
+              scrollToElement(target);
+            }
+          }
+        }
+      };
+      const renderSidebar = () => vue.createVNode("div", {
+        "ref": sidebar,
+        "class": bem$y("sidebar"),
+        "style": sidebarStyle.value,
+        "onClick": onClickSidebar,
+        "onTouchstartPassive": touch.start
+      }, [renderIndexes()]);
+      useExpose({
+        scrollTo
+      });
+      useEventListener("touchmove", onTouchMove, {
+        target: sidebar
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "ref": root,
+          "class": bem$y()
+        }, [props.teleport ? vue.createVNode(vue.Teleport, {
+          "to": props.teleport
+        }, {
+          default: () => [renderSidebar()]
+        }) : renderSidebar(), (_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const [name$y, bem$x] = createNamespace("index-anchor");
+  const indexAnchorProps = {
+    index: numericProp
+  };
+  var stdin_default$G = vue.defineComponent({
+    name: name$y,
+    props: indexAnchorProps,
+    setup(props, {
+      slots
+    }) {
+      const state = vue.reactive({
+        top: 0,
+        left: null,
+        rect: {
+          top: 0,
+          height: 0
+        },
+        width: null,
+        active: false
+      });
+      const root = vue.ref();
+      const {
+        parent
+      } = useParent(INDEX_BAR_KEY);
+      if (!parent) {
+        return;
+      }
+      const isSticky = () => state.active && parent.props.sticky;
+      const anchorStyle = vue.computed(() => {
+        const {
+          zIndex,
+          highlightColor
+        } = parent.props;
+        if (isSticky()) {
+          return extend(getZIndexStyle(zIndex), {
+            left: state.left ? `${state.left}px` : void 0,
+            width: state.width ? `${state.width}px` : void 0,
+            transform: state.top ? `translate3d(0, ${state.top}px, 0)` : void 0,
+            color: highlightColor
+          });
+        }
+      });
+      const getRect = (scrollParent, scrollParentRect) => {
+        const rootRect = useRect(root);
+        state.rect.height = rootRect.height;
+        if (scrollParent === window || scrollParent === document.body) {
+          state.rect.top = rootRect.top + getRootScrollTop();
+        } else {
+          state.rect.top = rootRect.top + getScrollTop(scrollParent) - scrollParentRect.top;
+        }
+        return state.rect;
+      };
+      useExpose({
+        state,
+        getRect
+      });
+      return () => {
+        const sticky = isSticky();
+        return vue.createVNode("div", {
+          "ref": root,
+          "style": {
+            height: sticky ? `${state.rect.height}px` : void 0
+          }
+        }, [vue.createVNode("div", {
+          "style": anchorStyle.value,
+          "class": [bem$x({
+            sticky
+          }), {
+            [BORDER_BOTTOM]: sticky
+          }]
+        }, [slots.default ? slots.default() : props.index])]);
+      };
+    }
+  });
+  const IndexAnchor = withInstall(stdin_default$G);
+  const IndexBar = withInstall(stdin_default$H);
+  const [name$x, bem$w, t$6] = createNamespace("list");
+  const listProps = {
+    error: Boolean,
+    offset: makeNumericProp(300),
+    loading: Boolean,
+    disabled: Boolean,
+    finished: Boolean,
+    errorText: String,
+    direction: makeStringProp("down"),
+    loadingText: String,
+    finishedText: String,
+    immediateCheck: truthProp
+  };
+  var stdin_default$F = vue.defineComponent({
+    name: name$x,
+    props: listProps,
+    emits: ["load", "update:error", "update:loading"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const loading = vue.ref(props.loading);
+      const root = vue.ref();
+      const placeholder = vue.ref();
+      const tabStatus = useTabStatus();
+      const scrollParent = useScrollParent(root);
+      const check = () => {
+        vue.nextTick(() => {
+          if (loading.value || props.finished || props.disabled || props.error || // skip check when inside an inactive tab
+          (tabStatus == null ? void 0 : tabStatus.value) === false) {
+            return;
+          }
+          const {
+            direction
+          } = props;
+          const offset2 = +props.offset;
+          const scrollParentRect = useRect(scrollParent);
+          if (!scrollParentRect.height || isHidden(root)) {
+            return;
+          }
+          let isReachEdge = false;
+          const placeholderRect = useRect(placeholder);
+          if (direction === "up") {
+            isReachEdge = scrollParentRect.top - placeholderRect.top <= offset2;
+          } else {
+            isReachEdge = placeholderRect.bottom - scrollParentRect.bottom <= offset2;
+          }
+          if (isReachEdge) {
+            loading.value = true;
+            emit("update:loading", true);
+            emit("load");
+          }
+        });
+      };
+      const renderFinishedText = () => {
+        if (props.finished) {
+          const text = slots.finished ? slots.finished() : props.finishedText;
+          if (text) {
+            return vue.createVNode("div", {
+              "class": bem$w("finished-text")
+            }, [text]);
+          }
+        }
+      };
+      const clickErrorText = () => {
+        emit("update:error", false);
+        check();
+      };
+      const renderErrorText = () => {
+        if (props.error) {
+          const text = slots.error ? slots.error() : props.errorText;
+          if (text) {
+            return vue.createVNode("div", {
+              "role": "button",
+              "class": bem$w("error-text"),
+              "tabindex": 0,
+              "onClick": clickErrorText
+            }, [text]);
+          }
+        }
+      };
+      const renderLoading = () => {
+        if (loading.value && !props.finished && !props.disabled) {
+          return vue.createVNode("div", {
+            "class": bem$w("loading")
+          }, [slots.loading ? slots.loading() : vue.createVNode(Loading, {
+            "class": bem$w("loading-icon")
+          }, {
+            default: () => [props.loadingText || t$6("loading")]
+          })]);
+        }
+      };
+      vue.watch(() => [props.loading, props.finished, props.error], check);
+      if (tabStatus) {
+        vue.watch(tabStatus, (tabActive) => {
+          if (tabActive) {
+            check();
+          }
+        });
+      }
+      vue.onUpdated(() => {
+        loading.value = props.loading;
+      });
+      vue.onMounted(() => {
+        if (props.immediateCheck) {
+          check();
+        }
+      });
+      useExpose({
+        check
+      });
+      useEventListener("scroll", check, {
+        target: scrollParent,
+        passive: true
+      });
+      return () => {
+        var _a;
+        const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
+        const Placeholder = vue.createVNode("div", {
+          "ref": placeholder,
+          "class": bem$w("placeholder")
+        }, null);
+        return vue.createVNode("div", {
+          "ref": root,
+          "role": "feed",
+          "class": bem$w(),
+          "aria-busy": loading.value
+        }, [props.direction === "down" ? Content : Placeholder, renderLoading(), renderFinishedText(), renderErrorText(), props.direction === "up" ? Content : Placeholder]);
+      };
+    }
+  });
+  const List = withInstall(stdin_default$F);
+  const [name$w, bem$v] = createNamespace("nav-bar");
+  const navBarProps = {
+    title: String,
+    fixed: Boolean,
+    zIndex: numericProp,
+    border: truthProp,
+    leftText: String,
+    rightText: String,
+    leftArrow: Boolean,
+    placeholder: Boolean,
+    safeAreaInsetTop: Boolean,
+    clickable: truthProp
+  };
+  var stdin_default$E = vue.defineComponent({
+    name: name$w,
+    props: navBarProps,
+    emits: ["clickLeft", "clickRight"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const navBarRef = vue.ref();
+      const renderPlaceholder = usePlaceholder(navBarRef, bem$v);
+      const onClickLeft = (event) => emit("clickLeft", event);
+      const onClickRight = (event) => emit("clickRight", event);
+      const renderLeft = () => {
+        if (slots.left) {
+          return slots.left();
+        }
+        return [props.leftArrow && vue.createVNode(Icon, {
+          "class": bem$v("arrow"),
+          "name": "arrow-left"
+        }, null), props.leftText && vue.createVNode("span", {
+          "class": bem$v("text")
+        }, [props.leftText])];
+      };
+      const renderRight = () => {
+        if (slots.right) {
+          return slots.right();
+        }
+        return vue.createVNode("span", {
+          "class": bem$v("text")
+        }, [props.rightText]);
+      };
+      const renderNavBar = () => {
+        const {
+          title,
+          fixed,
+          border,
+          zIndex
+        } = props;
+        const style = getZIndexStyle(zIndex);
+        const hasLeft = props.leftArrow || props.leftText || slots.left;
+        const hasRight = props.rightText || slots.right;
+        return vue.createVNode("div", {
+          "ref": navBarRef,
+          "style": style,
+          "class": [bem$v({
+            fixed
+          }), {
+            [BORDER_BOTTOM]: border,
+            "van-safe-area-top": props.safeAreaInsetTop
+          }]
+        }, [vue.createVNode("div", {
+          "class": bem$v("content")
+        }, [hasLeft && vue.createVNode("div", {
+          "class": [bem$v("left"), props.clickable ? HAPTICS_FEEDBACK : ""],
+          "onClick": onClickLeft
+        }, [renderLeft()]), vue.createVNode("div", {
+          "class": [bem$v("title"), "van-ellipsis"]
+        }, [slots.title ? slots.title() : title]), hasRight && vue.createVNode("div", {
+          "class": [bem$v("right"), props.clickable ? HAPTICS_FEEDBACK : ""],
+          "onClick": onClickRight
+        }, [renderRight()])])]);
+      };
+      return () => {
+        if (props.fixed && props.placeholder) {
+          return renderPlaceholder(renderNavBar);
+        }
+        return renderNavBar();
+      };
+    }
+  });
+  const NavBar = withInstall(stdin_default$E);
+  const [name$v, bem$u] = createNamespace("notice-bar");
+  const noticeBarProps = {
+    text: String,
+    mode: String,
+    color: String,
+    delay: makeNumericProp(1),
+    speed: makeNumericProp(60),
+    leftIcon: String,
+    wrapable: Boolean,
+    background: String,
+    scrollable: {
+      type: Boolean,
+      default: null
+    }
+  };
+  var stdin_default$D = vue.defineComponent({
+    name: name$v,
+    props: noticeBarProps,
+    emits: ["close", "replay"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      let wrapWidth = 0;
+      let contentWidth = 0;
+      let startTimer;
+      const wrapRef = vue.ref();
+      const contentRef = vue.ref();
+      const state = vue.reactive({
+        show: true,
+        offset: 0,
+        duration: 0
+      });
+      const renderLeftIcon = () => {
+        if (slots["left-icon"]) {
+          return slots["left-icon"]();
+        }
+        if (props.leftIcon) {
+          return vue.createVNode(Icon, {
+            "class": bem$u("left-icon"),
+            "name": props.leftIcon
+          }, null);
+        }
+      };
+      const getRightIconName = () => {
+        if (props.mode === "closeable") {
+          return "cross";
+        }
+        if (props.mode === "link") {
+          return "arrow";
+        }
+      };
+      const onClickRightIcon = (event) => {
+        if (props.mode === "closeable") {
+          state.show = false;
+          emit("close", event);
+        }
+      };
+      const renderRightIcon = () => {
+        if (slots["right-icon"]) {
+          return slots["right-icon"]();
+        }
+        const name2 = getRightIconName();
+        if (name2) {
+          return vue.createVNode(Icon, {
+            "name": name2,
+            "class": bem$u("right-icon"),
+            "onClick": onClickRightIcon
+          }, null);
+        }
+      };
+      const onTransitionEnd = () => {
+        state.offset = wrapWidth;
+        state.duration = 0;
+        raf(() => {
+          doubleRaf(() => {
+            state.offset = -contentWidth;
+            state.duration = (contentWidth + wrapWidth) / +props.speed;
+            emit("replay");
+          });
+        });
+      };
+      const renderMarquee = () => {
+        const ellipsis = props.scrollable === false && !props.wrapable;
+        const style = {
+          transform: state.offset ? `translateX(${state.offset}px)` : "",
+          transitionDuration: `${state.duration}s`
+        };
+        return vue.createVNode("div", {
+          "ref": wrapRef,
+          "role": "marquee",
+          "class": bem$u("wrap")
+        }, [vue.createVNode("div", {
+          "ref": contentRef,
+          "style": style,
+          "class": [bem$u("content"), {
+            "van-ellipsis": ellipsis
+          }],
+          "onTransitionend": onTransitionEnd
+        }, [slots.default ? slots.default() : props.text])]);
+      };
+      const reset = () => {
+        const {
+          delay,
+          speed,
+          scrollable
+        } = props;
+        const ms = isDef(delay) ? +delay * 1e3 : 0;
+        wrapWidth = 0;
+        contentWidth = 0;
+        state.offset = 0;
+        state.duration = 0;
+        clearTimeout(startTimer);
+        startTimer = setTimeout(() => {
+          if (!wrapRef.value || !contentRef.value || scrollable === false) {
+            return;
+          }
+          const wrapRefWidth = useRect(wrapRef).width;
+          const contentRefWidth = useRect(contentRef).width;
+          if (scrollable || contentRefWidth > wrapRefWidth) {
+            doubleRaf(() => {
+              wrapWidth = wrapRefWidth;
+              contentWidth = contentRefWidth;
+              state.offset = -contentWidth;
+              state.duration = contentWidth / +speed;
+            });
+          }
+        }, ms);
+      };
+      onPopupReopen(reset);
+      onMountedOrActivated(reset);
+      useEventListener("pageshow", reset);
+      useExpose({
+        reset
+      });
+      vue.watch(() => [props.text, props.scrollable], reset);
+      return () => {
+        const {
+          color,
+          wrapable,
+          background
+        } = props;
+        return vue.withDirectives(vue.createVNode("div", {
+          "role": "alert",
+          "class": bem$u({
+            wrapable
+          }),
+          "style": {
+            color,
+            background
+          }
+        }, [renderLeftIcon(), renderMarquee(), renderRightIcon()]), [[vue.vShow, state.show]]);
+      };
+    }
+  });
+  const NoticeBar = withInstall(stdin_default$D);
+  const [name$u, bem$t] = createNamespace("notify");
+  const notifyProps = extend({}, popupSharedProps, {
+    type: makeStringProp("danger"),
+    color: String,
+    message: numericProp,
+    position: makeStringProp("top"),
+    className: unknownProp,
+    background: String,
+    lockScroll: Boolean
+  });
+  var stdin_default$C = vue.defineComponent({
+    name: name$u,
+    props: notifyProps,
+    emits: ["update:show"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const updateShow = (show) => emit("update:show", show);
+      return () => vue.createVNode(Popup, {
+        "show": props.show,
+        "class": [bem$t([props.type]), props.className],
+        "style": {
+          color: props.color,
+          background: props.background
+        },
+        "overlay": false,
+        "zIndex": props.zIndex,
+        "position": props.position,
+        "duration": 0.2,
+        "lockScroll": props.lockScroll,
+        "onUpdate:show": updateShow
+      }, {
+        default: () => [slots.default ? slots.default() : props.message]
+      });
+    }
+  });
+  let timer;
+  let instance;
+  const parseOptions = (message) => isObject(message) ? message : {
+    message
+  };
+  function initInstance() {
+    ({
+      instance
+    } = mountComponent({
+      setup() {
+        const {
+          state,
+          toggle
+        } = usePopupState();
+        return () => vue.createVNode(stdin_default$C, vue.mergeProps(state, {
+          "onUpdate:show": toggle
+        }), null);
+      }
+    }));
+  }
+  const getDefaultOptions = () => ({
+    type: "danger",
+    color: void 0,
+    message: "",
+    onClose: void 0,
+    onClick: void 0,
+    onOpened: void 0,
+    duration: 3e3,
+    position: void 0,
+    className: "",
+    lockScroll: false,
+    background: void 0
+  });
+  let currentOptions = getDefaultOptions();
+  const closeNotify = () => {
+    if (instance) {
+      instance.toggle(false);
+    }
+  };
+  function showNotify(options) {
+    if (!inBrowser$1) {
+      return;
+    }
+    if (!instance) {
+      initInstance();
+    }
+    options = extend({}, currentOptions, parseOptions(options));
+    instance.open(options);
+    clearTimeout(timer);
+    if (options.duration > 0) {
+      timer = setTimeout(closeNotify, options.duration);
+    }
+    return instance;
+  }
+  const setNotifyDefaultOptions = (options) => extend(currentOptions, options);
+  const resetNotifyDefaultOptions = () => {
+    currentOptions = getDefaultOptions();
+  };
+  const Notify = withInstall(stdin_default$C);
+  const [name$t, bem$s] = createNamespace("key");
+  const CollapseIcon = vue.createVNode("svg", {
+    "class": bem$s("collapse-icon"),
+    "viewBox": "0 0 30 24"
+  }, [vue.createVNode("path", {
+    "d": "M26 13h-2v2h2v-2zm-8-3h2V8h-2v2zm2-4h2V4h-2v2zm2 4h4V4h-2v4h-2v2zm-7 14 3-3h-6l3 3zM6 13H4v2h2v-2zm16 0H8v2h14v-2zm-12-3h2V8h-2v2zM28 0l1 1 1 1v15l-1 2H1l-1-2V2l1-1 1-1zm0 2H2v15h26V2zM6 4v2H4V4zm10 2h2V4h-2v2zM8 9v1H4V8zm8 0v1h-2V8zm-6-5v2H8V4zm4 0v2h-2V4z",
+    "fill": "currentColor"
+  }, null)]);
+  const DeleteIcon = vue.createVNode("svg", {
+    "class": bem$s("delete-icon"),
+    "viewBox": "0 0 32 22"
+  }, [vue.createVNode("path", {
+    "d": "M28 0a4 4 0 0 1 4 4v14a4 4 0 0 1-4 4H10.4a2 2 0 0 1-1.4-.6L1 13.1c-.6-.5-.9-1.3-.9-2 0-1 .3-1.7.9-2.2L9 .6a2 2 0 0 1 1.4-.6zm0 2H10.4l-8.2 8.3a1 1 0 0 0-.3.7c0 .3.1.5.3.7l8.2 8.4H28a2 2 0 0 0 2-2V4c0-1.1-.9-2-2-2zm-5 4a1 1 0 0 1 .7.3 1 1 0 0 1 0 1.4L20.4 11l3.3 3.3c.2.2.3.5.3.7 0 .3-.1.5-.3.7a1 1 0 0 1-.7.3 1 1 0 0 1-.7-.3L19 12.4l-3.4 3.3a1 1 0 0 1-.6.3 1 1 0 0 1-.7-.3 1 1 0 0 1-.3-.7c0-.2.1-.5.3-.7l3.3-3.3-3.3-3.3A1 1 0 0 1 14 7c0-.3.1-.5.3-.7A1 1 0 0 1 15 6a1 1 0 0 1 .6.3L19 9.6l3.3-3.3A1 1 0 0 1 23 6z",
+    "fill": "currentColor"
+  }, null)]);
+  var stdin_default$B = vue.defineComponent({
+    name: name$t,
+    props: {
+      type: String,
+      text: numericProp,
+      color: String,
+      wider: Boolean,
+      large: Boolean,
+      loading: Boolean
+    },
+    emits: ["press"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const active = vue.ref(false);
+      const touch = useTouch();
+      const onTouchStart = (event) => {
+        touch.start(event);
+        active.value = true;
+      };
+      const onTouchMove = (event) => {
+        touch.move(event);
+        if (touch.direction.value) {
+          active.value = false;
+        }
+      };
+      const onTouchEnd = (event) => {
+        if (active.value) {
+          if (!slots.default) {
+            preventDefault(event);
+          }
+          active.value = false;
+          emit("press", props.text, props.type);
+        }
+      };
+      const renderContent = () => {
+        if (props.loading) {
+          return vue.createVNode(Loading, {
+            "class": bem$s("loading-icon")
+          }, null);
+        }
+        const text = slots.default ? slots.default() : props.text;
+        switch (props.type) {
+          case "delete":
+            return text || DeleteIcon;
+          case "extra":
+            return text || CollapseIcon;
+          default:
+            return text;
+        }
+      };
+      return () => vue.createVNode("div", {
+        "class": bem$s("wrapper", {
+          wider: props.wider
+        }),
+        "onTouchstartPassive": onTouchStart,
+        "onTouchmovePassive": onTouchMove,
+        "onTouchend": onTouchEnd,
+        "onTouchcancel": onTouchEnd
+      }, [vue.createVNode("div", {
+        "role": "button",
+        "tabindex": 0,
+        "class": bem$s([props.color, {
+          large: props.large,
+          active: active.value,
+          delete: props.type === "delete"
+        }])
+      }, [renderContent()])]);
+    }
+  });
+  const [name$s, bem$r] = createNamespace("number-keyboard");
+  const numberKeyboardProps = {
+    show: Boolean,
+    title: String,
+    theme: makeStringProp("default"),
+    zIndex: numericProp,
+    teleport: [String, Object],
+    maxlength: makeNumericProp(Infinity),
+    modelValue: makeStringProp(""),
+    transition: truthProp,
+    blurOnClose: truthProp,
+    showDeleteKey: truthProp,
+    randomKeyOrder: Boolean,
+    closeButtonText: String,
+    deleteButtonText: String,
+    closeButtonLoading: Boolean,
+    hideOnClickOutside: truthProp,
+    safeAreaInsetBottom: truthProp,
+    extraKey: {
+      type: [String, Array],
+      default: ""
+    }
+  };
+  function shuffle(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      const temp = array[i];
+      array[i] = array[j];
+      array[j] = temp;
+    }
+    return array;
+  }
+  var stdin_default$A = vue.defineComponent({
+    name: name$s,
+    inheritAttrs: false,
+    props: numberKeyboardProps,
+    emits: ["show", "hide", "blur", "input", "close", "delete", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots,
+      attrs
+    }) {
+      const root = vue.ref();
+      const genBasicKeys = () => {
+        const keys2 = Array(9).fill("").map((_, i) => ({
+          text: i + 1
+        }));
+        if (props.randomKeyOrder) {
+          shuffle(keys2);
+        }
+        return keys2;
+      };
+      const genDefaultKeys = () => [...genBasicKeys(), {
+        text: props.extraKey,
+        type: "extra"
+      }, {
+        text: 0
+      }, {
+        text: props.showDeleteKey ? props.deleteButtonText : "",
+        type: props.showDeleteKey ? "delete" : ""
+      }];
+      const genCustomKeys = () => {
+        const keys2 = genBasicKeys();
+        const {
+          extraKey
+        } = props;
+        const extraKeys = Array.isArray(extraKey) ? extraKey : [extraKey];
+        if (extraKeys.length === 1) {
+          keys2.push({
+            text: 0,
+            wider: true
+          }, {
+            text: extraKeys[0],
+            type: "extra"
+          });
+        } else if (extraKeys.length === 2) {
+          keys2.push({
+            text: extraKeys[0],
+            type: "extra"
+          }, {
+            text: 0
+          }, {
+            text: extraKeys[1],
+            type: "extra"
+          });
+        }
+        return keys2;
+      };
+      const keys = vue.computed(() => props.theme === "custom" ? genCustomKeys() : genDefaultKeys());
+      const onBlur = () => {
+        if (props.show) {
+          emit("blur");
+        }
+      };
+      const onClose = () => {
+        emit("close");
+        if (props.blurOnClose) {
+          onBlur();
+        }
+      };
+      const onAnimationEnd = () => emit(props.show ? "show" : "hide");
+      const onPress = (text, type) => {
+        if (text === "") {
+          if (type === "extra") {
+            onBlur();
+          }
+          return;
+        }
+        const value = props.modelValue;
+        if (type === "delete") {
+          emit("delete");
+          emit("update:modelValue", value.slice(0, value.length - 1));
+        } else if (type === "close") {
+          onClose();
+        } else if (value.length < +props.maxlength) {
+          emit("input", text);
+          emit("update:modelValue", value + text);
+        }
+      };
+      const renderTitle = () => {
+        const {
+          title,
+          theme,
+          closeButtonText
+        } = props;
+        const leftSlot = slots["title-left"];
+        const showClose = closeButtonText && theme === "default";
+        const showTitle = title || showClose || leftSlot;
+        if (!showTitle) {
+          return;
+        }
+        return vue.createVNode("div", {
+          "class": bem$r("header")
+        }, [leftSlot && vue.createVNode("span", {
+          "class": bem$r("title-left")
+        }, [leftSlot()]), title && vue.createVNode("h2", {
+          "class": bem$r("title")
+        }, [title]), showClose && vue.createVNode("button", {
+          "type": "button",
+          "class": [bem$r("close"), HAPTICS_FEEDBACK],
+          "onClick": onClose
+        }, [closeButtonText])]);
+      };
+      const renderKeys = () => keys.value.map((key) => {
+        const keySlots = {};
+        if (key.type === "delete") {
+          keySlots.default = slots.delete;
+        }
+        if (key.type === "extra") {
+          keySlots.default = slots["extra-key"];
+        }
+        return vue.createVNode(stdin_default$B, {
+          "key": key.text,
+          "text": key.text,
+          "type": key.type,
+          "wider": key.wider,
+          "color": key.color,
+          "onPress": onPress
+        }, keySlots);
+      });
+      const renderSidebar = () => {
+        if (props.theme === "custom") {
+          return vue.createVNode("div", {
+            "class": bem$r("sidebar")
+          }, [props.showDeleteKey && vue.createVNode(stdin_default$B, {
+            "large": true,
+            "text": props.deleteButtonText,
+            "type": "delete",
+            "onPress": onPress
+          }, {
+            delete: slots.delete
+          }), vue.createVNode(stdin_default$B, {
+            "large": true,
+            "text": props.closeButtonText,
+            "type": "close",
+            "color": "blue",
+            "loading": props.closeButtonLoading,
+            "onPress": onPress
+          }, null)]);
+        }
+      };
+      vue.watch(() => props.show, (value) => {
+        if (!props.transition) {
+          emit(value ? "show" : "hide");
+        }
+      });
+      if (props.hideOnClickOutside) {
+        useClickAway(root, onBlur, {
+          eventName: "touchstart"
+        });
+      }
+      return () => {
+        const Title = renderTitle();
+        const Content = vue.createVNode(vue.Transition, {
+          "name": props.transition ? "van-slide-up" : ""
+        }, {
+          default: () => [vue.withDirectives(vue.createVNode("div", vue.mergeProps({
+            "ref": root,
+            "style": getZIndexStyle(props.zIndex),
+            "class": bem$r({
+              unfit: !props.safeAreaInsetBottom,
+              "with-title": !!Title
+            }),
+            "onAnimationend": onAnimationEnd,
+            "onTouchstartPassive": stopPropagation
+          }, attrs), [Title, vue.createVNode("div", {
+            "class": bem$r("body")
+          }, [vue.createVNode("div", {
+            "class": bem$r("keys")
+          }, [renderKeys()]), renderSidebar()])]), [[vue.vShow, props.show]])]
+        });
+        if (props.teleport) {
+          return vue.createVNode(vue.Teleport, {
+            "to": props.teleport
+          }, {
+            default: () => [Content]
+          });
+        }
+        return Content;
+      };
+    }
+  });
+  const NumberKeyboard = withInstall(stdin_default$A);
+  const [name$r, bem$q, t$5] = createNamespace("pagination");
+  const makePage = (number, text, active) => ({
+    number,
+    text,
+    active
+  });
+  const paginationProps = {
+    mode: makeStringProp("multi"),
+    prevText: String,
+    nextText: String,
+    pageCount: makeNumericProp(0),
+    modelValue: makeNumberProp(0),
+    totalItems: makeNumericProp(0),
+    showPageSize: makeNumericProp(5),
+    itemsPerPage: makeNumericProp(10),
+    forceEllipses: Boolean
+  };
+  var stdin_default$z = vue.defineComponent({
+    name: name$r,
+    props: paginationProps,
+    emits: ["change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const count = vue.computed(() => {
+        const {
+          pageCount,
+          totalItems,
+          itemsPerPage
+        } = props;
+        const count2 = +pageCount || Math.ceil(+totalItems / +itemsPerPage);
+        return Math.max(1, count2);
+      });
+      const pages = vue.computed(() => {
+        const items = [];
+        const pageCount = count.value;
+        const showPageSize = +props.showPageSize;
+        const {
+          modelValue,
+          forceEllipses
+        } = props;
+        let startPage = 1;
+        let endPage = pageCount;
+        const isMaxSized = showPageSize < pageCount;
+        if (isMaxSized) {
+          startPage = Math.max(modelValue - Math.floor(showPageSize / 2), 1);
+          endPage = startPage + showPageSize - 1;
+          if (endPage > pageCount) {
+            endPage = pageCount;
+            startPage = endPage - showPageSize + 1;
+          }
+        }
+        for (let number = startPage; number <= endPage; number++) {
+          const page = makePage(number, number, number === modelValue);
+          items.push(page);
+        }
+        if (isMaxSized && showPageSize > 0 && forceEllipses) {
+          if (startPage > 1) {
+            const prevPages = makePage(startPage - 1, "...");
+            items.unshift(prevPages);
+          }
+          if (endPage < pageCount) {
+            const nextPages = makePage(endPage + 1, "...");
+            items.push(nextPages);
+          }
+        }
+        return items;
+      });
+      const updateModelValue = (value, emitChange) => {
+        value = clamp(value, 1, count.value);
+        if (props.modelValue !== value) {
+          emit("update:modelValue", value);
+          if (emitChange) {
+            emit("change", value);
+          }
+        }
+      };
+      vue.watchEffect(() => updateModelValue(props.modelValue));
+      const renderDesc = () => vue.createVNode("li", {
+        "class": bem$q("page-desc")
+      }, [slots.pageDesc ? slots.pageDesc() : `${props.modelValue}/${count.value}`]);
+      const renderPrevButton = () => {
+        const {
+          mode,
+          modelValue
+        } = props;
+        const slot = slots["prev-text"];
+        const disabled = modelValue === 1;
+        return vue.createVNode("li", {
+          "class": [bem$q("item", {
+            disabled,
+            border: mode === "simple",
+            prev: true
+          }), BORDER_SURROUND]
+        }, [vue.createVNode("button", {
+          "type": "button",
+          "disabled": disabled,
+          "onClick": () => updateModelValue(modelValue - 1, true)
+        }, [slot ? slot() : props.prevText || t$5("prev")])]);
+      };
+      const renderNextButton = () => {
+        const {
+          mode,
+          modelValue
+        } = props;
+        const slot = slots["next-text"];
+        const disabled = modelValue === count.value;
+        return vue.createVNode("li", {
+          "class": [bem$q("item", {
+            disabled,
+            border: mode === "simple",
+            next: true
+          }), BORDER_SURROUND]
+        }, [vue.createVNode("button", {
+          "type": "button",
+          "disabled": disabled,
+          "onClick": () => updateModelValue(modelValue + 1, true)
+        }, [slot ? slot() : props.nextText || t$5("next")])]);
+      };
+      const renderPages = () => pages.value.map((page) => vue.createVNode("li", {
+        "class": [bem$q("item", {
+          active: page.active,
+          page: true
+        }), BORDER_SURROUND]
+      }, [vue.createVNode("button", {
+        "type": "button",
+        "aria-current": page.active || void 0,
+        "onClick": () => updateModelValue(page.number, true)
+      }, [slots.page ? slots.page(page) : page.text])]));
+      return () => vue.createVNode("nav", {
+        "role": "navigation",
+        "class": bem$q()
+      }, [vue.createVNode("ul", {
+        "class": bem$q("items")
+      }, [renderPrevButton(), props.mode === "simple" ? renderDesc() : renderPages(), renderNextButton()])]);
+    }
+  });
+  const Pagination = withInstall(stdin_default$z);
+  const [name$q, bem$p] = createNamespace("password-input");
+  const passwordInputProps = {
+    info: String,
+    mask: truthProp,
+    value: makeStringProp(""),
+    gutter: numericProp,
+    length: makeNumericProp(6),
+    focused: Boolean,
+    errorInfo: String
+  };
+  var stdin_default$y = vue.defineComponent({
+    name: name$q,
+    props: passwordInputProps,
+    emits: ["focus"],
+    setup(props, {
+      emit
+    }) {
+      const onTouchStart = (event) => {
+        event.stopPropagation();
+        emit("focus", event);
+      };
+      const renderPoints = () => {
+        const Points = [];
+        const {
+          mask,
+          value,
+          gutter,
+          focused
+        } = props;
+        const length = +props.length;
+        for (let i = 0; i < length; i++) {
+          const char = value[i];
+          const showBorder = i !== 0 && !gutter;
+          const showCursor = focused && i === value.length;
+          let style;
+          if (i !== 0 && gutter) {
+            style = {
+              marginLeft: addUnit(gutter)
+            };
+          }
+          Points.push(vue.createVNode("li", {
+            "class": [{
+              [BORDER_LEFT]: showBorder
+            }, bem$p("item", {
+              focus: showCursor
+            })],
+            "style": style
+          }, [mask ? vue.createVNode("i", {
+            "style": {
+              visibility: char ? "visible" : "hidden"
+            }
+          }, null) : char, showCursor && vue.createVNode("div", {
+            "class": bem$p("cursor")
+          }, null)]));
+        }
+        return Points;
+      };
+      return () => {
+        const info = props.errorInfo || props.info;
+        return vue.createVNode("div", {
+          "class": bem$p()
+        }, [vue.createVNode("ul", {
+          "class": [bem$p("security"), {
+            [BORDER_SURROUND]: !props.gutter
+          }],
+          "onTouchstartPassive": onTouchStart
+        }, [renderPoints()]), info && vue.createVNode("div", {
+          "class": bem$p(props.errorInfo ? "error-info" : "info")
+        }, [info])]);
+      };
+    }
+  });
+  const PasswordInput = withInstall(stdin_default$y);
+  const PickerGroup = withInstall(stdin_default$1s);
+  function getWindow(node) {
+    if (node == null) {
+      return window;
+    }
+    if (node.toString() !== "[object Window]") {
+      var ownerDocument = node.ownerDocument;
+      return ownerDocument ? ownerDocument.defaultView || window : window;
+    }
+    return node;
+  }
+  function isElement(node) {
+    var OwnElement = getWindow(node).Element;
+    return node instanceof OwnElement || node instanceof Element;
+  }
+  function isHTMLElement(node) {
+    var OwnElement = getWindow(node).HTMLElement;
+    return node instanceof OwnElement || node instanceof HTMLElement;
+  }
+  function isShadowRoot(node) {
+    if (typeof ShadowRoot === "undefined") {
+      return false;
+    }
+    var OwnElement = getWindow(node).ShadowRoot;
+    return node instanceof OwnElement || node instanceof ShadowRoot;
+  }
+  var round = Math.round;
+  function getUAString() {
+    var uaData = navigator.userAgentData;
+    if (uaData != null && uaData.brands) {
+      return uaData.brands.map(function(item) {
+        return item.brand + "/" + item.version;
+      }).join(" ");
+    }
+    return navigator.userAgent;
+  }
+  function isLayoutViewport() {
+    return !/^((?!chrome|android).)*safari/i.test(getUAString());
+  }
+  function getBoundingClientRect(element, includeScale, isFixedStrategy) {
+    if (includeScale === void 0) {
+      includeScale = false;
+    }
+    if (isFixedStrategy === void 0) {
+      isFixedStrategy = false;
+    }
+    var clientRect = element.getBoundingClientRect();
+    var scaleX = 1;
+    var scaleY = 1;
+    if (includeScale && isHTMLElement(element)) {
+      scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
+      scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
+    }
+    var _ref = isElement(element) ? getWindow(element) : window, visualViewport = _ref.visualViewport;
+    var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
+    var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
+    var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
+    var width2 = clientRect.width / scaleX;
+    var height2 = clientRect.height / scaleY;
+    return {
+      width: width2,
+      height: height2,
+      top: y,
+      right: x + width2,
+      bottom: y + height2,
+      left: x,
+      x,
+      y
+    };
+  }
+  function getWindowScroll(node) {
+    var win = getWindow(node);
+    var scrollLeft = win.pageXOffset;
+    var scrollTop = win.pageYOffset;
+    return {
+      scrollLeft,
+      scrollTop
+    };
+  }
+  function getHTMLElementScroll(element) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  function getNodeScroll(node) {
+    if (node === getWindow(node) || !isHTMLElement(node)) {
+      return getWindowScroll(node);
+    } else {
+      return getHTMLElementScroll(node);
+    }
+  }
+  function getNodeName(element) {
+    return element ? (element.nodeName || "").toLowerCase() : null;
+  }
+  function getDocumentElement(element) {
+    return ((isElement(element) ? element.ownerDocument : (
+      // $FlowFixMe[prop-missing]
+      element.document
+    )) || window.document).documentElement;
+  }
+  function getWindowScrollBarX(element) {
+    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
+  }
+  function getComputedStyle(element) {
+    return getWindow(element).getComputedStyle(element);
+  }
+  function isScrollParent(element) {
+    var _getComputedStyle = getComputedStyle(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
+    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+  }
+  function isElementScaled(element) {
+    var rect = element.getBoundingClientRect();
+    var scaleX = round(rect.width) / element.offsetWidth || 1;
+    var scaleY = round(rect.height) / element.offsetHeight || 1;
+    return scaleX !== 1 || scaleY !== 1;
+  }
+  function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
+    if (isFixed === void 0) {
+      isFixed = false;
+    }
+    var isOffsetParentAnElement = isHTMLElement(offsetParent);
+    var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
+    var documentElement = getDocumentElement(offsetParent);
+    var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
+    var scroll = {
+      scrollLeft: 0,
+      scrollTop: 0
+    };
+    var offsets = {
+      x: 0,
+      y: 0
+    };
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+      if (getNodeName(offsetParent) !== "body" || // https://github.com/popperjs/popper-core/issues/1078
+      isScrollParent(documentElement)) {
+        scroll = getNodeScroll(offsetParent);
+      }
+      if (isHTMLElement(offsetParent)) {
+        offsets = getBoundingClientRect(offsetParent, true);
+        offsets.x += offsetParent.clientLeft;
+        offsets.y += offsetParent.clientTop;
+      } else if (documentElement) {
+        offsets.x = getWindowScrollBarX(documentElement);
+      }
+    }
+    return {
+      x: rect.left + scroll.scrollLeft - offsets.x,
+      y: rect.top + scroll.scrollTop - offsets.y,
+      width: rect.width,
+      height: rect.height
+    };
+  }
+  function getLayoutRect(element) {
+    var clientRect = getBoundingClientRect(element);
+    var width2 = element.offsetWidth;
+    var height2 = element.offsetHeight;
+    if (Math.abs(clientRect.width - width2) <= 1) {
+      width2 = clientRect.width;
+    }
+    if (Math.abs(clientRect.height - height2) <= 1) {
+      height2 = clientRect.height;
+    }
+    return {
+      x: element.offsetLeft,
+      y: element.offsetTop,
+      width: width2,
+      height: height2
+    };
+  }
+  function getParentNode(element) {
+    if (getNodeName(element) === "html") {
+      return element;
+    }
+    return (
+      // this is a quicker (but less type safe) way to save quite some bytes from the bundle
+      // $FlowFixMe[incompatible-return]
+      // $FlowFixMe[prop-missing]
+      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
+      element.parentNode || // DOM Element detected
+      (isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
+      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
+      getDocumentElement(element)
+    );
+  }
+  function getScrollParent(node) {
+    if (["html", "body", "#document"].indexOf(getNodeName(node)) >= 0) {
+      return node.ownerDocument.body;
+    }
+    if (isHTMLElement(node) && isScrollParent(node)) {
+      return node;
+    }
+    return getScrollParent(getParentNode(node));
+  }
+  function listScrollParents(element, list) {
+    var _element$ownerDocumen;
+    if (list === void 0) {
+      list = [];
+    }
+    var scrollParent = getScrollParent(element);
+    var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
+    var win = getWindow(scrollParent);
+    var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
+    var updatedList = list.concat(target);
+    return isBody ? updatedList : (
+      // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
+      updatedList.concat(listScrollParents(getParentNode(target)))
+    );
+  }
+  function isTableElement(element) {
+    return ["table", "td", "th"].indexOf(getNodeName(element)) >= 0;
+  }
+  function getTrueOffsetParent(element) {
+    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
+    getComputedStyle(element).position === "fixed") {
+      return null;
+    }
+    return element.offsetParent;
+  }
+  function getContainingBlock(element) {
+    var isFirefox = /firefox/i.test(getUAString());
+    var isIE = /Trident/i.test(getUAString());
+    if (isIE && isHTMLElement(element)) {
+      var elementCss = getComputedStyle(element);
+      if (elementCss.position === "fixed") {
+        return null;
+      }
+    }
+    var currentNode = getParentNode(element);
+    if (isShadowRoot(currentNode)) {
+      currentNode = currentNode.host;
+    }
+    while (isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0) {
+      var css = getComputedStyle(currentNode);
+      if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") {
+        return currentNode;
+      } else {
+        currentNode = currentNode.parentNode;
+      }
+    }
+    return null;
+  }
+  function getOffsetParent(element) {
+    var window2 = getWindow(element);
+    var offsetParent = getTrueOffsetParent(element);
+    while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") {
+      offsetParent = getTrueOffsetParent(offsetParent);
+    }
+    if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static")) {
+      return window2;
+    }
+    return offsetParent || getContainingBlock(element) || window2;
+  }
+  var top = "top";
+  var bottom = "bottom";
+  var right = "right";
+  var left = "left";
+  var auto = "auto";
+  var basePlacements = [top, bottom, right, left];
+  var start = "start";
+  var end = "end";
+  var placements = /* @__PURE__ */ [].concat(basePlacements, [auto]).reduce(function(acc, placement) {
+    return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
+  }, []);
+  var beforeRead = "beforeRead";
+  var read = "read";
+  var afterRead = "afterRead";
+  var beforeMain = "beforeMain";
+  var main = "main";
+  var afterMain = "afterMain";
+  var beforeWrite = "beforeWrite";
+  var write = "write";
+  var afterWrite = "afterWrite";
+  var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
+  function order(modifiers) {
+    var map = /* @__PURE__ */ new Map();
+    var visited = /* @__PURE__ */ new Set();
+    var result = [];
+    modifiers.forEach(function(modifier) {
+      map.set(modifier.name, modifier);
+    });
+    function sort(modifier) {
+      visited.add(modifier.name);
+      var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
+      requires.forEach(function(dep) {
+        if (!visited.has(dep)) {
+          var depModifier = map.get(dep);
+          if (depModifier) {
+            sort(depModifier);
+          }
+        }
+      });
+      result.push(modifier);
+    }
+    modifiers.forEach(function(modifier) {
+      if (!visited.has(modifier.name)) {
+        sort(modifier);
+      }
+    });
+    return result;
+  }
+  function orderModifiers(modifiers) {
+    var orderedModifiers = order(modifiers);
+    return modifierPhases.reduce(function(acc, phase) {
+      return acc.concat(orderedModifiers.filter(function(modifier) {
+        return modifier.phase === phase;
+      }));
+    }, []);
+  }
+  function debounce(fn2) {
+    var pending;
+    return function() {
+      if (!pending) {
+        pending = new Promise(function(resolve) {
+          Promise.resolve().then(function() {
+            pending = void 0;
+            resolve(fn2());
+          });
+        });
+      }
+      return pending;
+    };
+  }
+  function format(str) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    return [].concat(args).reduce(function(p, c) {
+      return p.replace(/%s/, c);
+    }, str);
+  }
+  var INVALID_MODIFIER_ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s';
+  var MISSING_DEPENDENCY_ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available';
+  var VALID_PROPERTIES = ["name", "enabled", "phase", "fn", "effect", "requires", "options"];
+  function validateModifiers(modifiers) {
+    modifiers.forEach(function(modifier) {
+      [].concat(Object.keys(modifier), VALID_PROPERTIES).filter(function(value, index, self2) {
+        return self2.indexOf(value) === index;
+      }).forEach(function(key) {
+        switch (key) {
+          case "name":
+            if (typeof modifier.name !== "string") {
+              console.error(format(INVALID_MODIFIER_ERROR, String(modifier.name), '"name"', '"string"', '"' + String(modifier.name) + '"'));
+            }
+            break;
+          case "enabled":
+            if (typeof modifier.enabled !== "boolean") {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', '"' + String(modifier.enabled) + '"'));
+            }
+            break;
+          case "phase":
+            if (modifierPhases.indexOf(modifier.phase) < 0) {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"phase"', "either " + modifierPhases.join(", "), '"' + String(modifier.phase) + '"'));
+            }
+            break;
+          case "fn":
+            if (typeof modifier.fn !== "function") {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', '"' + String(modifier.fn) + '"'));
+            }
+            break;
+          case "effect":
+            if (modifier.effect != null && typeof modifier.effect !== "function") {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"effect"', '"function"', '"' + String(modifier.fn) + '"'));
+            }
+            break;
+          case "requires":
+            if (modifier.requires != null && !Array.isArray(modifier.requires)) {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requires"', '"array"', '"' + String(modifier.requires) + '"'));
+            }
+            break;
+          case "requiresIfExists":
+            if (!Array.isArray(modifier.requiresIfExists)) {
+              console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requiresIfExists"', '"array"', '"' + String(modifier.requiresIfExists) + '"'));
+            }
+            break;
+          case "options":
+          case "data":
+            break;
+          default:
+            console.error('PopperJS: an invalid property has been provided to the "' + modifier.name + '" modifier, valid properties are ' + VALID_PROPERTIES.map(function(s) {
+              return '"' + s + '"';
+            }).join(", ") + '; but "' + key + '" was provided.');
+        }
+        modifier.requires && modifier.requires.forEach(function(requirement) {
+          if (modifiers.find(function(mod) {
+            return mod.name === requirement;
+          }) == null) {
+            console.error(format(MISSING_DEPENDENCY_ERROR, String(modifier.name), requirement, requirement));
+          }
+        });
+      });
+    });
+  }
+  function uniqueBy(arr, fn2) {
+    var identifiers = /* @__PURE__ */ new Set();
+    return arr.filter(function(item) {
+      var identifier = fn2(item);
+      if (!identifiers.has(identifier)) {
+        identifiers.add(identifier);
+        return true;
+      }
+    });
+  }
+  function getBasePlacement(placement) {
+    return placement.split("-")[0];
+  }
+  function mergeByName(modifiers) {
+    var merged = modifiers.reduce(function(merged2, current2) {
+      var existing = merged2[current2.name];
+      merged2[current2.name] = existing ? Object.assign({}, existing, current2, {
+        options: Object.assign({}, existing.options, current2.options),
+        data: Object.assign({}, existing.data, current2.data)
+      }) : current2;
+      return merged2;
+    }, {});
+    return Object.keys(merged).map(function(key) {
+      return merged[key];
+    });
+  }
+  function getVariation(placement) {
+    return placement.split("-")[1];
+  }
+  function getMainAxisFromPlacement(placement) {
+    return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
+  }
+  function computeOffsets(_ref) {
+    var reference = _ref.reference, element = _ref.element, placement = _ref.placement;
+    var basePlacement = placement ? getBasePlacement(placement) : null;
+    var variation = placement ? getVariation(placement) : null;
+    var commonX = reference.x + reference.width / 2 - element.width / 2;
+    var commonY = reference.y + reference.height / 2 - element.height / 2;
+    var offsets;
+    switch (basePlacement) {
+      case top:
+        offsets = {
+          x: commonX,
+          y: reference.y - element.height
+        };
+        break;
+      case bottom:
+        offsets = {
+          x: commonX,
+          y: reference.y + reference.height
+        };
+        break;
+      case right:
+        offsets = {
+          x: reference.x + reference.width,
+          y: commonY
+        };
+        break;
+      case left:
+        offsets = {
+          x: reference.x - element.width,
+          y: commonY
+        };
+        break;
+      default:
+        offsets = {
+          x: reference.x,
+          y: reference.y
+        };
+    }
+    var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
+    if (mainAxis != null) {
+      var len = mainAxis === "y" ? "height" : "width";
+      switch (variation) {
+        case start:
+          offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
+          break;
+        case end:
+          offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
+          break;
+      }
+    }
+    return offsets;
+  }
+  var INVALID_ELEMENT_ERROR = "Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.";
+  var INFINITE_LOOP_ERROR = "Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.";
+  var DEFAULT_OPTIONS = {
+    placement: "bottom",
+    modifiers: [],
+    strategy: "absolute"
+  };
+  function areValidElements() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return !args.some(function(element) {
+      return !(element && typeof element.getBoundingClientRect === "function");
+    });
+  }
+  function popperGenerator(generatorOptions) {
+    if (generatorOptions === void 0) {
+      generatorOptions = {};
+    }
+    var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers2 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions2 = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
+    return function createPopper2(reference, popper, options) {
+      if (options === void 0) {
+        options = defaultOptions2;
+      }
+      var state = {
+        placement: "bottom",
+        orderedModifiers: [],
+        options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions2),
+        modifiersData: {},
+        elements: {
+          reference,
+          popper
+        },
+        attributes: {},
+        styles: {}
+      };
+      var effectCleanupFns = [];
+      var isDestroyed = false;
+      var instance2 = {
+        state,
+        setOptions: function setOptions(setOptionsAction) {
+          var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
+          cleanupModifierEffects();
+          state.options = Object.assign({}, defaultOptions2, state.options, options2);
+          state.scrollParents = {
+            reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
+            popper: listScrollParents(popper)
+          };
+          var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state.options.modifiers)));
+          state.orderedModifiers = orderedModifiers.filter(function(m) {
+            return m.enabled;
+          });
+          {
+            var modifiers = uniqueBy([].concat(orderedModifiers, state.options.modifiers), function(_ref) {
+              var name2 = _ref.name;
+              return name2;
+            });
+            validateModifiers(modifiers);
+            if (getBasePlacement(state.options.placement) === auto) {
+              var flipModifier = state.orderedModifiers.find(function(_ref2) {
+                var name2 = _ref2.name;
+                return name2 === "flip";
+              });
+              if (!flipModifier) {
+                console.error(['Popper: "auto" placements require the "flip" modifier be', "present and enabled to work."].join(" "));
+              }
+            }
+            var _getComputedStyle = getComputedStyle(popper), marginTop = _getComputedStyle.marginTop, marginRight = _getComputedStyle.marginRight, marginBottom = _getComputedStyle.marginBottom, marginLeft = _getComputedStyle.marginLeft;
+            if ([marginTop, marginRight, marginBottom, marginLeft].some(function(margin) {
+              return parseFloat(margin);
+            })) {
+              console.warn(['Popper: CSS "margin" styles cannot be used to apply padding', "between the popper and its reference element or boundary.", "To replicate margin, use the `offset` modifier, as well as", "the `padding` option in the `preventOverflow` and `flip`", "modifiers."].join(" "));
+            }
+          }
+          runModifierEffects();
+          return instance2.update();
+        },
+        // Sync update – it will always be executed, even if not necessary. This
+        // is useful for low frequency updates where sync behavior simplifies the
+        // logic.
+        // For high frequency updates (e.g. `resize` and `scroll` events), always
+        // prefer the async Popper#update method
+        forceUpdate: function forceUpdate() {
+          if (isDestroyed) {
+            return;
+          }
+          var _state$elements = state.elements, reference2 = _state$elements.reference, popper2 = _state$elements.popper;
+          if (!areValidElements(reference2, popper2)) {
+            {
+              console.error(INVALID_ELEMENT_ERROR);
+            }
+            return;
+          }
+          state.rects = {
+            reference: getCompositeRect(reference2, getOffsetParent(popper2), state.options.strategy === "fixed"),
+            popper: getLayoutRect(popper2)
+          };
+          state.reset = false;
+          state.placement = state.options.placement;
+          state.orderedModifiers.forEach(function(modifier) {
+            return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
+          });
+          var __debug_loops__ = 0;
+          for (var index = 0; index < state.orderedModifiers.length; index++) {
+            {
+              __debug_loops__ += 1;
+              if (__debug_loops__ > 100) {
+                console.error(INFINITE_LOOP_ERROR);
+                break;
+              }
+            }
+            if (state.reset === true) {
+              state.reset = false;
+              index = -1;
+              continue;
+            }
+            var _state$orderedModifie = state.orderedModifiers[index], fn2 = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name2 = _state$orderedModifie.name;
+            if (typeof fn2 === "function") {
+              state = fn2({
+                state,
+                options: _options,
+                name: name2,
+                instance: instance2
+              }) || state;
+            }
+          }
+        },
+        // Async and optimistically optimized update – it will not be executed if
+        // not necessary (debounced to run at most once-per-tick)
+        update: debounce(function() {
+          return new Promise(function(resolve) {
+            instance2.forceUpdate();
+            resolve(state);
+          });
+        }),
+        destroy: function destroy() {
+          cleanupModifierEffects();
+          isDestroyed = true;
+        }
+      };
+      if (!areValidElements(reference, popper)) {
+        {
+          console.error(INVALID_ELEMENT_ERROR);
+        }
+        return instance2;
+      }
+      instance2.setOptions(options).then(function(state2) {
+        if (!isDestroyed && options.onFirstUpdate) {
+          options.onFirstUpdate(state2);
+        }
+      });
+      function runModifierEffects() {
+        state.orderedModifiers.forEach(function(_ref3) {
+          var name2 = _ref3.name, _ref3$options = _ref3.options, options2 = _ref3$options === void 0 ? {} : _ref3$options, effect3 = _ref3.effect;
+          if (typeof effect3 === "function") {
+            var cleanupFn = effect3({
+              state,
+              name: name2,
+              instance: instance2,
+              options: options2
+            });
+            var noopFn = function noopFn2() {
+            };
+            effectCleanupFns.push(cleanupFn || noopFn);
+          }
+        });
+      }
+      function cleanupModifierEffects() {
+        effectCleanupFns.forEach(function(fn2) {
+          return fn2();
+        });
+        effectCleanupFns = [];
+      }
+      return instance2;
+    };
+  }
+  var passive = {
+    passive: true
+  };
+  function effect(_ref) {
+    var state = _ref.state, instance2 = _ref.instance, options = _ref.options;
+    var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize;
+    var window2 = getWindow(state.elements.popper);
+    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
+    if (scroll) {
+      scrollParents.forEach(function(scrollParent) {
+        scrollParent.addEventListener("scroll", instance2.update, passive);
+      });
+    }
+    if (resize) {
+      window2.addEventListener("resize", instance2.update, passive);
+    }
+    return function() {
+      if (scroll) {
+        scrollParents.forEach(function(scrollParent) {
+          scrollParent.removeEventListener("scroll", instance2.update, passive);
+        });
+      }
+      if (resize) {
+        window2.removeEventListener("resize", instance2.update, passive);
+      }
+    };
+  }
+  var eventListeners_default = {
+    name: "eventListeners",
+    enabled: true,
+    phase: "write",
+    fn: function fn() {
+    },
+    effect,
+    data: {}
+  };
+  function popperOffsets(_ref) {
+    var state = _ref.state, name2 = _ref.name;
+    state.modifiersData[name2] = computeOffsets({
+      reference: state.rects.reference,
+      element: state.rects.popper,
+      strategy: "absolute",
+      placement: state.placement
+    });
+  }
+  var popperOffsets_default = {
+    name: "popperOffsets",
+    enabled: true,
+    phase: "read",
+    fn: popperOffsets,
+    data: {}
+  };
+  var unsetSides = {
+    top: "auto",
+    right: "auto",
+    bottom: "auto",
+    left: "auto"
+  };
+  function roundOffsetsByDPR(_ref) {
+    var x = _ref.x, y = _ref.y;
+    var win = window;
+    var dpr = win.devicePixelRatio || 1;
+    return {
+      x: round(x * dpr) / dpr || 0,
+      y: round(y * dpr) / dpr || 0
+    };
+  }
+  function mapToStyles(_ref2) {
+    var _Object$assign2;
+    var popper = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
+    var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y;
+    var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
+      x,
+      y
+    }) : {
+      x,
+      y
+    };
+    x = _ref3.x;
+    y = _ref3.y;
+    var hasX = offsets.hasOwnProperty("x");
+    var hasY = offsets.hasOwnProperty("y");
+    var sideX = left;
+    var sideY = top;
+    var win = window;
+    if (adaptive) {
+      var offsetParent = getOffsetParent(popper);
+      var heightProp = "clientHeight";
+      var widthProp = "clientWidth";
+      if (offsetParent === getWindow(popper)) {
+        offsetParent = getDocumentElement(popper);
+        if (getComputedStyle(offsetParent).position !== "static" && position === "absolute") {
+          heightProp = "scrollHeight";
+          widthProp = "scrollWidth";
+        }
+      }
+      offsetParent = offsetParent;
+      if (placement === top || (placement === left || placement === right) && variation === end) {
+        sideY = bottom;
+        var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : (
+          // $FlowFixMe[prop-missing]
+          offsetParent[heightProp]
+        );
+        y -= offsetY - popperRect.height;
+        y *= gpuAcceleration ? 1 : -1;
+      }
+      if (placement === left || (placement === top || placement === bottom) && variation === end) {
+        sideX = right;
+        var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : (
+          // $FlowFixMe[prop-missing]
+          offsetParent[widthProp]
+        );
+        x -= offsetX - popperRect.width;
+        x *= gpuAcceleration ? 1 : -1;
+      }
+    }
+    var commonStyles = Object.assign({
+      position
+    }, adaptive && unsetSides);
+    var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
+      x,
+      y
+    }) : {
+      x,
+      y
+    };
+    x = _ref4.x;
+    y = _ref4.y;
+    if (gpuAcceleration) {
+      var _Object$assign;
+      return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
+    }
+    return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : "", _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2));
+  }
+  function computeStyles(_ref5) {
+    var state = _ref5.state, options = _ref5.options;
+    var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
+    {
+      var transitionProperty = getComputedStyle(state.elements.popper).transitionProperty || "";
+      if (adaptive && ["transform", "top", "right", "bottom", "left"].some(function(property) {
+        return transitionProperty.indexOf(property) >= 0;
+      })) {
+        console.warn(["Popper: Detected CSS transitions on at least one of the following", 'CSS properties: "transform", "top", "right", "bottom", "left".', "\n\n", 'Disable the "computeStyles" modifier\'s `adaptive` option to allow', "for smooth transitions, or remove these properties from the CSS", "transition declaration on the popper element if only transitioning", "opacity or background-color for example.", "\n\n", "We recommend using the popper element as a wrapper around an inner", "element that can have any CSS property transitioned for animations."].join(" "));
+      }
+    }
+    var commonStyles = {
+      placement: getBasePlacement(state.placement),
+      variation: getVariation(state.placement),
+      popper: state.elements.popper,
+      popperRect: state.rects.popper,
+      gpuAcceleration,
+      isFixed: state.options.strategy === "fixed"
+    };
+    if (state.modifiersData.popperOffsets != null) {
+      state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
+        offsets: state.modifiersData.popperOffsets,
+        position: state.options.strategy,
+        adaptive,
+        roundOffsets
+      })));
+    }
+    if (state.modifiersData.arrow != null) {
+      state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
+        offsets: state.modifiersData.arrow,
+        position: "absolute",
+        adaptive: false,
+        roundOffsets
+      })));
+    }
+    state.attributes.popper = Object.assign({}, state.attributes.popper, {
+      "data-popper-placement": state.placement
+    });
+  }
+  var computeStyles_default = {
+    name: "computeStyles",
+    enabled: true,
+    phase: "beforeWrite",
+    fn: computeStyles,
+    data: {}
+  };
+  function applyStyles(_ref) {
+    var state = _ref.state;
+    Object.keys(state.elements).forEach(function(name2) {
+      var style = state.styles[name2] || {};
+      var attributes = state.attributes[name2] || {};
+      var element = state.elements[name2];
+      if (!isHTMLElement(element) || !getNodeName(element)) {
+        return;
+      }
+      Object.assign(element.style, style);
+      Object.keys(attributes).forEach(function(name22) {
+        var value = attributes[name22];
+        if (value === false) {
+          element.removeAttribute(name22);
+        } else {
+          element.setAttribute(name22, value === true ? "" : value);
+        }
+      });
+    });
+  }
+  function effect2(_ref2) {
+    var state = _ref2.state;
+    var initialStyles = {
+      popper: {
+        position: state.options.strategy,
+        left: "0",
+        top: "0",
+        margin: "0"
+      },
+      arrow: {
+        position: "absolute"
+      },
+      reference: {}
+    };
+    Object.assign(state.elements.popper.style, initialStyles.popper);
+    state.styles = initialStyles;
+    if (state.elements.arrow) {
+      Object.assign(state.elements.arrow.style, initialStyles.arrow);
+    }
+    return function() {
+      Object.keys(state.elements).forEach(function(name2) {
+        var element = state.elements[name2];
+        var attributes = state.attributes[name2] || {};
+        var styleProperties = Object.keys(state.styles.hasOwnProperty(name2) ? state.styles[name2] : initialStyles[name2]);
+        var style = styleProperties.reduce(function(style2, property) {
+          style2[property] = "";
+          return style2;
+        }, {});
+        if (!isHTMLElement(element) || !getNodeName(element)) {
+          return;
+        }
+        Object.assign(element.style, style);
+        Object.keys(attributes).forEach(function(attribute) {
+          element.removeAttribute(attribute);
+        });
+      });
+    };
+  }
+  var applyStyles_default = {
+    name: "applyStyles",
+    enabled: true,
+    phase: "write",
+    fn: applyStyles,
+    effect: effect2,
+    requires: ["computeStyles"]
+  };
+  var defaultModifiers = [eventListeners_default, popperOffsets_default, computeStyles_default, applyStyles_default];
+  var createPopper = /* @__PURE__ */ popperGenerator({
+    defaultModifiers
+  });
+  function distanceAndSkiddingToXY(placement, rects, offset2) {
+    var basePlacement = getBasePlacement(placement);
+    var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
+    var _ref = typeof offset2 === "function" ? offset2(Object.assign({}, rects, {
+      placement
+    })) : offset2, skidding = _ref[0], distance = _ref[1];
+    skidding = skidding || 0;
+    distance = (distance || 0) * invertDistance;
+    return [left, right].indexOf(basePlacement) >= 0 ? {
+      x: distance,
+      y: skidding
+    } : {
+      x: skidding,
+      y: distance
+    };
+  }
+  function offset(_ref2) {
+    var state = _ref2.state, options = _ref2.options, name2 = _ref2.name;
+    var _options$offset = options.offset, offset2 = _options$offset === void 0 ? [0, 0] : _options$offset;
+    var data = placements.reduce(function(acc, placement) {
+      acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset2);
+      return acc;
+    }, {});
+    var _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y;
+    if (state.modifiersData.popperOffsets != null) {
+      state.modifiersData.popperOffsets.x += x;
+      state.modifiersData.popperOffsets.y += y;
+    }
+    state.modifiersData[name2] = data;
+  }
+  var offset_default = {
+    name: "offset",
+    enabled: true,
+    phase: "main",
+    requires: ["popperOffsets"],
+    fn: offset
+  };
+  const useSyncPropRef = (getProp, setProp) => {
+    const propRef = vue.ref(getProp());
+    vue.watch(getProp, (value) => {
+      if (value !== propRef.value) {
+        propRef.value = value;
+      }
+    });
+    vue.watch(propRef, (value) => {
+      if (value !== getProp()) {
+        setProp(value);
+      }
+    });
+    return propRef;
+  };
+  const [name$p, bem$o] = createNamespace("popover");
+  const popupProps = ["overlay", "duration", "teleport", "overlayStyle", "overlayClass", "closeOnClickOverlay"];
+  const popoverProps = {
+    show: Boolean,
+    theme: makeStringProp("light"),
+    overlay: Boolean,
+    actions: makeArrayProp(),
+    trigger: makeStringProp("click"),
+    duration: numericProp,
+    showArrow: truthProp,
+    placement: makeStringProp("bottom"),
+    iconPrefix: String,
+    overlayClass: unknownProp,
+    overlayStyle: Object,
+    closeOnClickAction: truthProp,
+    closeOnClickOverlay: truthProp,
+    closeOnClickOutside: truthProp,
+    offset: {
+      type: Array,
+      default: () => [0, 8]
+    },
+    teleport: {
+      type: [String, Object],
+      default: "body"
+    }
+  };
+  var stdin_default$x = vue.defineComponent({
+    name: name$p,
+    props: popoverProps,
+    emits: ["select", "touchstart", "update:show"],
+    setup(props, {
+      emit,
+      slots,
+      attrs
+    }) {
+      let popper;
+      const popupRef = vue.ref();
+      const wrapperRef = vue.ref();
+      const popoverRef = vue.ref();
+      const show = useSyncPropRef(() => props.show, (value) => emit("update:show", value));
+      const getPopoverOptions = () => ({
+        placement: props.placement,
+        modifiers: [{
+          name: "computeStyles",
+          options: {
+            adaptive: false,
+            gpuAcceleration: false
+          }
+        }, extend({}, offset_default, {
+          options: {
+            offset: props.offset
+          }
+        })]
+      });
+      const createPopperInstance = () => {
+        if (wrapperRef.value && popoverRef.value) {
+          return createPopper(wrapperRef.value, popoverRef.value.popupRef.value, getPopoverOptions());
+        }
+        return null;
+      };
+      const updateLocation = () => {
+        vue.nextTick(() => {
+          if (!show.value) {
+            return;
+          }
+          if (!popper) {
+            popper = createPopperInstance();
+            if (inBrowser$1) {
+              window.addEventListener("animationend", updateLocation);
+              window.addEventListener("transitionend", updateLocation);
+            }
+          } else {
+            popper.setOptions(getPopoverOptions());
+          }
+        });
+      };
+      const updateShow = (value) => {
+        show.value = value;
+      };
+      const onClickWrapper = () => {
+        if (props.trigger === "click") {
+          show.value = !show.value;
+        }
+      };
+      const onClickAction = (action, index) => {
+        if (action.disabled) {
+          return;
+        }
+        emit("select", action, index);
+        if (props.closeOnClickAction) {
+          show.value = false;
+        }
+      };
+      const onClickAway = () => {
+        if (show.value && props.closeOnClickOutside && (!props.overlay || props.closeOnClickOverlay)) {
+          show.value = false;
+        }
+      };
+      const renderActionContent = (action, index) => {
+        if (slots.action) {
+          return slots.action({
+            action,
+            index
+          });
+        }
+        return [action.icon && vue.createVNode(Icon, {
+          "name": action.icon,
+          "classPrefix": props.iconPrefix,
+          "class": bem$o("action-icon")
+        }, null), vue.createVNode("div", {
+          "class": [bem$o("action-text"), BORDER_BOTTOM]
+        }, [action.text])];
+      };
+      const renderAction = (action, index) => {
+        const {
+          icon,
+          color,
+          disabled,
+          className
+        } = action;
+        return vue.createVNode("div", {
+          "role": "menuitem",
+          "class": [bem$o("action", {
+            disabled,
+            "with-icon": icon
+          }), className],
+          "style": {
+            color
+          },
+          "tabindex": disabled ? void 0 : 0,
+          "aria-disabled": disabled || void 0,
+          "onClick": () => onClickAction(action, index)
+        }, [renderActionContent(action, index)]);
+      };
+      vue.onMounted(() => {
+        updateLocation();
+        vue.watchEffect(() => {
+          var _a;
+          popupRef.value = (_a = popoverRef.value) == null ? void 0 : _a.popupRef.value;
+        });
+      });
+      vue.onBeforeUnmount(() => {
+        if (popper) {
+          if (inBrowser$1) {
+            window.removeEventListener("animationend", updateLocation);
+            window.removeEventListener("transitionend", updateLocation);
+          }
+          popper.destroy();
+          popper = null;
+        }
+      });
+      vue.watch(() => [show.value, props.offset, props.placement], updateLocation);
+      useClickAway([wrapperRef, popupRef], onClickAway, {
+        eventName: "touchstart"
+      });
+      return () => {
+        var _a;
+        return vue.createVNode(vue.Fragment, null, [vue.createVNode("span", {
+          "ref": wrapperRef,
+          "class": bem$o("wrapper"),
+          "onClick": onClickWrapper
+        }, [(_a = slots.reference) == null ? void 0 : _a.call(slots)]), vue.createVNode(Popup, vue.mergeProps({
+          "ref": popoverRef,
+          "show": show.value,
+          "class": bem$o([props.theme]),
+          "position": "",
+          "transition": "van-popover-zoom",
+          "lockScroll": false,
+          "onUpdate:show": updateShow
+        }, attrs, pick(props, popupProps)), {
+          default: () => [props.showArrow && vue.createVNode("div", {
+            "class": bem$o("arrow")
+          }, null), vue.createVNode("div", {
+            "role": "menu",
+            "class": bem$o("content")
+          }, [slots.default ? slots.default() : props.actions.map(renderAction)])]
+        })]);
+      };
+    }
+  });
+  const Popover = withInstall(stdin_default$x);
+  const [name$o, bem$n] = createNamespace("progress");
+  const progressProps = {
+    color: String,
+    inactive: Boolean,
+    pivotText: String,
+    textColor: String,
+    showPivot: truthProp,
+    pivotColor: String,
+    trackColor: String,
+    strokeWidth: numericProp,
+    percentage: {
+      type: numericProp,
+      default: 0,
+      validator: (value) => +value >= 0 && +value <= 100
+    }
+  };
+  var stdin_default$w = vue.defineComponent({
+    name: name$o,
+    props: progressProps,
+    setup(props) {
+      const background = vue.computed(() => props.inactive ? void 0 : props.color);
+      const renderPivot = () => {
+        const {
+          textColor,
+          pivotText,
+          pivotColor,
+          percentage
+        } = props;
+        const text = pivotText != null ? pivotText : `${percentage}%`;
+        if (props.showPivot && text) {
+          const style = {
+            color: textColor,
+            left: `${+percentage}%`,
+            transform: `translate(-${+percentage}%,-50%)`,
+            background: pivotColor || background.value
+          };
+          return vue.createVNode("span", {
+            "style": style,
+            "class": bem$n("pivot", {
+              inactive: props.inactive
+            })
+          }, [text]);
+        }
+      };
+      return () => {
+        const {
+          trackColor,
+          percentage,
+          strokeWidth
+        } = props;
+        const rootStyle = {
+          background: trackColor,
+          height: addUnit(strokeWidth)
+        };
+        const portionStyle = {
+          width: `${percentage}%`,
+          background: background.value
+        };
+        return vue.createVNode("div", {
+          "class": bem$n(),
+          "style": rootStyle
+        }, [vue.createVNode("span", {
+          "class": bem$n("portion", {
+            inactive: props.inactive
+          }),
+          "style": portionStyle
+        }, null), renderPivot()]);
+      };
+    }
+  });
+  const Progress = withInstall(stdin_default$w);
+  const [name$n, bem$m, t$4] = createNamespace("pull-refresh");
+  const DEFAULT_HEAD_HEIGHT = 50;
+  const TEXT_STATUS = ["pulling", "loosing", "success"];
+  const pullRefreshProps = {
+    disabled: Boolean,
+    modelValue: Boolean,
+    headHeight: makeNumericProp(DEFAULT_HEAD_HEIGHT),
+    successText: String,
+    pullingText: String,
+    loosingText: String,
+    loadingText: String,
+    pullDistance: numericProp,
+    successDuration: makeNumericProp(500),
+    animationDuration: makeNumericProp(300)
+  };
+  var stdin_default$v = vue.defineComponent({
+    name: name$n,
+    props: pullRefreshProps,
+    emits: ["change", "refresh", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      let reachTop;
+      const root = vue.ref();
+      const track = vue.ref();
+      const scrollParent = useScrollParent(root);
+      const state = vue.reactive({
+        status: "normal",
+        distance: 0,
+        duration: 0
+      });
+      const touch = useTouch();
+      const getHeadStyle = () => {
+        if (props.headHeight !== DEFAULT_HEAD_HEIGHT) {
+          return {
+            height: `${props.headHeight}px`
+          };
+        }
+      };
+      const isTouchable = () => state.status !== "loading" && state.status !== "success" && !props.disabled;
+      const ease = (distance) => {
+        const pullDistance = +(props.pullDistance || props.headHeight);
+        if (distance > pullDistance) {
+          if (distance < pullDistance * 2) {
+            distance = pullDistance + (distance - pullDistance) / 2;
+          } else {
+            distance = pullDistance * 1.5 + (distance - pullDistance * 2) / 4;
+          }
+        }
+        return Math.round(distance);
+      };
+      const setStatus = (distance, isLoading) => {
+        const pullDistance = +(props.pullDistance || props.headHeight);
+        state.distance = distance;
+        if (isLoading) {
+          state.status = "loading";
+        } else if (distance === 0) {
+          state.status = "normal";
+        } else if (distance < pullDistance) {
+          state.status = "pulling";
+        } else {
+          state.status = "loosing";
+        }
+        emit("change", {
+          status: state.status,
+          distance
+        });
+      };
+      const getStatusText = () => {
+        const {
+          status
+        } = state;
+        if (status === "normal") {
+          return "";
+        }
+        return props[`${status}Text`] || t$4(status);
+      };
+      const renderStatus = () => {
+        const {
+          status,
+          distance
+        } = state;
+        if (slots[status]) {
+          return slots[status]({
+            distance
+          });
+        }
+        const nodes = [];
+        if (TEXT_STATUS.includes(status)) {
+          nodes.push(vue.createVNode("div", {
+            "class": bem$m("text")
+          }, [getStatusText()]));
+        }
+        if (status === "loading") {
+          nodes.push(vue.createVNode(Loading, {
+            "class": bem$m("loading")
+          }, {
+            default: getStatusText
+          }));
+        }
+        return nodes;
+      };
+      const showSuccessTip = () => {
+        state.status = "success";
+        setTimeout(() => {
+          setStatus(0);
+        }, +props.successDuration);
+      };
+      const checkPosition = (event) => {
+        reachTop = getScrollTop(scrollParent.value) === 0;
+        if (reachTop) {
+          state.duration = 0;
+          touch.start(event);
+        }
+      };
+      const onTouchStart = (event) => {
+        if (isTouchable()) {
+          checkPosition(event);
+        }
+      };
+      const onTouchMove = (event) => {
+        if (isTouchable()) {
+          if (!reachTop) {
+            checkPosition(event);
+          }
+          const {
+            deltaY
+          } = touch;
+          touch.move(event);
+          if (reachTop && deltaY.value >= 0 && touch.isVertical()) {
+            preventDefault(event);
+            setStatus(ease(deltaY.value));
+          }
+        }
+      };
+      const onTouchEnd = () => {
+        if (reachTop && touch.deltaY.value && isTouchable()) {
+          state.duration = +props.animationDuration;
+          if (state.status === "loosing") {
+            setStatus(+props.headHeight, true);
+            emit("update:modelValue", true);
+            vue.nextTick(() => emit("refresh"));
+          } else {
+            setStatus(0);
+          }
+        }
+      };
+      vue.watch(() => props.modelValue, (value) => {
+        state.duration = +props.animationDuration;
+        if (value) {
+          setStatus(+props.headHeight, true);
+        } else if (slots.success || props.successText) {
+          showSuccessTip();
+        } else {
+          setStatus(0, false);
+        }
+      });
+      useEventListener("touchmove", onTouchMove, {
+        target: track
+      });
+      return () => {
+        var _a;
+        const trackStyle = {
+          transitionDuration: `${state.duration}ms`,
+          transform: state.distance ? `translate3d(0,${state.distance}px, 0)` : ""
+        };
+        return vue.createVNode("div", {
+          "ref": root,
+          "class": bem$m()
+        }, [vue.createVNode("div", {
+          "ref": track,
+          "class": bem$m("track"),
+          "style": trackStyle,
+          "onTouchstartPassive": onTouchStart,
+          "onTouchend": onTouchEnd,
+          "onTouchcancel": onTouchEnd
+        }, [vue.createVNode("div", {
+          "class": bem$m("head"),
+          "style": getHeadStyle()
+        }, [renderStatus()]), (_a = slots.default) == null ? void 0 : _a.call(slots)])]);
+      };
+    }
+  });
+  const PullRefresh = withInstall(stdin_default$v);
+  const [name$m, bem$l] = createNamespace("rate");
+  function getRateStatus(value, index, allowHalf, readonly) {
+    if (value >= index) {
+      return {
+        status: "full",
+        value: 1
+      };
+    }
+    if (value + 0.5 >= index && allowHalf && !readonly) {
+      return {
+        status: "half",
+        value: 0.5
+      };
+    }
+    if (value + 1 >= index && allowHalf && readonly) {
+      const cardinal = 10 ** 10;
+      return {
+        status: "half",
+        value: Math.round((value - index + 1) * cardinal) / cardinal
+      };
+    }
+    return {
+      status: "void",
+      value: 0
+    };
+  }
+  const rateProps = {
+    size: numericProp,
+    icon: makeStringProp("star"),
+    color: String,
+    count: makeNumericProp(5),
+    gutter: numericProp,
+    readonly: Boolean,
+    disabled: Boolean,
+    voidIcon: makeStringProp("star-o"),
+    allowHalf: Boolean,
+    voidColor: String,
+    touchable: truthProp,
+    iconPrefix: String,
+    modelValue: makeNumberProp(0),
+    disabledColor: String
+  };
+  var stdin_default$u = vue.defineComponent({
+    name: name$m,
+    props: rateProps,
+    emits: ["change", "update:modelValue"],
+    setup(props, {
+      emit
+    }) {
+      const touch = useTouch();
+      const [itemRefs, setItemRefs] = useRefs();
+      const groupRef = vue.ref();
+      const untouchable = () => props.readonly || props.disabled || !props.touchable;
+      const list = vue.computed(() => Array(+props.count).fill("").map((_, i) => getRateStatus(props.modelValue, i + 1, props.allowHalf, props.readonly)));
+      let ranges;
+      let groupRefRect;
+      let minRectTop = Number.MAX_SAFE_INTEGER;
+      let maxRectTop = Number.MIN_SAFE_INTEGER;
+      const updateRanges = () => {
+        groupRefRect = useRect(groupRef);
+        const rects = itemRefs.value.map(useRect);
+        ranges = [];
+        rects.forEach((rect, index) => {
+          minRectTop = Math.min(rect.top, minRectTop);
+          maxRectTop = Math.max(rect.top, maxRectTop);
+          if (props.allowHalf) {
+            ranges.push({
+              score: index + 0.5,
+              left: rect.left,
+              top: rect.top,
+              height: rect.height
+            }, {
+              score: index + 1,
+              left: rect.left + rect.width / 2,
+              top: rect.top,
+              height: rect.height
+            });
+          } else {
+            ranges.push({
+              score: index + 1,
+              left: rect.left,
+              top: rect.top,
+              height: rect.height
+            });
+          }
+        });
+      };
+      const getScoreByPosition = (x, y) => {
+        for (let i = ranges.length - 1; i > 0; i--) {
+          if (y >= groupRefRect.top && y <= groupRefRect.bottom) {
+            if (x > ranges[i].left && y >= ranges[i].top && y <= ranges[i].top + ranges[i].height) {
+              return ranges[i].score;
+            }
+          } else {
+            const curTop = y < groupRefRect.top ? minRectTop : maxRectTop;
+            if (x > ranges[i].left && ranges[i].top === curTop) {
+              return ranges[i].score;
+            }
+          }
+        }
+        return props.allowHalf ? 0.5 : 1;
+      };
+      const select = (index) => {
+        if (!props.disabled && !props.readonly && index !== props.modelValue) {
+          emit("update:modelValue", index);
+          emit("change", index);
+        }
+      };
+      const onTouchStart = (event) => {
+        if (untouchable()) {
+          return;
+        }
+        touch.start(event);
+        updateRanges();
+      };
+      const onTouchMove = (event) => {
+        if (untouchable()) {
+          return;
+        }
+        touch.move(event);
+        if (touch.isHorizontal()) {
+          const {
+            clientX,
+            clientY
+          } = event.touches[0];
+          preventDefault(event);
+          select(getScoreByPosition(clientX, clientY));
+        }
+      };
+      const renderStar = (item, index) => {
+        const {
+          icon,
+          size,
+          color,
+          count,
+          gutter,
+          voidIcon,
+          disabled,
+          voidColor,
+          allowHalf,
+          iconPrefix,
+          disabledColor
+        } = props;
+        const score = index + 1;
+        const isFull = item.status === "full";
+        const isVoid = item.status === "void";
+        const renderHalf = allowHalf && item.value > 0 && item.value < 1;
+        let style;
+        if (gutter && score !== +count) {
+          style = {
+            paddingRight: addUnit(gutter)
+          };
+        }
+        const onClickItem = (event) => {
+          updateRanges();
+          select(allowHalf ? getScoreByPosition(event.clientX, event.clientY) : score);
+        };
+        return vue.createVNode("div", {
+          "key": index,
+          "ref": setItemRefs(index),
+          "role": "radio",
+          "style": style,
+          "class": bem$l("item"),
+          "tabindex": disabled ? void 0 : 0,
+          "aria-setsize": count,
+          "aria-posinset": score,
+          "aria-checked": !isVoid,
+          "onClick": onClickItem
+        }, [vue.createVNode(Icon, {
+          "size": size,
+          "name": isFull ? icon : voidIcon,
+          "class": bem$l("icon", {
+            disabled,
+            full: isFull
+          }),
+          "color": disabled ? disabledColor : isFull ? color : voidColor,
+          "classPrefix": iconPrefix
+        }, null), renderHalf && vue.createVNode(Icon, {
+          "size": size,
+          "style": {
+            width: item.value + "em"
+          },
+          "name": isVoid ? voidIcon : icon,
+          "class": bem$l("icon", ["half", {
+            disabled,
+            full: !isVoid
+          }]),
+          "color": disabled ? disabledColor : isVoid ? voidColor : color,
+          "classPrefix": iconPrefix
+        }, null)]);
+      };
+      useCustomFieldValue(() => props.modelValue);
+      useEventListener("touchmove", onTouchMove, {
+        target: groupRef
+      });
+      return () => vue.createVNode("div", {
+        "ref": groupRef,
+        "role": "radiogroup",
+        "class": bem$l({
+          readonly: props.readonly,
+          disabled: props.disabled
+        }),
+        "tabindex": props.disabled ? void 0 : 0,
+        "aria-disabled": props.disabled,
+        "aria-readonly": props.readonly,
+        "onTouchstartPassive": onTouchStart
+      }, [list.value.map(renderStar)]);
+    }
+  });
+  const Rate = withInstall(stdin_default$u);
+  const Row = withInstall(stdin_default$10);
+  const [name$l, bem$k, t$3] = createNamespace("search");
+  const searchProps = extend({}, fieldSharedProps, {
+    label: String,
+    shape: makeStringProp("square"),
+    leftIcon: makeStringProp("search"),
+    clearable: truthProp,
+    actionText: String,
+    background: String,
+    showAction: Boolean
+  });
+  var stdin_default$t = vue.defineComponent({
+    name: name$l,
+    props: searchProps,
+    emits: ["blur", "focus", "clear", "search", "cancel", "clickInput", "clickLeftIcon", "clickRightIcon", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots,
+      attrs
+    }) {
+      const id = useId();
+      const fieldRef = vue.ref();
+      const onCancel = () => {
+        if (!slots.action) {
+          emit("update:modelValue", "");
+          emit("cancel");
+        }
+      };
+      const onKeypress = (event) => {
+        const ENTER_CODE = 13;
+        if (event.keyCode === ENTER_CODE) {
+          preventDefault(event);
+          emit("search", props.modelValue);
+        }
+      };
+      const getInputId = () => props.id || `${id}-input`;
+      const renderLabel = () => {
+        if (slots.label || props.label) {
+          return vue.createVNode("label", {
+            "class": bem$k("label"),
+            "for": getInputId()
+          }, [slots.label ? slots.label() : props.label]);
+        }
+      };
+      const renderAction = () => {
+        if (props.showAction) {
+          const text = props.actionText || t$3("cancel");
+          return vue.createVNode("div", {
+            "class": bem$k("action"),
+            "role": "button",
+            "tabindex": 0,
+            "onClick": onCancel
+          }, [slots.action ? slots.action() : text]);
+        }
+      };
+      const blur = () => {
+        var _a;
+        return (_a = fieldRef.value) == null ? void 0 : _a.blur();
+      };
+      const focus = () => {
+        var _a;
+        return (_a = fieldRef.value) == null ? void 0 : _a.focus();
+      };
+      const onBlur = (event) => emit("blur", event);
+      const onFocus = (event) => emit("focus", event);
+      const onClear = (event) => emit("clear", event);
+      const onClickInput = (event) => emit("clickInput", event);
+      const onClickLeftIcon = (event) => emit("clickLeftIcon", event);
+      const onClickRightIcon = (event) => emit("clickRightIcon", event);
+      const fieldPropNames = Object.keys(fieldSharedProps);
+      const renderField = () => {
+        const fieldAttrs = extend({}, attrs, pick(props, fieldPropNames), {
+          id: getInputId()
+        });
+        const onInput = (value) => emit("update:modelValue", value);
+        return vue.createVNode(Field, vue.mergeProps({
+          "ref": fieldRef,
+          "type": "search",
+          "class": bem$k("field"),
+          "border": false,
+          "onBlur": onBlur,
+          "onFocus": onFocus,
+          "onClear": onClear,
+          "onKeypress": onKeypress,
+          "onClickInput": onClickInput,
+          "onClickLeftIcon": onClickLeftIcon,
+          "onClickRightIcon": onClickRightIcon,
+          "onUpdate:modelValue": onInput
+        }, fieldAttrs), pick(slots, ["left-icon", "right-icon"]));
+      };
+      useExpose({
+        focus,
+        blur
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "class": bem$k({
+            "show-action": props.showAction
+          }),
+          "style": {
+            background: props.background
+          }
+        }, [(_a = slots.left) == null ? void 0 : _a.call(slots), vue.createVNode("div", {
+          "class": bem$k("content", props.shape)
+        }, [renderLabel(), renderField()]), renderAction()]);
+      };
+    }
+  });
+  const Search = withInstall(stdin_default$t);
+  const popupInheritKeys = [...popupSharedPropKeys, "round", "closeOnPopstate", "safeAreaInsetBottom"];
+  const iconMap = {
+    qq: "qq",
+    link: "link-o",
+    weibo: "weibo",
+    qrcode: "qr",
+    poster: "photo-o",
+    wechat: "wechat",
+    "weapp-qrcode": "miniprogram-o",
+    "wechat-moments": "wechat-moments"
+  };
+  const [name$k, bem$j, t$2] = createNamespace("share-sheet");
+  const shareSheetProps = extend({}, popupSharedProps, {
+    title: String,
+    round: truthProp,
+    options: makeArrayProp(),
+    cancelText: String,
+    description: String,
+    closeOnPopstate: truthProp,
+    safeAreaInsetBottom: truthProp
+  });
+  var stdin_default$s = vue.defineComponent({
+    name: name$k,
+    props: shareSheetProps,
+    emits: ["cancel", "select", "update:show"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const updateShow = (value) => emit("update:show", value);
+      const onCancel = () => {
+        updateShow(false);
+        emit("cancel");
+      };
+      const onSelect = (option, index) => emit("select", option, index);
+      const renderHeader = () => {
+        const title = slots.title ? slots.title() : props.title;
+        const description = slots.description ? slots.description() : props.description;
+        if (title || description) {
+          return vue.createVNode("div", {
+            "class": bem$j("header")
+          }, [title && vue.createVNode("h2", {
+            "class": bem$j("title")
+          }, [title]), description && vue.createVNode("span", {
+            "class": bem$j("description")
+          }, [description])]);
+        }
+      };
+      const renderIcon = (icon) => {
+        if (iconMap[icon]) {
+          return vue.createVNode("div", {
+            "class": bem$j("icon", [icon])
+          }, [vue.createVNode(Icon, {
+            "name": iconMap[icon] || icon
+          }, null)]);
+        }
+        return vue.createVNode("img", {
+          "src": icon,
+          "class": bem$j("image-icon")
+        }, null);
+      };
+      const renderOption = (option, index) => {
+        const {
+          name: name2,
+          icon,
+          className,
+          description
+        } = option;
+        return vue.createVNode("div", {
+          "role": "button",
+          "tabindex": 0,
+          "class": [bem$j("option"), className, HAPTICS_FEEDBACK],
+          "onClick": () => onSelect(option, index)
+        }, [renderIcon(icon), name2 && vue.createVNode("span", {
+          "class": bem$j("name")
+        }, [name2]), description && vue.createVNode("span", {
+          "class": bem$j("option-description")
+        }, [description])]);
+      };
+      const renderOptions = (options, border) => vue.createVNode("div", {
+        "class": bem$j("options", {
+          border
+        })
+      }, [options.map(renderOption)]);
+      const renderRows = () => {
+        const {
+          options
+        } = props;
+        if (Array.isArray(options[0])) {
+          return options.map((item, index) => renderOptions(item, index !== 0));
+        }
+        return renderOptions(options);
+      };
+      const renderCancelButton = () => {
+        var _a;
+        const cancelText = (_a = props.cancelText) != null ? _a : t$2("cancel");
+        if (slots.cancel || cancelText) {
+          return vue.createVNode("button", {
+            "type": "button",
+            "class": bem$j("cancel"),
+            "onClick": onCancel
+          }, [slots.cancel ? slots.cancel() : cancelText]);
+        }
+      };
+      return () => vue.createVNode(Popup, vue.mergeProps({
+        "class": bem$j(),
+        "position": "bottom",
+        "onUpdate:show": updateShow
+      }, pick(props, popupInheritKeys)), {
+        default: () => [renderHeader(), renderRows(), renderCancelButton()]
+      });
+    }
+  });
+  const ShareSheet = withInstall(stdin_default$s);
+  const [name$j, bem$i] = createNamespace("sidebar");
+  const SIDEBAR_KEY = Symbol(name$j);
+  const sidebarProps = {
+    modelValue: makeNumericProp(0)
+  };
+  var stdin_default$r = vue.defineComponent({
+    name: name$j,
+    props: sidebarProps,
+    emits: ["change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const {
+        linkChildren
+      } = useChildren(SIDEBAR_KEY);
+      const getActive = () => +props.modelValue;
+      const setActive = (value) => {
+        if (value !== getActive()) {
+          emit("update:modelValue", value);
+          emit("change", value);
+        }
+      };
+      linkChildren({
+        getActive,
+        setActive
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "role": "tablist",
+          "class": bem$i()
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+    }
+  });
+  const Sidebar = withInstall(stdin_default$r);
+  const [name$i, bem$h] = createNamespace("sidebar-item");
+  const sidebarItemProps = extend({}, routeProps, {
+    dot: Boolean,
+    title: String,
+    badge: numericProp,
+    disabled: Boolean,
+    badgeProps: Object
+  });
+  var stdin_default$q = vue.defineComponent({
+    name: name$i,
+    props: sidebarItemProps,
+    emits: ["click"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const route2 = useRoute();
+      const {
+        parent,
+        index
+      } = useParent(SIDEBAR_KEY);
+      if (!parent) {
+        return;
+      }
+      const onClick = () => {
+        if (props.disabled) {
+          return;
+        }
+        emit("click", index.value);
+        parent.setActive(index.value);
+        route2();
+      };
+      return () => {
+        const {
+          dot,
+          badge,
+          title,
+          disabled
+        } = props;
+        const selected = index.value === parent.getActive();
+        return vue.createVNode("div", {
+          "role": "tab",
+          "class": bem$h({
+            select: selected,
+            disabled
+          }),
+          "tabindex": disabled ? void 0 : 0,
+          "aria-selected": selected,
+          "onClick": onClick
+        }, [vue.createVNode(Badge, vue.mergeProps({
+          "dot": dot,
+          "class": bem$h("text"),
+          "content": badge
+        }, props.badgeProps), {
+          default: () => [slots.title ? slots.title() : title]
+        })]);
+      };
+    }
+  });
+  const SidebarItem = withInstall(stdin_default$q);
+  const [name$h, bem$g] = createNamespace("skeleton-title");
+  const skeletonTitleProps = {
+    round: Boolean,
+    titleWidth: numericProp
+  };
+  var stdin_default$p = vue.defineComponent({
+    name: name$h,
+    props: skeletonTitleProps,
+    setup(props) {
+      return () => vue.createVNode("h3", {
+        "class": bem$g([{
+          round: props.round
+        }]),
+        "style": {
+          width: addUnit(props.titleWidth)
+        }
+      }, null);
+    }
+  });
+  const SkeletonTitle = withInstall(stdin_default$p);
+  var stdin_default$o = SkeletonTitle;
+  const [name$g, bem$f] = createNamespace("skeleton-avatar");
+  const skeletonAvatarProps = {
+    avatarSize: numericProp,
+    avatarShape: makeStringProp("round")
+  };
+  var stdin_default$n = vue.defineComponent({
+    name: name$g,
+    props: skeletonAvatarProps,
+    setup(props) {
+      return () => vue.createVNode("div", {
+        "class": bem$f([props.avatarShape]),
+        "style": getSizeStyle(props.avatarSize)
+      }, null);
+    }
+  });
+  const SkeletonAvatar = withInstall(stdin_default$n);
+  var stdin_default$m = SkeletonAvatar;
+  const DEFAULT_ROW_WIDTH = "100%";
+  const skeletonParagraphProps = {
+    round: Boolean,
+    rowWidth: {
+      type: numericProp,
+      default: DEFAULT_ROW_WIDTH
+    }
+  };
+  const [name$f, bem$e] = createNamespace("skeleton-paragraph");
+  var stdin_default$l = vue.defineComponent({
+    name: name$f,
+    props: skeletonParagraphProps,
+    setup(props) {
+      return () => vue.createVNode("div", {
+        "class": bem$e([{
+          round: props.round
+        }]),
+        "style": {
+          width: props.rowWidth
+        }
+      }, null);
+    }
+  });
+  const SkeletonParagraph = withInstall(stdin_default$l);
+  var stdin_default$k = SkeletonParagraph;
+  const [name$e, bem$d] = createNamespace("skeleton");
+  const DEFAULT_LAST_ROW_WIDTH = "60%";
+  const skeletonProps = {
+    row: makeNumericProp(0),
+    round: Boolean,
+    title: Boolean,
+    titleWidth: numericProp,
+    avatar: Boolean,
+    avatarSize: numericProp,
+    avatarShape: makeStringProp("round"),
+    loading: truthProp,
+    animate: truthProp,
+    rowWidth: {
+      type: [Number, String, Array],
+      default: DEFAULT_ROW_WIDTH
+    }
+  };
+  var stdin_default$j = vue.defineComponent({
+    name: name$e,
+    inheritAttrs: false,
+    props: skeletonProps,
+    setup(props, {
+      slots,
+      attrs
+    }) {
+      const renderAvatar = () => {
+        if (props.avatar) {
+          return vue.createVNode(stdin_default$m, {
+            "avatarShape": props.avatarShape,
+            "avatarSize": props.avatarSize
+          }, null);
+        }
+      };
+      const renderTitle = () => {
+        if (props.title) {
+          return vue.createVNode(stdin_default$o, {
+            "round": props.round,
+            "titleWidth": props.titleWidth
+          }, null);
+        }
+      };
+      const getRowWidth = (index) => {
+        const {
+          rowWidth
+        } = props;
+        if (rowWidth === DEFAULT_ROW_WIDTH && index === +props.row - 1) {
+          return DEFAULT_LAST_ROW_WIDTH;
+        }
+        if (Array.isArray(rowWidth)) {
+          return rowWidth[index];
+        }
+        return rowWidth;
+      };
+      const renderRows = () => Array(+props.row).fill("").map((_, i) => vue.createVNode(stdin_default$k, {
+        "key": i,
+        "round": props.round,
+        "rowWidth": addUnit(getRowWidth(i))
+      }, null));
+      const renderContents = () => {
+        if (slots.template) {
+          return slots.template();
+        }
+        return vue.createVNode(vue.Fragment, null, [renderAvatar(), vue.createVNode("div", {
+          "class": bem$d("content")
+        }, [renderTitle(), renderRows()])]);
+      };
+      return () => {
+        var _a;
+        if (!props.loading) {
+          return (_a = slots.default) == null ? void 0 : _a.call(slots);
+        }
+        return vue.createVNode("div", vue.mergeProps({
+          "class": bem$d({
+            animate: props.animate,
+            round: props.round
+          })
+        }, attrs), [renderContents()]);
+      };
+    }
+  });
+  const Skeleton = withInstall(stdin_default$j);
+  const [name$d, bem$c] = createNamespace("skeleton-image");
+  const skeletonImageProps = {
+    imageSize: numericProp,
+    imageShape: makeStringProp("square")
+  };
+  var stdin_default$i = vue.defineComponent({
+    name: name$d,
+    props: skeletonImageProps,
+    setup(props) {
+      return () => vue.createVNode("div", {
+        "class": bem$c([props.imageShape]),
+        "style": getSizeStyle(props.imageSize)
+      }, [vue.createVNode(Icon, {
+        "name": "photo",
+        "class": bem$c("icon")
+      }, null)]);
+    }
+  });
+  const SkeletonImage = withInstall(stdin_default$i);
+  const [name$c, bem$b] = createNamespace("slider");
+  const sliderProps = {
+    min: makeNumericProp(0),
+    max: makeNumericProp(100),
+    step: makeNumericProp(1),
+    range: Boolean,
+    reverse: Boolean,
+    disabled: Boolean,
+    readonly: Boolean,
+    vertical: Boolean,
+    barHeight: numericProp,
+    buttonSize: numericProp,
+    activeColor: String,
+    inactiveColor: String,
+    modelValue: {
+      type: [Number, Array],
+      default: 0
+    }
+  };
+  var stdin_default$h = vue.defineComponent({
+    name: name$c,
+    props: sliderProps,
+    emits: ["change", "dragEnd", "dragStart", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      let buttonIndex;
+      let current2;
+      let startValue;
+      const root = vue.ref();
+      const slider = [vue.ref(), vue.ref()];
+      const dragStatus = vue.ref();
+      const touch = useTouch();
+      const scope = vue.computed(() => Number(props.max) - Number(props.min));
+      const wrapperStyle = vue.computed(() => {
+        const crossAxis = props.vertical ? "width" : "height";
+        return {
+          background: props.inactiveColor,
+          [crossAxis]: addUnit(props.barHeight)
+        };
+      });
+      const isRange = (val) => props.range && Array.isArray(val);
+      const calcMainAxis = () => {
+        const {
+          modelValue,
+          min
+        } = props;
+        if (isRange(modelValue)) {
+          return `${(modelValue[1] - modelValue[0]) * 100 / scope.value}%`;
+        }
+        return `${(modelValue - Number(min)) * 100 / scope.value}%`;
+      };
+      const calcOffset = () => {
+        const {
+          modelValue,
+          min
+        } = props;
+        if (isRange(modelValue)) {
+          return `${(modelValue[0] - Number(min)) * 100 / scope.value}%`;
+        }
+        return "0%";
+      };
+      const barStyle = vue.computed(() => {
+        const mainAxis = props.vertical ? "height" : "width";
+        const style = {
+          [mainAxis]: calcMainAxis(),
+          background: props.activeColor
+        };
+        if (dragStatus.value) {
+          style.transition = "none";
+        }
+        const getPositionKey = () => {
+          if (props.vertical) {
+            return props.reverse ? "bottom" : "top";
+          }
+          return props.reverse ? "right" : "left";
+        };
+        style[getPositionKey()] = calcOffset();
+        return style;
+      });
+      const format2 = (value) => {
+        const min = +props.min;
+        const max = +props.max;
+        const step = +props.step;
+        value = clamp(value, min, max);
+        const diff = Math.round((value - min) / step) * step;
+        return addNumber(min, diff);
+      };
+      const handleRangeValue = (value) => {
+        var _a, _b;
+        const left2 = (_a = value[0]) != null ? _a : Number(props.min);
+        const right2 = (_b = value[1]) != null ? _b : Number(props.max);
+        return left2 > right2 ? [right2, left2] : [left2, right2];
+      };
+      const updateValue = (value, end2) => {
+        if (isRange(value)) {
+          value = handleRangeValue(value).map(format2);
+        } else {
+          value = format2(value);
+        }
+        if (!isSameValue(value, props.modelValue)) {
+          emit("update:modelValue", value);
+        }
+        if (end2 && !isSameValue(value, startValue)) {
+          emit("change", value);
+        }
+      };
+      const onClick = (event) => {
+        event.stopPropagation();
+        if (props.disabled || props.readonly) {
+          return;
+        }
+        const {
+          min,
+          reverse,
+          vertical,
+          modelValue
+        } = props;
+        const rect = useRect(root);
+        const getDelta = () => {
+          if (vertical) {
+            if (reverse) {
+              return rect.bottom - event.clientY;
+            }
+            return event.clientY - rect.top;
+          }
+          if (reverse) {
+            return rect.right - event.clientX;
+          }
+          return event.clientX - rect.left;
+        };
+        const total = vertical ? rect.height : rect.width;
+        const value = Number(min) + getDelta() / total * scope.value;
+        if (isRange(modelValue)) {
+          const [left2, right2] = modelValue;
+          const middle = (left2 + right2) / 2;
+          if (value <= middle) {
+            updateValue([value, right2], true);
+          } else {
+            updateValue([left2, value], true);
+          }
+        } else {
+          updateValue(value, true);
+        }
+      };
+      const onTouchStart = (event) => {
+        if (props.disabled || props.readonly) {
+          return;
+        }
+        touch.start(event);
+        current2 = props.modelValue;
+        if (isRange(current2)) {
+          startValue = current2.map(format2);
+        } else {
+          startValue = format2(current2);
+        }
+        dragStatus.value = "start";
+      };
+      const onTouchMove = (event) => {
+        if (props.disabled || props.readonly) {
+          return;
+        }
+        if (dragStatus.value === "start") {
+          emit("dragStart", event);
+        }
+        preventDefault(event, true);
+        touch.move(event);
+        dragStatus.value = "dragging";
+        const rect = useRect(root);
+        const delta = props.vertical ? touch.deltaY.value : touch.deltaX.value;
+        const total = props.vertical ? rect.height : rect.width;
+        let diff = delta / total * scope.value;
+        if (props.reverse) {
+          diff = -diff;
+        }
+        if (isRange(startValue)) {
+          const index = props.reverse ? 1 - buttonIndex : buttonIndex;
+          current2[index] = startValue[index] + diff;
+        } else {
+          current2 = startValue + diff;
+        }
+        updateValue(current2);
+      };
+      const onTouchEnd = (event) => {
+        if (props.disabled || props.readonly) {
+          return;
+        }
+        if (dragStatus.value === "dragging") {
+          updateValue(current2, true);
+          emit("dragEnd", event);
+        }
+        dragStatus.value = "";
+      };
+      const getButtonClassName = (index) => {
+        if (typeof index === "number") {
+          const position = ["left", "right"];
+          return bem$b(`button-wrapper`, position[index]);
+        }
+        return bem$b("button-wrapper", props.reverse ? "left" : "right");
+      };
+      const renderButtonContent = (value, index) => {
+        if (typeof index === "number") {
+          const slot = slots[index === 0 ? "left-button" : "right-button"];
+          if (slot) {
+            return slot({
+              value
+            });
+          }
+        }
+        if (slots.button) {
+          return slots.button({
+            value
+          });
+        }
+        return vue.createVNode("div", {
+          "class": bem$b("button"),
+          "style": getSizeStyle(props.buttonSize)
+        }, null);
+      };
+      const renderButton = (index) => {
+        const current22 = typeof index === "number" ? props.modelValue[index] : props.modelValue;
+        return vue.createVNode("div", {
+          "ref": slider[index != null ? index : 0],
+          "role": "slider",
+          "class": getButtonClassName(index),
+          "tabindex": props.disabled ? void 0 : 0,
+          "aria-valuemin": props.min,
+          "aria-valuenow": current22,
+          "aria-valuemax": props.max,
+          "aria-disabled": props.disabled || void 0,
+          "aria-readonly": props.readonly || void 0,
+          "aria-orientation": props.vertical ? "vertical" : "horizontal",
+          "onTouchstartPassive": (event) => {
+            if (typeof index === "number") {
+              buttonIndex = index;
+            }
+            onTouchStart(event);
+          },
+          "onTouchend": onTouchEnd,
+          "onTouchcancel": onTouchEnd,
+          "onClick": stopPropagation
+        }, [renderButtonContent(current22, index)]);
+      };
+      updateValue(props.modelValue);
+      useCustomFieldValue(() => props.modelValue);
+      slider.forEach((item) => {
+        useEventListener("touchmove", onTouchMove, {
+          target: item
+        });
+      });
+      return () => vue.createVNode("div", {
+        "ref": root,
+        "style": wrapperStyle.value,
+        "class": bem$b({
+          vertical: props.vertical,
+          disabled: props.disabled
+        }),
+        "onClick": onClick
+      }, [vue.createVNode("div", {
+        "class": bem$b("bar"),
+        "style": barStyle.value
+      }, [props.range ? [renderButton(0), renderButton(1)] : renderButton()])]);
+    }
+  });
+  const Slider = withInstall(stdin_default$h);
+  const [name$b, bem$a] = createNamespace("space");
+  const spaceProps = {
+    align: String,
+    direction: {
+      type: String,
+      default: "horizontal"
+    },
+    size: {
+      type: [Number, String, Array],
+      default: 8
+    },
+    wrap: Boolean,
+    fill: Boolean
+  };
+  function filterEmpty(children = []) {
+    const nodes = [];
+    children.forEach((child) => {
+      if (Array.isArray(child)) {
+        nodes.push(...child);
+      } else if (child.type === vue.Fragment) {
+        nodes.push(...filterEmpty(child.children));
+      } else {
+        nodes.push(child);
+      }
+    });
+    return nodes.filter((c) => {
+      var _a;
+      return !(c && (c.type === vue.Comment || c.type === vue.Fragment && ((_a = c.children) == null ? void 0 : _a.length) === 0 || c.type === vue.Text && c.children.trim() === ""));
+    });
+  }
+  var stdin_default$g = vue.defineComponent({
+    name: name$b,
+    props: spaceProps,
+    setup(props, {
+      slots
+    }) {
+      const mergedAlign = vue.computed(() => {
+        var _a;
+        return (_a = props.align) != null ? _a : props.direction === "horizontal" ? "center" : "";
+      });
+      const getMargin = (size) => {
+        if (typeof size === "number") {
+          return size + "px";
+        }
+        return size;
+      };
+      const getMarginStyle = (isLast) => {
+        const style = {};
+        const marginRight = `${getMargin(Array.isArray(props.size) ? props.size[0] : props.size)}`;
+        const marginBottom = `${getMargin(Array.isArray(props.size) ? props.size[1] : props.size)}`;
+        if (isLast) {
+          return props.wrap ? {
+            marginBottom
+          } : {};
+        }
+        if (props.direction === "horizontal") {
+          style.marginRight = marginRight;
+        }
+        if (props.direction === "vertical" || props.wrap) {
+          style.marginBottom = marginBottom;
+        }
+        return style;
+      };
+      return () => {
+        var _a;
+        const children = filterEmpty((_a = slots.default) == null ? void 0 : _a.call(slots));
+        return vue.createVNode("div", {
+          "class": [bem$a({
+            [props.direction]: props.direction,
+            [`align-${mergedAlign.value}`]: mergedAlign.value,
+            wrap: props.wrap,
+            fill: props.fill
+          })]
+        }, [children.map((c, i) => vue.createVNode("div", {
+          "key": `item-${i}`,
+          "class": `${name$b}-item`,
+          "style": getMarginStyle(i === children.length - 1)
+        }, [c]))]);
+      };
+    }
+  });
+  const Space = withInstall(stdin_default$g);
+  const [name$a, bem$9] = createNamespace("steps");
+  const stepsProps = {
+    active: makeNumericProp(0),
+    direction: makeStringProp("horizontal"),
+    activeIcon: makeStringProp("checked"),
+    iconPrefix: String,
+    finishIcon: String,
+    activeColor: String,
+    inactiveIcon: String,
+    inactiveColor: String
+  };
+  const STEPS_KEY = Symbol(name$a);
+  var stdin_default$f = vue.defineComponent({
+    name: name$a,
+    props: stepsProps,
+    emits: ["clickStep"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const {
+        linkChildren
+      } = useChildren(STEPS_KEY);
+      const onClickStep = (index) => emit("clickStep", index);
+      linkChildren({
+        props,
+        onClickStep
+      });
+      return () => {
+        var _a;
+        return vue.createVNode("div", {
+          "class": bem$9([props.direction])
+        }, [vue.createVNode("div", {
+          "class": bem$9("items")
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
+      };
+    }
+  });
+  const [name$9, bem$8] = createNamespace("step");
+  var stdin_default$e = vue.defineComponent({
+    name: name$9,
+    setup(props, {
+      slots
+    }) {
+      const {
+        parent,
+        index
+      } = useParent(STEPS_KEY);
+      if (!parent) {
+        return;
+      }
+      const parentProps = parent.props;
+      const getStatus = () => {
+        const active = +parentProps.active;
+        if (index.value < active) {
+          return "finish";
+        }
+        return index.value === active ? "process" : "waiting";
+      };
+      const isActive = () => getStatus() === "process";
+      const lineStyle = vue.computed(() => ({
+        background: getStatus() === "finish" ? parentProps.activeColor : parentProps.inactiveColor
+      }));
+      const titleStyle = vue.computed(() => {
+        if (isActive()) {
+          return {
+            color: parentProps.activeColor
+          };
+        }
+        if (getStatus() === "waiting") {
+          return {
+            color: parentProps.inactiveColor
+          };
+        }
+      });
+      const onClickStep = () => parent.onClickStep(index.value);
+      const renderCircle = () => {
+        const {
+          iconPrefix,
+          finishIcon,
+          activeIcon,
+          activeColor,
+          inactiveIcon
+        } = parentProps;
+        if (isActive()) {
+          if (slots["active-icon"]) {
+            return slots["active-icon"]();
+          }
+          return vue.createVNode(Icon, {
+            "class": bem$8("icon", "active"),
+            "name": activeIcon,
+            "color": activeColor,
+            "classPrefix": iconPrefix
+          }, null);
+        }
+        if (getStatus() === "finish" && (finishIcon || slots["finish-icon"])) {
+          if (slots["finish-icon"]) {
+            return slots["finish-icon"]();
+          }
+          return vue.createVNode(Icon, {
+            "class": bem$8("icon", "finish"),
+            "name": finishIcon,
+            "color": activeColor,
+            "classPrefix": iconPrefix
+          }, null);
+        }
+        if (slots["inactive-icon"]) {
+          return slots["inactive-icon"]();
+        }
+        if (inactiveIcon) {
+          return vue.createVNode(Icon, {
+            "class": bem$8("icon"),
+            "name": inactiveIcon,
+            "classPrefix": iconPrefix
+          }, null);
+        }
+        return vue.createVNode("i", {
+          "class": bem$8("circle"),
+          "style": lineStyle.value
+        }, null);
+      };
+      return () => {
+        var _a;
+        const status = getStatus();
+        return vue.createVNode("div", {
+          "class": [BORDER, bem$8([parentProps.direction, {
+            [status]: status
+          }])]
+        }, [vue.createVNode("div", {
+          "class": bem$8("title", {
+            active: isActive()
+          }),
+          "style": titleStyle.value,
+          "onClick": onClickStep
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]), vue.createVNode("div", {
+          "class": bem$8("circle-container"),
+          "onClick": onClickStep
+        }, [renderCircle()]), vue.createVNode("div", {
+          "class": bem$8("line"),
+          "style": lineStyle.value
+        }, null)]);
+      };
+    }
+  });
+  const Step = withInstall(stdin_default$e);
+  const [name$8, bem$7] = createNamespace("stepper");
+  const LONG_PRESS_INTERVAL = 200;
+  const isEqual = (value1, value2) => String(value1) === String(value2);
+  const stepperProps = {
+    min: makeNumericProp(1),
+    max: makeNumericProp(Infinity),
+    name: makeNumericProp(""),
+    step: makeNumericProp(1),
+    theme: String,
+    integer: Boolean,
+    disabled: Boolean,
+    showPlus: truthProp,
+    showMinus: truthProp,
+    showInput: truthProp,
+    longPress: truthProp,
+    autoFixed: truthProp,
+    allowEmpty: Boolean,
+    modelValue: numericProp,
+    inputWidth: numericProp,
+    buttonSize: numericProp,
+    placeholder: String,
+    disablePlus: Boolean,
+    disableMinus: Boolean,
+    disableInput: Boolean,
+    beforeChange: Function,
+    defaultValue: makeNumericProp(1),
+    decimalLength: numericProp
+  };
+  var stdin_default$d = vue.defineComponent({
+    name: name$8,
+    props: stepperProps,
+    emits: ["plus", "blur", "minus", "focus", "change", "overlimit", "update:modelValue"],
+    setup(props, {
+      emit
+    }) {
+      const format2 = (value, autoFixed = true) => {
+        const {
+          min,
+          max,
+          allowEmpty,
+          decimalLength
+        } = props;
+        if (allowEmpty && value === "") {
+          return value;
+        }
+        value = formatNumber(String(value), !props.integer);
+        value = value === "" ? 0 : +value;
+        value = Number.isNaN(value) ? +min : value;
+        value = autoFixed ? Math.max(Math.min(+max, value), +min) : value;
+        if (isDef(decimalLength)) {
+          value = value.toFixed(+decimalLength);
+        }
+        return value;
+      };
+      const getInitialValue = () => {
+        var _a;
+        const defaultValue = (_a = props.modelValue) != null ? _a : props.defaultValue;
+        const value = format2(defaultValue);
+        if (!isEqual(value, props.modelValue)) {
+          emit("update:modelValue", value);
+        }
+        return value;
+      };
+      let actionType;
+      const inputRef = vue.ref();
+      const current2 = vue.ref(getInitialValue());
+      const minusDisabled = vue.computed(() => props.disabled || props.disableMinus || +current2.value <= +props.min);
+      const plusDisabled = vue.computed(() => props.disabled || props.disablePlus || +current2.value >= +props.max);
+      const inputStyle = vue.computed(() => ({
+        width: addUnit(props.inputWidth),
+        height: addUnit(props.buttonSize)
+      }));
+      const buttonStyle = vue.computed(() => getSizeStyle(props.buttonSize));
+      const check = () => {
+        const value = format2(current2.value);
+        if (!isEqual(value, current2.value)) {
+          current2.value = value;
+        }
+      };
+      const setValue = (value) => {
+        if (props.beforeChange) {
+          callInterceptor(props.beforeChange, {
+            args: [value],
+            done() {
+              current2.value = value;
+            }
+          });
+        } else {
+          current2.value = value;
+        }
+      };
+      const onChange = () => {
+        if (actionType === "plus" && plusDisabled.value || actionType === "minus" && minusDisabled.value) {
+          emit("overlimit", actionType);
+          return;
+        }
+        const diff = actionType === "minus" ? -props.step : +props.step;
+        const value = format2(addNumber(+current2.value, diff));
+        setValue(value);
+        emit(actionType);
+      };
+      const onInput = (event) => {
+        const input = event.target;
+        const {
+          value
+        } = input;
+        const {
+          decimalLength
+        } = props;
+        let formatted = formatNumber(String(value), !props.integer);
+        if (isDef(decimalLength) && formatted.includes(".")) {
+          const pair = formatted.split(".");
+          formatted = `${pair[0]}.${pair[1].slice(0, +decimalLength)}`;
+        }
+        if (props.beforeChange) {
+          input.value = String(current2.value);
+        } else if (!isEqual(value, formatted)) {
+          input.value = formatted;
+        }
+        const isNumeric2 = formatted === String(+formatted);
+        setValue(isNumeric2 ? +formatted : formatted);
+      };
+      const onFocus = (event) => {
+        var _a;
+        if (props.disableInput) {
+          (_a = inputRef.value) == null ? void 0 : _a.blur();
+        } else {
+          emit("focus", event);
+        }
+      };
+      const onBlur = (event) => {
+        const input = event.target;
+        const value = format2(input.value, props.autoFixed);
+        input.value = String(value);
+        current2.value = value;
+        vue.nextTick(() => {
+          emit("blur", event);
+          resetScroll();
+        });
+      };
+      let isLongPress;
+      let longPressTimer;
+      const longPressStep = () => {
+        longPressTimer = setTimeout(() => {
+          onChange();
+          longPressStep();
+        }, LONG_PRESS_INTERVAL);
+      };
+      const onTouchStart = () => {
+        if (props.longPress) {
+          isLongPress = false;
+          clearTimeout(longPressTimer);
+          longPressTimer = setTimeout(() => {
+            isLongPress = true;
+            onChange();
+            longPressStep();
+          }, LONG_PRESS_START_TIME);
+        }
+      };
+      const onTouchEnd = (event) => {
+        if (props.longPress) {
+          clearTimeout(longPressTimer);
+          if (isLongPress) {
+            preventDefault(event);
+          }
+        }
+      };
+      const onMousedown = (event) => {
+        if (props.disableInput) {
+          preventDefault(event);
+        }
+      };
+      const createListeners = (type) => ({
+        onClick: (event) => {
+          preventDefault(event);
+          actionType = type;
+          onChange();
+        },
+        onTouchstartPassive: () => {
+          actionType = type;
+          onTouchStart();
+        },
+        onTouchend: onTouchEnd,
+        onTouchcancel: onTouchEnd
+      });
+      vue.watch(() => [props.max, props.min, props.integer, props.decimalLength], check);
+      vue.watch(() => props.modelValue, (value) => {
+        if (!isEqual(value, current2.value)) {
+          current2.value = format2(value);
+        }
+      });
+      vue.watch(current2, (value) => {
+        emit("update:modelValue", value);
+        emit("change", value, {
+          name: props.name
+        });
+      });
+      useCustomFieldValue(() => props.modelValue);
+      return () => vue.createVNode("div", {
+        "role": "group",
+        "class": bem$7([props.theme])
+      }, [vue.withDirectives(vue.createVNode("button", vue.mergeProps({
+        "type": "button",
+        "style": buttonStyle.value,
+        "class": [bem$7("minus", {
+          disabled: minusDisabled.value
+        }), {
+          [HAPTICS_FEEDBACK]: !minusDisabled.value
+        }],
+        "aria-disabled": minusDisabled.value || void 0
+      }, createListeners("minus")), null), [[vue.vShow, props.showMinus]]), vue.withDirectives(vue.createVNode("input", {
+        "ref": inputRef,
+        "type": props.integer ? "tel" : "text",
+        "role": "spinbutton",
+        "class": bem$7("input"),
+        "value": current2.value,
+        "style": inputStyle.value,
+        "disabled": props.disabled,
+        "readonly": props.disableInput,
+        "inputmode": props.integer ? "numeric" : "decimal",
+        "placeholder": props.placeholder,
+        "aria-valuemax": props.max,
+        "aria-valuemin": props.min,
+        "aria-valuenow": current2.value,
+        "onBlur": onBlur,
+        "onInput": onInput,
+        "onFocus": onFocus,
+        "onMousedown": onMousedown
+      }, null), [[vue.vShow, props.showInput]]), vue.withDirectives(vue.createVNode("button", vue.mergeProps({
+        "type": "button",
+        "style": buttonStyle.value,
+        "class": [bem$7("plus", {
+          disabled: plusDisabled.value
+        }), {
+          [HAPTICS_FEEDBACK]: !plusDisabled.value
+        }],
+        "aria-disabled": plusDisabled.value || void 0
+      }, createListeners("plus")), null), [[vue.vShow, props.showPlus]])]);
+    }
+  });
+  const Stepper = withInstall(stdin_default$d);
+  const Steps = withInstall(stdin_default$f);
+  const [name$7, bem$6, t$1] = createNamespace("submit-bar");
+  const submitBarProps = {
+    tip: String,
+    label: String,
+    price: Number,
+    tipIcon: String,
+    loading: Boolean,
+    currency: makeStringProp("¥"),
+    disabled: Boolean,
+    textAlign: String,
+    buttonText: String,
+    buttonType: makeStringProp("danger"),
+    buttonColor: String,
+    suffixLabel: String,
+    placeholder: Boolean,
+    decimalLength: makeNumericProp(2),
+    safeAreaInsetBottom: truthProp
+  };
+  var stdin_default$c = vue.defineComponent({
+    name: name$7,
+    props: submitBarProps,
+    emits: ["submit"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const root = vue.ref();
+      const renderPlaceholder = usePlaceholder(root, bem$6);
+      const renderText = () => {
+        const {
+          price,
+          label,
+          currency,
+          textAlign,
+          suffixLabel,
+          decimalLength
+        } = props;
+        if (typeof price === "number") {
+          const pricePair = (price / 100).toFixed(+decimalLength).split(".");
+          const decimal = decimalLength ? `.${pricePair[1]}` : "";
+          return vue.createVNode("div", {
+            "class": bem$6("text"),
+            "style": {
+              textAlign
+            }
+          }, [vue.createVNode("span", null, [label || t$1("label")]), vue.createVNode("span", {
+            "class": bem$6("price")
+          }, [currency, vue.createVNode("span", {
+            "class": bem$6("price-integer")
+          }, [pricePair[0]]), decimal]), suffixLabel && vue.createVNode("span", {
+            "class": bem$6("suffix-label")
+          }, [suffixLabel])]);
+        }
+      };
+      const renderTip = () => {
+        var _a;
+        const {
+          tip,
+          tipIcon
+        } = props;
+        if (slots.tip || tip) {
+          return vue.createVNode("div", {
+            "class": bem$6("tip")
+          }, [tipIcon && vue.createVNode(Icon, {
+            "class": bem$6("tip-icon"),
+            "name": tipIcon
+          }, null), tip && vue.createVNode("span", {
+            "class": bem$6("tip-text")
+          }, [tip]), (_a = slots.tip) == null ? void 0 : _a.call(slots)]);
+        }
+      };
+      const onClickButton = () => emit("submit");
+      const renderButton = () => {
+        if (slots.button) {
+          return slots.button();
+        }
+        return vue.createVNode(Button, {
+          "round": true,
+          "type": props.buttonType,
+          "text": props.buttonText,
+          "class": bem$6("button", props.buttonType),
+          "color": props.buttonColor,
+          "loading": props.loading,
+          "disabled": props.disabled,
+          "onClick": onClickButton
+        }, null);
+      };
+      const renderSubmitBar = () => {
+        var _a, _b;
+        return vue.createVNode("div", {
+          "ref": root,
+          "class": [bem$6(), {
+            "van-safe-area-bottom": props.safeAreaInsetBottom
+          }]
+        }, [(_a = slots.top) == null ? void 0 : _a.call(slots), renderTip(), vue.createVNode("div", {
+          "class": bem$6("bar")
+        }, [(_b = slots.default) == null ? void 0 : _b.call(slots), renderText(), renderButton()])]);
+      };
+      return () => {
+        if (props.placeholder) {
+          return renderPlaceholder(renderSubmitBar);
+        }
+        return renderSubmitBar();
+      };
+    }
+  });
+  const SubmitBar = withInstall(stdin_default$c);
+  const [name$6, bem$5] = createNamespace("swipe-cell");
+  const swipeCellProps = {
+    name: makeNumericProp(""),
+    disabled: Boolean,
+    leftWidth: numericProp,
+    rightWidth: numericProp,
+    beforeClose: Function,
+    stopPropagation: Boolean
+  };
+  var stdin_default$b = vue.defineComponent({
+    name: name$6,
+    props: swipeCellProps,
+    emits: ["open", "close", "click"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      let opened;
+      let lockClick2;
+      let startOffset;
+      const root = vue.ref();
+      const leftRef = vue.ref();
+      const rightRef = vue.ref();
+      const state = vue.reactive({
+        offset: 0,
+        dragging: false
+      });
+      const touch = useTouch();
+      const getWidthByRef = (ref2) => ref2.value ? useRect(ref2).width : 0;
+      const leftWidth = vue.computed(() => isDef(props.leftWidth) ? +props.leftWidth : getWidthByRef(leftRef));
+      const rightWidth = vue.computed(() => isDef(props.rightWidth) ? +props.rightWidth : getWidthByRef(rightRef));
+      const open = (side) => {
+        state.offset = side === "left" ? leftWidth.value : -rightWidth.value;
+        if (!opened) {
+          opened = true;
+          emit("open", {
+            name: props.name,
+            position: side
+          });
+        }
+      };
+      const close = (position) => {
+        state.offset = 0;
+        if (opened) {
+          opened = false;
+          emit("close", {
+            name: props.name,
+            position
+          });
+        }
+      };
+      const toggle = (side) => {
+        const offset2 = Math.abs(state.offset);
+        const THRESHOLD = 0.15;
+        const threshold = opened ? 1 - THRESHOLD : THRESHOLD;
+        const width2 = side === "left" ? leftWidth.value : rightWidth.value;
+        if (width2 && offset2 > width2 * threshold) {
+          open(side);
+        } else {
+          close(side);
+        }
+      };
+      const onTouchStart = (event) => {
+        if (!props.disabled) {
+          startOffset = state.offset;
+          touch.start(event);
+        }
+      };
+      const onTouchMove = (event) => {
+        if (props.disabled) {
+          return;
+        }
+        const {
+          deltaX
+        } = touch;
+        touch.move(event);
+        if (touch.isHorizontal()) {
+          lockClick2 = true;
+          state.dragging = true;
+          const isEdge = !opened || deltaX.value * startOffset < 0;
+          if (isEdge) {
+            preventDefault(event, props.stopPropagation);
+          }
+          state.offset = clamp(deltaX.value + startOffset, -rightWidth.value, leftWidth.value);
+        }
+      };
+      const onTouchEnd = () => {
+        if (state.dragging) {
+          state.dragging = false;
+          toggle(state.offset > 0 ? "left" : "right");
+          setTimeout(() => {
+            lockClick2 = false;
+          }, 0);
+        }
+      };
+      const onClick = (position = "outside") => {
+        emit("click", position);
+        if (opened && !lockClick2) {
+          callInterceptor(props.beforeClose, {
+            args: [{
+              name: props.name,
+              position
+            }],
+            done: () => close(position)
+          });
+        }
+      };
+      const getClickHandler = (position, stop) => (event) => {
+        if (stop) {
+          event.stopPropagation();
+        }
+        onClick(position);
+      };
+      const renderSideContent = (side, ref2) => {
+        const contentSlot = slots[side];
+        if (contentSlot) {
+          return vue.createVNode("div", {
+            "ref": ref2,
+            "class": bem$5(side),
+            "onClick": getClickHandler(side, true)
+          }, [contentSlot()]);
+        }
+      };
+      useExpose({
+        open,
+        close
+      });
+      useClickAway(root, () => onClick("outside"), {
+        eventName: "touchstart"
+      });
+      useEventListener("touchmove", onTouchMove, {
+        target: root
+      });
+      return () => {
+        var _a;
+        const wrapperStyle = {
+          transform: `translate3d(${state.offset}px, 0, 0)`,
+          transitionDuration: state.dragging ? "0s" : ".6s"
+        };
+        return vue.createVNode("div", {
+          "ref": root,
+          "class": bem$5(),
+          "onClick": getClickHandler("cell", lockClick2),
+          "onTouchstartPassive": onTouchStart,
+          "onTouchend": onTouchEnd,
+          "onTouchcancel": onTouchEnd
+        }, [vue.createVNode("div", {
+          "class": bem$5("wrapper"),
+          "style": wrapperStyle
+        }, [renderSideContent("left", leftRef), (_a = slots.default) == null ? void 0 : _a.call(slots), renderSideContent("right", rightRef)])]);
+      };
+    }
+  });
+  const SwipeCell = withInstall(stdin_default$b);
+  const [name$5, bem$4] = createNamespace("tabbar");
+  const tabbarProps = {
+    route: Boolean,
+    fixed: truthProp,
+    border: truthProp,
+    zIndex: numericProp,
+    placeholder: Boolean,
+    activeColor: String,
+    beforeChange: Function,
+    inactiveColor: String,
+    modelValue: makeNumericProp(0),
+    safeAreaInsetBottom: {
+      type: Boolean,
+      default: null
+    }
+  };
+  const TABBAR_KEY = Symbol(name$5);
+  var stdin_default$a = vue.defineComponent({
+    name: name$5,
+    props: tabbarProps,
+    emits: ["change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const root = vue.ref();
+      const {
+        linkChildren
+      } = useChildren(TABBAR_KEY);
+      const renderPlaceholder = usePlaceholder(root, bem$4);
+      const enableSafeArea = () => {
+        var _a;
+        return (_a = props.safeAreaInsetBottom) != null ? _a : props.fixed;
+      };
+      const renderTabbar = () => {
+        var _a;
+        const {
+          fixed,
+          zIndex,
+          border
+        } = props;
+        return vue.createVNode("div", {
+          "ref": root,
+          "role": "tablist",
+          "style": getZIndexStyle(zIndex),
+          "class": [bem$4({
+            fixed
+          }), {
+            [BORDER_TOP_BOTTOM]: border,
+            "van-safe-area-bottom": enableSafeArea()
+          }]
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      };
+      const setActive = (active, afterChange) => {
+        callInterceptor(props.beforeChange, {
+          args: [active],
+          done() {
+            emit("update:modelValue", active);
+            emit("change", active);
+            afterChange();
+          }
+        });
+      };
+      linkChildren({
+        props,
+        setActive
+      });
+      return () => {
+        if (props.fixed && props.placeholder) {
+          return renderPlaceholder(renderTabbar);
+        }
+        return renderTabbar();
+      };
+    }
+  });
+  const Tabbar = withInstall(stdin_default$a);
+  const [name$4, bem$3] = createNamespace("tabbar-item");
+  const tabbarItemProps = extend({}, routeProps, {
+    dot: Boolean,
+    icon: String,
+    name: numericProp,
+    badge: numericProp,
+    badgeProps: Object,
+    iconPrefix: String
+  });
+  var stdin_default$9 = vue.defineComponent({
+    name: name$4,
+    props: tabbarItemProps,
+    emits: ["click"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const route2 = useRoute();
+      const vm = vue.getCurrentInstance().proxy;
+      const {
+        parent,
+        index
+      } = useParent(TABBAR_KEY);
+      if (!parent) {
+        return;
+      }
+      const active = vue.computed(() => {
+        var _a;
+        const {
+          route: route22,
+          modelValue
+        } = parent.props;
+        if (route22 && "$route" in vm) {
+          const {
+            $route
+          } = vm;
+          const {
+            to
+          } = props;
+          const config = isObject(to) ? to : {
+            path: to
+          };
+          return !!$route.matched.find((val) => {
+            const pathMatched = "path" in config && config.path === val.path;
+            const nameMatched = "name" in config && config.name === val.name;
+            return pathMatched || nameMatched;
+          });
+        }
+        return ((_a = props.name) != null ? _a : index.value) === modelValue;
+      });
+      const onClick = (event) => {
+        var _a;
+        if (!active.value) {
+          parent.setActive((_a = props.name) != null ? _a : index.value, route2);
+        }
+        emit("click", event);
+      };
+      const renderIcon = () => {
+        if (slots.icon) {
+          return slots.icon({
+            active: active.value
+          });
+        }
+        if (props.icon) {
+          return vue.createVNode(Icon, {
+            "name": props.icon,
+            "classPrefix": props.iconPrefix
+          }, null);
+        }
+      };
+      return () => {
+        var _a;
+        const {
+          dot,
+          badge
+        } = props;
+        const {
+          activeColor,
+          inactiveColor
+        } = parent.props;
+        const color = active.value ? activeColor : inactiveColor;
+        return vue.createVNode("div", {
+          "role": "tab",
+          "class": bem$3({
+            active: active.value
+          }),
+          "style": {
+            color
+          },
+          "tabindex": 0,
+          "aria-selected": active.value,
+          "onClick": onClick
+        }, [vue.createVNode(Badge, vue.mergeProps({
+          "dot": dot,
+          "class": bem$3("icon"),
+          "content": badge
+        }, props.badgeProps), {
+          default: renderIcon
+        }), vue.createVNode("div", {
+          "class": bem$3("text")
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots, {
+          active: active.value
+        })])]);
+      };
+    }
+  });
+  const TabbarItem = withInstall(stdin_default$9);
+  const [name$3, bem$2] = createNamespace("text-ellipsis");
+  const textEllipsisProps = {
+    rows: makeNumericProp(1),
+    content: makeStringProp(""),
+    expandText: makeStringProp(""),
+    collapseText: makeStringProp("")
+  };
+  var stdin_default$8 = vue.defineComponent({
+    name: name$3,
+    props: textEllipsisProps,
+    emits: ["clickAction"],
+    setup(props, {
+      emit
+    }) {
+      const text = vue.ref("");
+      const expanded = vue.ref(false);
+      const hasAction = vue.ref(false);
+      const root = vue.ref();
+      const pxToNum = (value) => {
+        if (!value)
+          return 0;
+        const match = value.match(/^\d*(\.\d*)?/);
+        return match ? Number(match[0]) : 0;
+      };
+      const calcEllipsised = () => {
+        const cloneContainer = () => {
+          if (!root.value)
+            return;
+          const originStyle = window.getComputedStyle(root.value);
+          const container2 = document.createElement("div");
+          const styleNames = Array.prototype.slice.apply(originStyle);
+          styleNames.forEach((name2) => {
+            container2.style.setProperty(name2, originStyle.getPropertyValue(name2));
+          });
+          container2.style.position = "fixed";
+          container2.style.zIndex = "-9999";
+          container2.style.top = "-9999px";
+          container2.style.height = "auto";
+          container2.style.minHeight = "auto";
+          container2.style.maxHeight = "auto";
+          container2.innerText = props.content;
+          document.body.appendChild(container2);
+          return container2;
+        };
+        const calcEllipsisText = (container2, maxHeight2) => {
+          const {
+            content,
+            expandText
+          } = props;
+          const dot = "...";
+          let left2 = 0;
+          let right2 = content.length;
+          let res = -1;
+          while (left2 <= right2) {
+            const mid = Math.floor((left2 + right2) / 2);
+            container2.innerText = content.slice(0, mid) + dot + expandText;
+            if (container2.offsetHeight <= maxHeight2) {
+              left2 = mid + 1;
+              res = mid;
+            } else {
+              right2 = mid - 1;
+            }
+          }
+          return content.slice(0, res) + dot;
+        };
+        const container = cloneContainer();
+        if (!container)
+          return;
+        const {
+          paddingBottom,
+          paddingTop,
+          lineHeight
+        } = container.style;
+        const maxHeight = (Number(props.rows) + 0.5) * pxToNum(lineHeight) + pxToNum(paddingTop) + pxToNum(paddingBottom);
+        if (maxHeight < container.offsetHeight) {
+          hasAction.value = true;
+          text.value = calcEllipsisText(container, maxHeight);
+        } else {
+          hasAction.value = false;
+          text.value = props.content;
+        }
+        document.body.removeChild(container);
+      };
+      const onClickAction = (event) => {
+        expanded.value = !expanded.value;
+        emit("clickAction", event);
+      };
+      const renderAction = () => vue.createVNode("span", {
+        "class": bem$2("action"),
+        "onClick": onClickAction
+      }, [expanded.value ? props.collapseText : props.expandText]);
+      vue.onMounted(calcEllipsised);
+      vue.watch(() => [props.content, props.rows], calcEllipsised);
+      useEventListener("resize", calcEllipsised);
+      return () => vue.createVNode("div", {
+        "ref": root,
+        "class": bem$2()
+      }, [expanded.value ? props.content : text.value, hasAction.value ? renderAction() : null]);
+    }
+  });
+  const TextEllipsis = withInstall(stdin_default$8);
+  const [name$2] = createNamespace("time-picker");
+  const timePickerProps = extend({}, sharedProps, {
+    minHour: makeNumericProp(0),
+    maxHour: makeNumericProp(23),
+    minMinute: makeNumericProp(0),
+    maxMinute: makeNumericProp(59),
+    minSecond: makeNumericProp(0),
+    maxSecond: makeNumericProp(59),
+    columnsType: {
+      type: Array,
+      default: () => ["hour", "minute"]
+    }
+  });
+  var stdin_default$7 = vue.defineComponent({
+    name: name$2,
+    props: timePickerProps,
+    emits: ["confirm", "cancel", "change", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const currentValues = vue.ref(props.modelValue);
+      const columns = vue.computed(() => props.columnsType.map((type) => {
+        const {
+          filter,
+          formatter
+        } = props;
+        switch (type) {
+          case "hour":
+            return genOptions(+props.minHour, +props.maxHour, type, formatter, filter);
+          case "minute":
+            return genOptions(+props.minMinute, +props.maxMinute, type, formatter, filter);
+          case "second":
+            return genOptions(+props.minSecond, +props.maxSecond, type, formatter, filter);
+          default:
+            return [];
+        }
+      }));
+      vue.watch(currentValues, (newValues) => {
+        if (!isSameValue(newValues, props.modelValue)) {
+          emit("update:modelValue", newValues);
+        }
+      });
+      vue.watch(() => props.modelValue, (newValues) => {
+        newValues = formatValueRange(newValues, columns.value);
+        if (!isSameValue(newValues, currentValues.value)) {
+          currentValues.value = newValues;
+        }
+      }, {
+        immediate: true
+      });
+      const onChange = (...args) => emit("change", ...args);
+      const onCancel = (...args) => emit("cancel", ...args);
+      const onConfirm = (...args) => emit("confirm", ...args);
+      return () => vue.createVNode(Picker, vue.mergeProps({
+        "modelValue": currentValues.value,
+        "onUpdate:modelValue": ($event) => currentValues.value = $event,
+        "columns": columns.value,
+        "onChange": onChange,
+        "onCancel": onCancel,
+        "onConfirm": onConfirm
+      }, pick(props, pickerInheritKeys)), slots);
+    }
+  });
+  const TimePicker = withInstall(stdin_default$7);
+  const [name$1, bem$1] = createNamespace("tree-select");
+  const treeSelectProps = {
+    max: makeNumericProp(Infinity),
+    items: makeArrayProp(),
+    height: makeNumericProp(300),
+    selectedIcon: makeStringProp("success"),
+    mainActiveIndex: makeNumericProp(0),
+    activeId: {
+      type: [Number, String, Array],
+      default: 0
+    }
+  };
+  var stdin_default$6 = vue.defineComponent({
+    name: name$1,
+    props: treeSelectProps,
+    emits: ["clickNav", "clickItem", "update:activeId", "update:mainActiveIndex"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const isActiveItem = (id) => Array.isArray(props.activeId) ? props.activeId.includes(id) : props.activeId === id;
+      const renderSubItem = (item) => {
+        const onClick = () => {
+          if (item.disabled) {
+            return;
+          }
+          let activeId;
+          if (Array.isArray(props.activeId)) {
+            activeId = props.activeId.slice();
+            const index = activeId.indexOf(item.id);
+            if (index !== -1) {
+              activeId.splice(index, 1);
+            } else if (activeId.length < +props.max) {
+              activeId.push(item.id);
+            }
+          } else {
+            activeId = item.id;
+          }
+          emit("update:activeId", activeId);
+          emit("clickItem", item);
+        };
+        return vue.createVNode("div", {
+          "key": item.id,
+          "class": ["van-ellipsis", bem$1("item", {
+            active: isActiveItem(item.id),
+            disabled: item.disabled
+          })],
+          "onClick": onClick
+        }, [item.text, isActiveItem(item.id) && vue.createVNode(Icon, {
+          "name": props.selectedIcon,
+          "class": bem$1("selected")
+        }, null)]);
+      };
+      const onSidebarChange = (index) => {
+        emit("update:mainActiveIndex", index);
+      };
+      const onClickSidebarItem = (index) => emit("clickNav", index);
+      const renderSidebar = () => {
+        const Items = props.items.map((item) => vue.createVNode(SidebarItem, {
+          "dot": item.dot,
+          "badge": item.badge,
+          "class": [bem$1("nav-item"), item.className],
+          "disabled": item.disabled,
+          "onClick": onClickSidebarItem
+        }, {
+          title: () => slots["nav-text"] ? slots["nav-text"](item) : item.text
+        }));
+        return vue.createVNode(Sidebar, {
+          "class": bem$1("nav"),
+          "modelValue": props.mainActiveIndex,
+          "onChange": onSidebarChange
+        }, {
+          default: () => [Items]
+        });
+      };
+      const renderContent = () => {
+        if (slots.content) {
+          return slots.content();
+        }
+        const selected = props.items[+props.mainActiveIndex] || {};
+        if (selected.children) {
+          return selected.children.map(renderSubItem);
+        }
+      };
+      return () => vue.createVNode("div", {
+        "class": bem$1(),
+        "style": {
+          height: addUnit(props.height)
+        }
+      }, [renderSidebar(), vue.createVNode("div", {
+        "class": bem$1("content")
+      }, [renderContent()])]);
+    }
+  });
+  const TreeSelect = withInstall(stdin_default$6);
+  const [name, bem, t] = 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 toArray(items).some((item) => {
+      if (item.file) {
+        if (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;
+  }
+  var stdin_default$5 = vue.defineComponent({
+    props: {
+      name: numericProp,
+      item: makeRequiredProp(Object),
+      index: Number,
+      imageFit: String,
+      lazyLoad: Boolean,
+      deletable: Boolean,
+      previewSize: [Number, String, Array],
+      beforeDelete: Function
+    },
+    emits: ["delete", "preview"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const renderMask = () => {
+        const {
+          status,
+          message
+        } = props.item;
+        if (status === "uploading" || status === "failed") {
+          const MaskIcon = status === "failed" ? vue.createVNode(Icon, {
+            "name": "close",
+            "class": bem("mask-icon")
+          }, null) : vue.createVNode(Loading, {
+            "class": bem("loading")
+          }, null);
+          const showMessage = isDef(message) && message !== "";
+          return vue.createVNode("div", {
+            "class": bem("mask")
+          }, [MaskIcon, showMessage && vue.createVNode("div", {
+            "class": bem("mask-message")
+          }, [message])]);
+        }
+      };
+      const onDelete = (event) => {
+        const {
+          name: name2,
+          item,
+          index,
+          beforeDelete
+        } = props;
+        event.stopPropagation();
+        callInterceptor(beforeDelete, {
+          args: [item, {
+            name: name2,
+            index
+          }],
+          done: () => emit("delete")
+        });
+      };
+      const onPreview = () => emit("preview");
+      const renderDeleteIcon = () => {
+        if (props.deletable && props.item.status !== "uploading") {
+          const slot = slots["preview-delete"];
+          return vue.createVNode("div", {
+            "role": "button",
+            "class": bem("preview-delete", {
+              shadow: !slot
+            }),
+            "tabindex": 0,
+            "aria-label": t("delete"),
+            "onClick": onDelete
+          }, [slot ? slot() : vue.createVNode(Icon, {
+            "name": "cross",
+            "class": bem("preview-delete-icon")
+          }, null)]);
+        }
+      };
+      const renderCover = () => {
+        if (slots["preview-cover"]) {
+          const {
+            index,
+            item
+          } = props;
+          return vue.createVNode("div", {
+            "class": bem("preview-cover")
+          }, [slots["preview-cover"](extend({
+            index
+          }, item))]);
+        }
+      };
+      const renderPreview = () => {
+        const {
+          item,
+          lazyLoad,
+          imageFit,
+          previewSize
+        } = props;
+        if (isImageFile(item)) {
+          return vue.createVNode(Image$1, {
+            "fit": imageFit,
+            "src": item.content || item.url,
+            "class": bem("preview-image"),
+            "width": Array.isArray(previewSize) ? previewSize[0] : previewSize,
+            "height": Array.isArray(previewSize) ? previewSize[1] : previewSize,
+            "lazyLoad": lazyLoad,
+            "onClick": onPreview
+          }, {
+            default: renderCover
+          });
+        }
+        return vue.createVNode("div", {
+          "class": bem("file"),
+          "style": getSizeStyle(props.previewSize)
+        }, [vue.createVNode(Icon, {
+          "class": bem("file-icon"),
+          "name": "description"
+        }, null), vue.createVNode("div", {
+          "class": [bem("file-name"), "van-ellipsis"]
+        }, [item.file ? item.file.name : item.url]), renderCover()]);
+      };
+      return () => vue.createVNode("div", {
+        "class": bem("preview")
+      }, [renderPreview(), renderMask(), renderDeleteIcon()]);
+    }
+  });
+  const uploaderProps = {
+    name: makeNumericProp(""),
+    accept: makeStringProp("image/*"),
+    capture: String,
+    multiple: Boolean,
+    disabled: Boolean,
+    readonly: Boolean,
+    lazyLoad: Boolean,
+    maxCount: makeNumericProp(Infinity),
+    imageFit: makeStringProp("cover"),
+    resultType: makeStringProp("dataUrl"),
+    uploadIcon: makeStringProp("photograph"),
+    uploadText: String,
+    deletable: truthProp,
+    afterRead: Function,
+    showUpload: truthProp,
+    modelValue: makeArrayProp(),
+    beforeRead: Function,
+    beforeDelete: Function,
+    previewSize: [Number, String, Array],
+    previewImage: truthProp,
+    previewOptions: Object,
+    previewFullImage: truthProp,
+    maxSize: {
+      type: [Number, String, Function],
+      default: Infinity
+    }
+  };
+  var stdin_default$4 = vue.defineComponent({
+    name,
+    props: uploaderProps,
+    emits: ["delete", "oversize", "clickUpload", "closePreview", "clickPreview", "update:modelValue"],
+    setup(props, {
+      emit,
+      slots
+    }) {
+      const inputRef = vue.ref();
+      const urls = [];
+      const getDetail = (index = props.modelValue.length) => ({
+        name: props.name,
+        index
+      });
+      const resetInput = () => {
+        if (inputRef.value) {
+          inputRef.value.value = "";
+        }
+      };
+      const onAfterRead = (items) => {
+        resetInput();
+        if (isOversize(items, props.maxSize)) {
+          if (Array.isArray(items)) {
+            const result = filterFiles(items, props.maxSize);
+            items = result.valid;
+            emit("oversize", result.invalid, getDetail());
+            if (!items.length) {
+              return;
+            }
+          } else {
+            emit("oversize", items, getDetail());
+            return;
+          }
+        }
+        items = vue.reactive(items);
+        emit("update:modelValue", [...props.modelValue, ...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) => readFileContent(file, resultType))).then((contents) => {
+            const fileList = files.map((file, index) => {
+              const result = {
+                file,
+                status: "",
+                message: ""
+              };
+              if (contents[index]) {
+                result.content = contents[index];
+              }
+              return result;
+            });
+            onAfterRead(fileList);
+          });
+        } else {
+          readFileContent(files, resultType).then((content) => {
+            const result = {
+              file: files,
+              status: "",
+              message: ""
+            };
+            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 (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(isImageFile);
+          const images = imageFiles.map((item2) => {
+            if (item2.file && !item2.url && item2.status !== "failed") {
+              item2.url = URL.createObjectURL(item2.file);
+              urls.push(item2.url);
+            }
+            return item2.url;
+          }).filter(Boolean);
+          imagePreview = showImagePreview(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 renderPreviewItem = (item, index) => {
+        const needPickData = ["imageFit", "deletable", "previewSize", "beforeDelete"];
+        const previewData = extend(pick(props, needPickData), pick(item, needPickData, true));
+        return vue.createVNode(stdin_default$5, vue.mergeProps({
+          "item": item,
+          "index": index,
+          "onClick": () => emit("clickPreview", item, getDetail(index)),
+          "onDelete": () => deleteFile(item, index),
+          "onPreview": () => previewImage(item)
+        }, pick(props, ["name", "lazyLoad"]), previewData), pick(slots, ["preview-cover", "preview-delete"]));
+      };
+      const renderPreviewList = () => {
+        if (props.previewImage) {
+          return props.modelValue.map(renderPreviewItem);
+        }
+      };
+      const onClickUpload = (event) => emit("clickUpload", event);
+      const renderUpload = () => {
+        if (props.modelValue.length >= +props.maxCount) {
+          return;
+        }
+        const Input = props.readonly ? null : vue.createVNode("input", {
+          "ref": inputRef,
+          "type": "file",
+          "class": bem("input"),
+          "accept": props.accept,
+          "capture": props.capture,
+          "multiple": props.multiple,
+          "disabled": props.disabled,
+          "onChange": onChange
+        }, null);
+        if (slots.default) {
+          return vue.createVNode("div", {
+            "class": bem("input-wrapper"),
+            "onClick": onClickUpload
+          }, [slots.default(), Input]);
+        }
+        return vue.withDirectives(vue.createVNode("div", {
+          "class": bem("upload", {
+            readonly: props.readonly
+          }),
+          "style": getSizeStyle(props.previewSize),
+          "onClick": onClickUpload
+        }, [vue.createVNode(Icon, {
+          "name": props.uploadIcon,
+          "class": bem("upload-icon")
+        }, null), props.uploadText && vue.createVNode("span", {
+          "class": bem("upload-text")
+        }, [props.uploadText]), Input]), [[vue.vShow, props.showUpload]]);
+      };
+      const chooseFile = () => {
+        if (inputRef.value && !props.disabled) {
+          inputRef.value.click();
+        }
+      };
+      vue.onBeforeUnmount(() => {
+        urls.forEach((url) => URL.revokeObjectURL(url));
+      });
+      useExpose({
+        chooseFile,
+        closeImagePreview
+      });
+      useCustomFieldValue(() => props.modelValue);
+      return () => vue.createVNode("div", {
+        "class": bem()
+      }, [vue.createVNode("div", {
+        "class": bem("wrapper", {
+          disabled: props.disabled
+        })
+      }, [renderPreviewList(), renderUpload()])]);
+    }
+  });
+  const Uploader = withInstall(stdin_default$4);
+  class ReactiveListener {
+    constructor({
+      el,
+      src,
+      error,
+      loading,
+      bindType,
+      $parent,
+      options,
+      cors,
+      elRenderer,
+      imageCache
+    }) {
+      this.el = el;
+      this.src = src;
+      this.error = error;
+      this.loading = loading;
+      this.bindType = bindType;
+      this.attempt = 0;
+      this.cors = cors;
+      this.naturalHeight = 0;
+      this.naturalWidth = 0;
+      this.options = options;
+      this.$parent = $parent;
+      this.elRenderer = elRenderer;
+      this.imageCache = imageCache;
+      this.performanceData = {
+        loadStart: 0,
+        loadEnd: 0
+      };
+      this.filter();
+      this.initState();
+      this.render("loading", false);
+    }
+    /*
+     * init listener state
+     * @return
+     */
+    initState() {
+      if ("dataset" in this.el) {
+        this.el.dataset.src = this.src;
+      } else {
+        this.el.setAttribute("data-src", this.src);
+      }
+      this.state = {
+        loading: false,
+        error: false,
+        loaded: false,
+        rendered: false
+      };
+    }
+    /*
+     * record performance
+     * @return
+     */
+    record(event) {
+      this.performanceData[event] = Date.now();
+    }
+    /*
+     * update image listener data
+     * @param  {String} image uri
+     * @param  {String} loading image uri
+     * @param  {String} error image uri
+     * @return
+     */
+    update({ src, loading, error }) {
+      const oldSrc = this.src;
+      this.src = src;
+      this.loading = loading;
+      this.error = error;
+      this.filter();
+      if (oldSrc !== this.src) {
+        this.attempt = 0;
+        this.initState();
+      }
+    }
+    /*
+     *  check el is in view
+     * @return {Boolean} el is in view
+     */
+    checkInView() {
+      const rect = useRect(this.el);
+      return rect.top < window.innerHeight * this.options.preLoad && rect.bottom > this.options.preLoadTop && rect.left < window.innerWidth * this.options.preLoad && rect.right > 0;
+    }
+    /*
+     * listener filter
+     */
+    filter() {
+      Object.keys(this.options.filter).forEach((key) => {
+        this.options.filter[key](this, this.options);
+      });
+    }
+    /*
+     * render loading first
+     * @params cb:Function
+     * @return
+     */
+    renderLoading(cb) {
+      this.state.loading = true;
+      loadImageAsync(
+        {
+          src: this.loading,
+          cors: this.cors
+        },
+        () => {
+          this.render("loading", false);
+          this.state.loading = false;
+          cb();
+        },
+        () => {
+          cb();
+          this.state.loading = false;
+        }
+      );
+    }
+    /*
+     * try load image and  render it
+     * @return
+     */
+    load(onFinish = noop) {
+      if (this.attempt > this.options.attempt - 1 && this.state.error) {
+        onFinish();
+        return;
+      }
+      if (this.state.rendered && this.state.loaded)
+        return;
+      if (this.imageCache.has(this.src)) {
+        this.state.loaded = true;
+        this.render("loaded", true);
+        this.state.rendered = true;
+        return onFinish();
+      }
+      this.renderLoading(() => {
+        var _a, _b;
+        this.attempt++;
+        (_b = (_a = this.options.adapter).beforeLoad) == null ? void 0 : _b.call(_a, this, this.options);
+        this.record("loadStart");
+        loadImageAsync(
+          {
+            src: this.src,
+            cors: this.cors
+          },
+          (data) => {
+            this.naturalHeight = data.naturalHeight;
+            this.naturalWidth = data.naturalWidth;
+            this.state.loaded = true;
+            this.state.error = false;
+            this.record("loadEnd");
+            this.render("loaded", false);
+            this.state.rendered = true;
+            this.imageCache.add(this.src);
+            onFinish();
+          },
+          (err) => {
+            !this.options.silent && console.error(err);
+            this.state.error = true;
+            this.state.loaded = false;
+            this.render("error", false);
+          }
+        );
+      });
+    }
+    /*
+     * render image
+     * @param  {String} state to render // ['loading', 'src', 'error']
+     * @param  {String} is form cache
+     * @return
+     */
+    render(state, cache) {
+      this.elRenderer(this, state, cache);
+    }
+    /*
+     * output performance data
+     * @return {Object} performance data
+     */
+    performance() {
+      let state = "loading";
+      let time = 0;
+      if (this.state.loaded) {
+        state = "loaded";
+        time = (this.performanceData.loadEnd - this.performanceData.loadStart) / 1e3;
+      }
+      if (this.state.error)
+        state = "error";
+      return {
+        src: this.src,
+        state,
+        time
+      };
+    }
+    /*
+     * $destroy
+     * @return
+     */
+    $destroy() {
+      this.el = null;
+      this.src = null;
+      this.error = null;
+      this.loading = null;
+      this.bindType = null;
+      this.attempt = 0;
+    }
+  }
+  const DEFAULT_URL = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
+  const DEFAULT_EVENTS = [
+    "scroll",
+    "wheel",
+    "mousewheel",
+    "resize",
+    "animationend",
+    "transitionend",
+    "touchmove"
+  ];
+  const DEFAULT_OBSERVER_OPTIONS = {
+    rootMargin: "0px",
+    threshold: 0
+  };
+  function stdin_default$3() {
+    return class Lazy {
+      constructor({
+        preLoad,
+        error,
+        throttleWait,
+        preLoadTop,
+        dispatchEvent,
+        loading,
+        attempt,
+        silent = true,
+        scale,
+        listenEvents,
+        filter,
+        adapter,
+        observer,
+        observerOptions
+      }) {
+        this.mode = modeType.event;
+        this.listeners = [];
+        this.targetIndex = 0;
+        this.targets = [];
+        this.options = {
+          silent,
+          dispatchEvent: !!dispatchEvent,
+          throttleWait: throttleWait || 200,
+          preLoad: preLoad || 1.3,
+          preLoadTop: preLoadTop || 0,
+          error: error || DEFAULT_URL,
+          loading: loading || DEFAULT_URL,
+          attempt: attempt || 3,
+          scale: scale || getDPR(scale),
+          ListenEvents: listenEvents || DEFAULT_EVENTS,
+          supportWebp: supportWebp(),
+          filter: filter || {},
+          adapter: adapter || {},
+          observer: !!observer,
+          observerOptions: observerOptions || DEFAULT_OBSERVER_OPTIONS
+        };
+        this.initEvent();
+        this.imageCache = new ImageCache({ max: 200 });
+        this.lazyLoadHandler = throttle(
+          this.lazyLoadHandler.bind(this),
+          this.options.throttleWait
+        );
+        this.setMode(this.options.observer ? modeType.observer : modeType.event);
+      }
+      /**
+       * update config
+       * @param  {Object} config params
+       * @return
+       */
+      config(options = {}) {
+        Object.assign(this.options, options);
+      }
+      /**
+       * output listener's load performance
+       * @return {Array}
+       */
+      performance() {
+        return this.listeners.map((item) => item.performance());
+      }
+      /*
+       * add lazy component to queue
+       * @param  {Vue} vm lazy component instance
+       * @return
+       */
+      addLazyBox(vm) {
+        this.listeners.push(vm);
+        if (inBrowser) {
+          this.addListenerTarget(window);
+          this.observer && this.observer.observe(vm.el);
+          if (vm.$el && vm.$el.parentNode) {
+            this.addListenerTarget(vm.$el.parentNode);
+          }
+        }
+      }
+      /*
+       * add image listener to queue
+       * @param  {DOM} el
+       * @param  {object} binding vue directive binding
+       * @param  {vnode} vnode vue directive vnode
+       * @return
+       */
+      add(el, binding, vnode) {
+        if (this.listeners.some((item) => item.el === el)) {
+          this.update(el, binding);
+          return vue.nextTick(this.lazyLoadHandler);
+        }
+        const value = this.valueFormatter(binding.value);
+        let { src } = value;
+        vue.nextTick(() => {
+          src = getBestSelectionFromSrcset(el, this.options.scale) || src;
+          this.observer && this.observer.observe(el);
+          const container = Object.keys(binding.modifiers)[0];
+          let $parent;
+          if (container) {
+            $parent = vnode.context.$refs[container];
+            $parent = $parent ? $parent.$el || $parent : document.getElementById(container);
+          }
+          if (!$parent) {
+            $parent = getScrollParent$1(el);
+          }
+          const newListener = new ReactiveListener({
+            bindType: binding.arg,
+            $parent,
+            el,
+            src,
+            loading: value.loading,
+            error: value.error,
+            cors: value.cors,
+            elRenderer: this.elRenderer.bind(this),
+            options: this.options,
+            imageCache: this.imageCache
+          });
+          this.listeners.push(newListener);
+          if (inBrowser) {
+            this.addListenerTarget(window);
+            this.addListenerTarget($parent);
+          }
+          this.lazyLoadHandler();
+          vue.nextTick(() => this.lazyLoadHandler());
+        });
+      }
+      /**
+       * update image src
+       * @param  {DOM} el
+       * @param  {object} vue directive binding
+       * @return
+       */
+      update(el, binding, vnode) {
+        const value = this.valueFormatter(binding.value);
+        let { src } = value;
+        src = getBestSelectionFromSrcset(el, this.options.scale) || src;
+        const exist = this.listeners.find((item) => item.el === el);
+        if (!exist) {
+          this.add(el, binding, vnode);
+        } else {
+          exist.update({
+            src,
+            error: value.error,
+            loading: value.loading
+          });
+        }
+        if (this.observer) {
+          this.observer.unobserve(el);
+          this.observer.observe(el);
+        }
+        this.lazyLoadHandler();
+        vue.nextTick(() => this.lazyLoadHandler());
+      }
+      /**
+       * remove listener form list
+       * @param  {DOM} el
+       * @return
+       */
+      remove(el) {
+        if (!el)
+          return;
+        this.observer && this.observer.unobserve(el);
+        const existItem = this.listeners.find((item) => item.el === el);
+        if (existItem) {
+          this.removeListenerTarget(existItem.$parent);
+          this.removeListenerTarget(window);
+          remove(this.listeners, existItem);
+          existItem.$destroy();
+        }
+      }
+      /*
+       * remove lazy components form list
+       * @param  {Vue} vm Vue instance
+       * @return
+       */
+      removeComponent(vm) {
+        if (!vm)
+          return;
+        remove(this.listeners, vm);
+        this.observer && this.observer.unobserve(vm.el);
+        if (vm.$parent && vm.$el.parentNode) {
+          this.removeListenerTarget(vm.$el.parentNode);
+        }
+        this.removeListenerTarget(window);
+      }
+      setMode(mode) {
+        if (!hasIntersectionObserver && mode === modeType.observer) {
+          mode = modeType.event;
+        }
+        this.mode = mode;
+        if (mode === modeType.event) {
+          if (this.observer) {
+            this.listeners.forEach((listener) => {
+              this.observer.unobserve(listener.el);
+            });
+            this.observer = null;
+          }
+          this.targets.forEach((target) => {
+            this.initListen(target.el, true);
+          });
+        } else {
+          this.targets.forEach((target) => {
+            this.initListen(target.el, false);
+          });
+          this.initIntersectionObserver();
+        }
+      }
+      /*
+       *** Private functions ***
+       */
+      /*
+       * add listener target
+       * @param  {DOM} el listener target
+       * @return
+       */
+      addListenerTarget(el) {
+        if (!el)
+          return;
+        let target = this.targets.find((target2) => target2.el === el);
+        if (!target) {
+          target = {
+            el,
+            id: ++this.targetIndex,
+            childrenCount: 1,
+            listened: true
+          };
+          this.mode === modeType.event && this.initListen(target.el, true);
+          this.targets.push(target);
+        } else {
+          target.childrenCount++;
+        }
+        return this.targetIndex;
+      }
+      /*
+       * remove listener target or reduce target childrenCount
+       * @param  {DOM} el or window
+       * @return
+       */
+      removeListenerTarget(el) {
+        this.targets.forEach((target, index) => {
+          if (target.el === el) {
+            target.childrenCount--;
+            if (!target.childrenCount) {
+              this.initListen(target.el, false);
+              this.targets.splice(index, 1);
+              target = null;
+            }
+          }
+        });
+      }
+      /*
+       * add or remove eventlistener
+       * @param  {DOM} el DOM or Window
+       * @param  {boolean} start flag
+       * @return
+       */
+      initListen(el, start2) {
+        this.options.ListenEvents.forEach(
+          (evt) => (start2 ? on : off)(el, evt, this.lazyLoadHandler)
+        );
+      }
+      initEvent() {
+        this.Event = {
+          listeners: {
+            loading: [],
+            loaded: [],
+            error: []
+          }
+        };
+        this.$on = (event, func) => {
+          if (!this.Event.listeners[event])
+            this.Event.listeners[event] = [];
+          this.Event.listeners[event].push(func);
+        };
+        this.$once = (event, func) => {
+          const on2 = (...args) => {
+            this.$off(event, on2);
+            func.apply(this, args);
+          };
+          this.$on(event, on2);
+        };
+        this.$off = (event, func) => {
+          if (!func) {
+            if (!this.Event.listeners[event])
+              return;
+            this.Event.listeners[event].length = 0;
+            return;
+          }
+          remove(this.Event.listeners[event], func);
+        };
+        this.$emit = (event, context, inCache) => {
+          if (!this.Event.listeners[event])
+            return;
+          this.Event.listeners[event].forEach((func) => func(context, inCache));
+        };
+      }
+      /**
+       * find nodes which in viewport and trigger load
+       * @return
+       */
+      lazyLoadHandler() {
+        const freeList = [];
+        this.listeners.forEach((listener) => {
+          if (!listener.el || !listener.el.parentNode) {
+            freeList.push(listener);
+          }
+          const catIn = listener.checkInView();
+          if (!catIn)
+            return;
+          listener.load();
+        });
+        freeList.forEach((item) => {
+          remove(this.listeners, item);
+          item.$destroy();
+        });
+      }
+      /**
+       * init IntersectionObserver
+       * set mode to observer
+       * @return
+       */
+      initIntersectionObserver() {
+        if (!hasIntersectionObserver) {
+          return;
+        }
+        this.observer = new IntersectionObserver(
+          this.observerHandler.bind(this),
+          this.options.observerOptions
+        );
+        if (this.listeners.length) {
+          this.listeners.forEach((listener) => {
+            this.observer.observe(listener.el);
+          });
+        }
+      }
+      /**
+       * init IntersectionObserver
+       * @return
+       */
+      observerHandler(entries) {
+        entries.forEach((entry) => {
+          if (entry.isIntersecting) {
+            this.listeners.forEach((listener) => {
+              if (listener.el === entry.target) {
+                if (listener.state.loaded)
+                  return this.observer.unobserve(listener.el);
+                listener.load();
+              }
+            });
+          }
+        });
+      }
+      /**
+       * set element attribute with image'url and state
+       * @param  {object} lazyload listener object
+       * @param  {string} state will be rendered
+       * @param  {bool} inCache  is rendered from cache
+       * @return
+       */
+      elRenderer(listener, state, cache) {
+        if (!listener.el)
+          return;
+        const { el, bindType } = listener;
+        let src;
+        switch (state) {
+          case "loading":
+            src = listener.loading;
+            break;
+          case "error":
+            src = listener.error;
+            break;
+          default:
+            ({ src } = listener);
+            break;
+        }
+        if (bindType) {
+          el.style[bindType] = 'url("' + src + '")';
+        } else if (el.getAttribute("src") !== src) {
+          el.setAttribute("src", src);
+        }
+        el.setAttribute("lazy", state);
+        this.$emit(state, listener, cache);
+        this.options.adapter[state] && this.options.adapter[state](listener, this.options);
+        if (this.options.dispatchEvent) {
+          const event = new CustomEvent(state, {
+            detail: listener
+          });
+          el.dispatchEvent(event);
+        }
+      }
+      /**
+       * generate loading loaded error image url
+       * @param {string} image's src
+       * @return {object} image's loading, loaded, error url
+       */
+      valueFormatter(value) {
+        let src = value;
+        let { loading, error } = this.options;
+        if (isObject(value)) {
+          ({ src } = value);
+          loading = value.loading || this.options.loading;
+          error = value.error || this.options.error;
+        }
+        return {
+          src,
+          loading,
+          error
+        };
+      }
+    };
+  }
+  var stdin_default$2 = (lazy) => ({
+    props: {
+      tag: {
+        type: String,
+        default: "div"
+      }
+    },
+    emits: ["show"],
+    render() {
+      return vue.h(
+        this.tag,
+        this.show && this.$slots.default ? this.$slots.default() : null
+      );
+    },
+    data() {
+      return {
+        el: null,
+        state: {
+          loaded: false
+        },
+        show: false
+      };
+    },
+    mounted() {
+      this.el = this.$el;
+      lazy.addLazyBox(this);
+      lazy.lazyLoadHandler();
+    },
+    beforeUnmount() {
+      lazy.removeComponent(this);
+    },
+    methods: {
+      checkInView() {
+        const rect = useRect(this.$el);
+        return inBrowser && rect.top < window.innerHeight * lazy.options.preLoad && rect.bottom > 0 && rect.left < window.innerWidth * lazy.options.preLoad && rect.right > 0;
+      },
+      load() {
+        this.show = true;
+        this.state.loaded = true;
+        this.$emit("show", this);
+      },
+      destroy() {
+        return this.$destroy;
+      }
+    }
+  });
+  const defaultOptions = {
+    selector: "img"
+  };
+  class LazyContainer {
+    constructor({ el, binding, vnode, lazy }) {
+      this.el = null;
+      this.vnode = vnode;
+      this.binding = binding;
+      this.options = {};
+      this.lazy = lazy;
+      this.queue = [];
+      this.update({ el, binding });
+    }
+    update({ el, binding }) {
+      this.el = el;
+      this.options = Object.assign({}, defaultOptions, binding.value);
+      const imgs = this.getImgs();
+      imgs.forEach((el2) => {
+        this.lazy.add(
+          el2,
+          Object.assign({}, this.binding, {
+            value: {
+              src: "dataset" in el2 ? el2.dataset.src : el2.getAttribute("data-src"),
+              error: ("dataset" in el2 ? el2.dataset.error : el2.getAttribute("data-error")) || this.options.error,
+              loading: ("dataset" in el2 ? el2.dataset.loading : el2.getAttribute("data-loading")) || this.options.loading
+            }
+          }),
+          this.vnode
+        );
+      });
+    }
+    getImgs() {
+      return Array.from(this.el.querySelectorAll(this.options.selector));
+    }
+    clear() {
+      const imgs = this.getImgs();
+      imgs.forEach((el) => this.lazy.remove(el));
+      this.vnode = null;
+      this.binding = null;
+      this.lazy = null;
+    }
+  }
+  class LazyContainerManager {
+    constructor({ lazy }) {
+      this.lazy = lazy;
+      this.queue = [];
+    }
+    bind(el, binding, vnode) {
+      const container = new LazyContainer({
+        el,
+        binding,
+        vnode,
+        lazy: this.lazy
+      });
+      this.queue.push(container);
+    }
+    update(el, binding, vnode) {
+      const container = this.queue.find((item) => item.el === el);
+      if (!container)
+        return;
+      container.update({ el, binding, vnode });
+    }
+    unbind(el) {
+      const container = this.queue.find((item) => item.el === el);
+      if (!container)
+        return;
+      container.clear();
+      remove(this.queue, container);
+    }
+  }
+  var stdin_default$1 = (lazyManager) => ({
+    props: {
+      src: [String, Object],
+      tag: {
+        type: String,
+        default: "img"
+      }
+    },
+    render() {
+      var _a, _b;
+      return vue.h(
+        this.tag,
+        {
+          src: this.renderSrc
+        },
+        (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)
+      );
+    },
+    data() {
+      return {
+        el: null,
+        options: {
+          src: "",
+          error: "",
+          loading: "",
+          attempt: lazyManager.options.attempt
+        },
+        state: {
+          loaded: false,
+          error: false,
+          attempt: 0
+        },
+        renderSrc: ""
+      };
+    },
+    watch: {
+      src() {
+        this.init();
+        lazyManager.addLazyBox(this);
+        lazyManager.lazyLoadHandler();
+      }
+    },
+    created() {
+      this.init();
+    },
+    mounted() {
+      this.el = this.$el;
+      lazyManager.addLazyBox(this);
+      lazyManager.lazyLoadHandler();
+    },
+    beforeUnmount() {
+      lazyManager.removeComponent(this);
+    },
+    methods: {
+      init() {
+        const { src, loading, error } = lazyManager.valueFormatter(this.src);
+        this.state.loaded = false;
+        this.options.src = src;
+        this.options.error = error;
+        this.options.loading = loading;
+        this.renderSrc = this.options.loading;
+      },
+      checkInView() {
+        const rect = useRect(this.$el);
+        return rect.top < window.innerHeight * lazyManager.options.preLoad && rect.bottom > 0 && rect.left < window.innerWidth * lazyManager.options.preLoad && rect.right > 0;
+      },
+      load(onFinish = noop) {
+        if (this.state.attempt > this.options.attempt - 1 && this.state.error) {
+          onFinish();
+          return;
+        }
+        const { src } = this.options;
+        loadImageAsync(
+          { src },
+          ({ src: src2 }) => {
+            this.renderSrc = src2;
+            this.state.loaded = true;
+          },
+          () => {
+            this.state.attempt++;
+            this.renderSrc = this.options.error;
+            this.state.error = true;
+          }
+        );
+      }
+    }
+  });
+  const Lazyload = {
+    /*
+     * install function
+     * @param  {App} app
+     * @param  {object} options lazyload options
+     */
+    install(app, options = {}) {
+      const LazyClass = stdin_default$3();
+      const lazy = new LazyClass(options);
+      const lazyContainer = new LazyContainerManager({ lazy });
+      app.config.globalProperties.$Lazyload = lazy;
+      if (options.lazyComponent) {
+        app.component("LazyComponent", stdin_default$2(lazy));
+      }
+      if (options.lazyImage) {
+        app.component("LazyImage", stdin_default$1(lazy));
+      }
+      app.directive("lazy", {
+        beforeMount: lazy.add.bind(lazy),
+        updated: lazy.update.bind(lazy),
+        unmounted: lazy.remove.bind(lazy)
+      });
+      app.directive("lazy-container", {
+        beforeMount: lazyContainer.bind.bind(lazyContainer),
+        updated: lazyContainer.update.bind(lazyContainer),
+        unmounted: lazyContainer.unbind.bind(lazyContainer)
+      });
+    }
+  };
+  const version = "4.1.2";
+  function install(app) {
+    const components = [
+      ActionBar,
+      ActionBarButton,
+      ActionBarIcon,
+      ActionSheet,
+      AddressEdit,
+      AddressList,
+      Area,
+      BackTop,
+      Badge,
+      Button,
+      Calendar,
+      Card,
+      Cascader,
+      Cell,
+      CellGroup,
+      Checkbox,
+      CheckboxGroup,
+      Circle,
+      Col,
+      Collapse,
+      CollapseItem,
+      ConfigProvider,
+      ContactCard,
+      ContactEdit,
+      ContactList,
+      CountDown,
+      Coupon,
+      CouponCell,
+      CouponList,
+      DatePicker,
+      Dialog,
+      Divider,
+      DropdownItem,
+      DropdownMenu,
+      Empty,
+      Field,
+      Form,
+      Grid,
+      GridItem,
+      Icon,
+      Image$1,
+      ImagePreview,
+      IndexAnchor,
+      IndexBar,
+      List,
+      Loading,
+      Locale,
+      NavBar,
+      NoticeBar,
+      Notify,
+      NumberKeyboard,
+      Overlay,
+      Pagination,
+      PasswordInput,
+      Picker,
+      PickerGroup,
+      Popover,
+      Popup,
+      Progress,
+      PullRefresh,
+      Radio,
+      RadioGroup,
+      Rate,
+      Row,
+      Search,
+      ShareSheet,
+      Sidebar,
+      SidebarItem,
+      Skeleton,
+      SkeletonAvatar,
+      SkeletonImage,
+      SkeletonParagraph,
+      SkeletonTitle,
+      Slider,
+      Space,
+      Step,
+      Stepper,
+      Steps,
+      Sticky,
+      SubmitBar,
+      Swipe,
+      SwipeCell,
+      SwipeItem,
+      Switch,
+      Tab,
+      Tabbar,
+      TabbarItem,
+      Tabs,
+      Tag,
+      TextEllipsis,
+      TimePicker,
+      Toast,
+      TreeSelect,
+      Uploader
+    ];
+    components.forEach((item) => {
+      if (item.install) {
+        app.use(item);
+      } else if (item.name) {
+        app.component(item.name, item);
+      }
+    });
+  }
+  var stdin_default = {
+    install,
+    version
+  };
+  exports2.ActionBar = ActionBar;
+  exports2.ActionBarButton = ActionBarButton;
+  exports2.ActionBarIcon = ActionBarIcon;
+  exports2.ActionSheet = ActionSheet;
+  exports2.AddressEdit = AddressEdit;
+  exports2.AddressList = AddressList;
+  exports2.Area = Area;
+  exports2.BackTop = BackTop;
+  exports2.Badge = Badge;
+  exports2.Button = Button;
+  exports2.Calendar = Calendar;
+  exports2.Card = Card;
+  exports2.Cascader = Cascader;
+  exports2.Cell = Cell;
+  exports2.CellGroup = CellGroup;
+  exports2.Checkbox = Checkbox;
+  exports2.CheckboxGroup = CheckboxGroup;
+  exports2.Circle = Circle;
+  exports2.Col = Col;
+  exports2.Collapse = Collapse;
+  exports2.CollapseItem = CollapseItem;
+  exports2.ConfigProvider = ConfigProvider;
+  exports2.ContactCard = ContactCard;
+  exports2.ContactEdit = ContactEdit;
+  exports2.ContactList = ContactList;
+  exports2.CountDown = CountDown;
+  exports2.Coupon = Coupon;
+  exports2.CouponCell = CouponCell;
+  exports2.CouponList = CouponList;
+  exports2.DEFAULT_ROW_WIDTH = DEFAULT_ROW_WIDTH;
+  exports2.DatePicker = DatePicker;
+  exports2.Dialog = Dialog;
+  exports2.Divider = Divider;
+  exports2.DropdownItem = DropdownItem;
+  exports2.DropdownMenu = DropdownMenu;
+  exports2.Empty = Empty;
+  exports2.Field = Field;
+  exports2.Form = Form;
+  exports2.Grid = Grid;
+  exports2.GridItem = GridItem;
+  exports2.Icon = Icon;
+  exports2.Image = Image$1;
+  exports2.ImagePreview = ImagePreview;
+  exports2.IndexAnchor = IndexAnchor;
+  exports2.IndexBar = IndexBar;
+  exports2.Lazyload = Lazyload;
+  exports2.List = List;
+  exports2.Loading = Loading;
+  exports2.Locale = Locale;
+  exports2.NavBar = NavBar;
+  exports2.NoticeBar = NoticeBar;
+  exports2.Notify = Notify;
+  exports2.NumberKeyboard = NumberKeyboard;
+  exports2.Overlay = Overlay;
+  exports2.Pagination = Pagination;
+  exports2.PasswordInput = PasswordInput;
+  exports2.Picker = Picker;
+  exports2.PickerGroup = PickerGroup;
+  exports2.Popover = Popover;
+  exports2.Popup = Popup;
+  exports2.Progress = Progress;
+  exports2.PullRefresh = PullRefresh;
+  exports2.Radio = Radio;
+  exports2.RadioGroup = RadioGroup;
+  exports2.Rate = Rate;
+  exports2.Row = Row;
+  exports2.Search = Search;
+  exports2.ShareSheet = ShareSheet;
+  exports2.Sidebar = Sidebar;
+  exports2.SidebarItem = SidebarItem;
+  exports2.Skeleton = Skeleton;
+  exports2.SkeletonAvatar = SkeletonAvatar;
+  exports2.SkeletonImage = SkeletonImage;
+  exports2.SkeletonParagraph = SkeletonParagraph;
+  exports2.SkeletonTitle = SkeletonTitle;
+  exports2.Slider = Slider;
+  exports2.Space = Space;
+  exports2.Step = Step;
+  exports2.Stepper = Stepper;
+  exports2.Steps = Steps;
+  exports2.Sticky = Sticky;
+  exports2.SubmitBar = SubmitBar;
+  exports2.Swipe = Swipe;
+  exports2.SwipeCell = SwipeCell;
+  exports2.SwipeItem = SwipeItem;
+  exports2.Switch = Switch;
+  exports2.Tab = Tab;
+  exports2.Tabbar = Tabbar;
+  exports2.TabbarItem = TabbarItem;
+  exports2.Tabs = Tabs;
+  exports2.Tag = Tag;
+  exports2.TextEllipsis = TextEllipsis;
+  exports2.TimePicker = TimePicker;
+  exports2.Toast = Toast;
+  exports2.TreeSelect = TreeSelect;
+  exports2.Uploader = Uploader;
+  exports2.actionBarButtonProps = actionBarButtonProps;
+  exports2.actionBarIconProps = actionBarIconProps;
+  exports2.actionBarProps = actionBarProps;
+  exports2.actionSheetProps = actionSheetProps;
+  exports2.addressEditProps = addressEditProps;
+  exports2.addressListProps = addressListProps;
+  exports2.allowMultipleToast = allowMultipleToast;
+  exports2.areaProps = areaProps;
+  exports2.backTopProps = backTopProps;
+  exports2.badgeProps = badgeProps;
+  exports2.buttonProps = buttonProps;
+  exports2.calendarProps = calendarProps;
+  exports2.cardProps = cardProps;
+  exports2.cascaderProps = cascaderProps;
+  exports2.cellGroupProps = cellGroupProps;
+  exports2.cellProps = cellProps;
+  exports2.checkboxGroupProps = checkboxGroupProps;
+  exports2.checkboxProps = checkboxProps;
+  exports2.circleProps = circleProps;
+  exports2.closeDialog = closeDialog;
+  exports2.closeNotify = closeNotify;
+  exports2.closeToast = closeToast;
+  exports2.colProps = colProps;
+  exports2.collapseItemProps = collapseItemProps;
+  exports2.collapseProps = collapseProps;
+  exports2.configProviderProps = configProviderProps;
+  exports2.contactCardProps = contactCardProps;
+  exports2.contactEditProps = contactEditProps;
+  exports2.contactListProps = contactListProps;
+  exports2.countDownProps = countDownProps;
+  exports2.couponCellProps = couponCellProps;
+  exports2.couponListProps = couponListProps;
+  exports2.datePickerProps = datePickerProps;
+  exports2.default = stdin_default;
+  exports2.dialogProps = dialogProps;
+  exports2.dividerProps = dividerProps;
+  exports2.dropdownItemProps = dropdownItemProps;
+  exports2.dropdownMenuProps = dropdownMenuProps;
+  exports2.emptyProps = emptyProps;
+  exports2.fieldProps = fieldProps;
+  exports2.formProps = formProps;
+  exports2.gridItemProps = gridItemProps;
+  exports2.gridProps = gridProps;
+  exports2.iconProps = iconProps;
+  exports2.imagePreviewProps = imagePreviewProps;
+  exports2.imageProps = imageProps;
+  exports2.indexAnchorProps = indexAnchorProps;
+  exports2.indexBarProps = indexBarProps;
+  exports2.install = install;
+  exports2.listProps = listProps;
+  exports2.loadingProps = loadingProps;
+  exports2.navBarProps = navBarProps;
+  exports2.noticeBarProps = noticeBarProps;
+  exports2.notifyProps = notifyProps;
+  exports2.numberKeyboardProps = numberKeyboardProps;
+  exports2.overlayProps = overlayProps;
+  exports2.paginationProps = paginationProps;
+  exports2.passwordInputProps = passwordInputProps;
+  exports2.pickerGroupProps = pickerGroupProps;
+  exports2.pickerProps = pickerProps;
+  exports2.popoverProps = popoverProps;
+  exports2.popupProps = popupProps$2;
+  exports2.progressProps = progressProps;
+  exports2.pullRefreshProps = pullRefreshProps;
+  exports2.radioGroupProps = radioGroupProps;
+  exports2.radioProps = radioProps;
+  exports2.rateProps = rateProps;
+  exports2.resetDialogDefaultOptions = resetDialogDefaultOptions;
+  exports2.resetNotifyDefaultOptions = resetNotifyDefaultOptions;
+  exports2.resetToastDefaultOptions = resetToastDefaultOptions;
+  exports2.rowProps = rowProps;
+  exports2.searchProps = searchProps;
+  exports2.setDialogDefaultOptions = setDialogDefaultOptions;
+  exports2.setNotifyDefaultOptions = setNotifyDefaultOptions;
+  exports2.setToastDefaultOptions = setToastDefaultOptions;
+  exports2.shareSheetProps = shareSheetProps;
+  exports2.showConfirmDialog = showConfirmDialog;
+  exports2.showDialog = showDialog;
+  exports2.showFailToast = showFailToast;
+  exports2.showImagePreview = showImagePreview;
+  exports2.showLoadingToast = showLoadingToast;
+  exports2.showNotify = showNotify;
+  exports2.showSuccessToast = showSuccessToast;
+  exports2.showToast = showToast;
+  exports2.sidebarItemProps = sidebarItemProps;
+  exports2.sidebarProps = sidebarProps;
+  exports2.skeletonAvatarProps = skeletonAvatarProps;
+  exports2.skeletonImageProps = skeletonImageProps;
+  exports2.skeletonParagraphProps = skeletonParagraphProps;
+  exports2.skeletonProps = skeletonProps;
+  exports2.skeletonTitleProps = skeletonTitleProps;
+  exports2.sliderProps = sliderProps;
+  exports2.spaceProps = spaceProps;
+  exports2.stepperProps = stepperProps;
+  exports2.stepsProps = stepsProps;
+  exports2.stickyProps = stickyProps;
+  exports2.submitBarProps = submitBarProps;
+  exports2.swipeCellProps = swipeCellProps;
+  exports2.swipeProps = swipeProps;
+  exports2.switchProps = switchProps;
+  exports2.tabProps = tabProps;
+  exports2.tabbarItemProps = tabbarItemProps;
+  exports2.tabbarProps = tabbarProps;
+  exports2.tabsProps = tabsProps;
+  exports2.tagProps = tagProps;
+  exports2.textEllipsisProps = textEllipsisProps;
+  exports2.timePickerProps = timePickerProps;
+  exports2.toastProps = toastProps;
+  exports2.treeSelectProps = treeSelectProps;
+  exports2.uploaderProps = uploaderProps;
+  exports2.useCurrentLang = useCurrentLang;
+  exports2.version = version;
+  Object.defineProperties(exports2, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+});

hybrid/html/openMap/js/mapindex.js

@@ -0,0 +1,76 @@
+
+  // 初始化地图
+    const map = L.map('map').setView([31.2304, 121.4737], 13); // 上海坐标
+    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+        maxZoom: 19,
+        attribution: '© OpenStreetMap'
+    }).addTo(map);
+  
+    let markers = [];
+    let routeLine = null;
+  
+    // 点击地图添加起点/终点
+    map.on('click', async (e) => {
+        const { lat, lng } = e.latlng;
+  
+        if (markers.length >= 1) {
+            // 重置
+            markers.forEach(m => map.removeLayer(m));
+            markers = [];
+            if (routeLine) {
+                map.removeLayer(routeLine);
+                routeLine = null;
+            }
+        }
+  
+        const marker = L.marker([lat, lng]).addTo(map);
+        markers.push(marker);
+  	  
+  	  
+  	  const url = `https://nominatim.openstreetmap.org/reverse?format=jsonv2&lat=${lat}&lon=${lng}`;
+  	    const res = await fetch(url);
+  	    const data = await res.json();
+  	    console.log(data);
+  	  
+        marker.bindPopup(`📍 当前位置：<br>纬度：${lat}<br>经度：${lng}<br>${data.display_name}`).openPopup();
+  
+        console.log("选择的坐标：", lat, lng);
+  	  
+        if (markers.length === 2) {
+            const start = markers[0].getLatLng();
+            const end = markers[1].getLatLng();
+  
+            // 请求 OSRM 路线 API
+            const url = `https://router.project-osrm.org/route/v1/driving/${start.lng},${start.lat};${end.lng},${end.lat}?overview=full&geometries=geojson`;
+  
+            const response = await fetch(url);
+            const json = await response.json();
+  
+            if (json.code === 'Ok') {
+                const coords = json.routes[0].geometry.coordinates.map(c => [c[1], c[0]]);
+                routeLine = L.polyline(coords, { color: 'blue', weight: 5 }).addTo(map);
+                map.fitBounds(routeLine.getBounds());
+  
+                const distance = (json.routes[0].distance / 1000).toFixed(2);
+                const duration = (json.routes[0].duration / 60).toFixed(1);
+                alert(`路线规划完成：\n距离：${distance} 公里\n预计时间：${duration} 分钟`);
+            } else {
+                alert('路线规划失败');
+            }
+        }
+    });
+  
+document.addEventListener('UniAppJSBridgeReady', function() {
+	function initMap() {
+		uni.postMessage({
+			data: {
+				mark:"initMap"
+			}
+		});
+	}
+	  
+	window.initMap = initMap;
+});
+  
+  
+  

hybrid/html/openMap/map.html

@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8" />
+<title>OpenStreetMap 路线规划</title>
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<link rel="stylesheet" href="https://unpkg.com/leaflet/dist/leaflet.css"/>
+<script src="https://unpkg.com/leaflet/dist/leaflet.js"></script>
+<script src="./js/lib/common.js"></script>
+<style>
+  html, body, #map {
+    position: relative;
+    width: 100%;
+    height: 100%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+  
+</style>
+</head>
+<body>
+<div id="map" ></div>
+</body>
+<script type="text/javascript" src="./js/lib/uniwebviewsdk.js"></script>
+<script>
+  // 初始化地图
+  let state = 0;
+  state = getQueryVariable('shstate');
+  let dlat=getQueryVariable('dlat');
+  let dlng=getQueryVariable('dlng');
+  
+  const map = L.map('map').setView([dlat, dlng], 13); // 上海坐标
+  L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+      maxZoom: 19,
+      attribution: '&copy; OpenStreetMap'
+  }).addTo(map);
+
+  let markers = [];
+  let routeLine = null;
+  
+  // 点击地图添加起点/终点
+  map.on('click', async (e) => {
+      const { lat, lng } = e.latlng;
+      if (markers.length >= 1) {
+          // 重置
+          markers.forEach(m => map.removeLayer(m));
+          markers = [];
+          if (routeLine) {
+              map.removeLayer(routeLine);
+              routeLine = null;
+          }
+      }
+      const marker = L.marker([lat, lng]).addTo(map);
+      markers.push(marker);
+	  
+	  
+	const url = `https://nominatim.openstreetmap.org/reverse?format=jsonv2&lat=${lat}&lon=${lng}`;
+	const res = await fetch(url);
+	const data = await res.json();
+	
+	if(state!=0){
+		marker.bindPopup(`📍 当前位置：<br>纬度：${lat}<br>经度：${lng}<br>${data.display_name}`).openPopup();
+	}
+      
+      console.log("选择的坐标：", lat, lng);
+	  
+	  uni.postMessage({
+	      data: {
+	          data:`${lat};${lng}`, // 回传
+	  		type:88
+	      },
+	  });
+	  
+	  
+
+      if (markers.length === 2) {
+          const start = markers[0].getLatLng();
+          const end = markers[1].getLatLng();
+
+          // 请求 OSRM 路线 API
+          const url = `https://router.project-osrm.org/route/v1/driving/${start.lng},${start.lat};${end.lng},${end.lat}?overview=full&geometries=geojson`;
+
+          const response = await fetch(url);
+          const json = await response.json();
+
+          if (json.code === 'Ok') {
+              const coords = json.routes[0].geometry.coordinates.map(c => [c[1], c[0]]);
+              routeLine = L.polyline(coords, { color: 'blue', weight: 5 }).addTo(map);
+              map.fitBounds(routeLine.getBounds());
+
+              const distance = (json.routes[0].distance / 1000).toFixed(2);
+              const duration = (json.routes[0].duration / 60).toFixed(1);
+              alert(`路线规划完成：\n距离：${distance} 公里\n预计时间：${duration} 分钟`);
+          } else {
+              alert('路线规划失败');
+          }
+      }
+  });
+  
+  function showAddrMark (obj) {
+	  if (markers.length >= 1) {
+	      // 重置
+	      markers.forEach(m => map.removeLayer(m));
+	      markers = [];
+	      if (routeLine) {
+	          map.removeLayer(routeLine);
+	          routeLine = null;
+	      }
+	  }
+	  const lat=obj.payload.lat;
+	  const lng = obj.payload.lon;
+	  const marker = L.marker([lat, lng]).addTo(map);
+	  markers.push(marker);
+  };
+
+</script>
+
+</html>

hybrid/html/openMap/pathmap.html

@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8" />
+<title>OpenStreetMap 路线规划</title>
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<link rel="stylesheet" href="https://unpkg.com/leaflet/dist/leaflet.css"/>
+<script src="https://unpkg.com/leaflet/dist/leaflet.js"></script>
+<script src="./js/lib/common.js"></script>
+<style>
+  html, body, #map {
+    position: relative;
+    width: 100%;
+    height: 100%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+  
+</style>
+</head>
+<body>
+<div id="map" ></div>
+</body>
+<script type="text/javascript" src="./js/lib/uniwebviewsdk.js"></script>
+<script>
+  // 初始化地图
+  let state = 0;
+  state = getQueryVariable('shstate');
+  let dlat=getQueryVariable('dlat');
+  let dlng=getQueryVariable('dlng');
+  
+  const map = L.map('map').setView([dlat, dlng], 13); // 上海坐标
+  L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+      maxZoom: 19,
+      attribution: '&copy; OpenStreetMap'
+  }).addTo(map);
+
+  let markers = [];
+  let routeLine = null;
+  
+  // 点击地图添加起点/终点
+  map.on('click', async (e) => {
+      const { lat, lng } = e.latlng;
+      if (markers.length >= 1) {
+          // 重置
+          markers.forEach(m => map.removeLayer(m));
+          markers = [];
+          if (routeLine) {
+              map.removeLayer(routeLine);
+              routeLine = null;
+          }
+      }
+      const marker = L.marker([lat, lng]).addTo(map);
+      markers.push(marker);
+	  
+	  
+	const url = `https://nominatim.openstreetmap.org/reverse?format=jsonv2&lat=${lat}&lon=${lng}`;
+	const res = await fetch(url);
+	const data = await res.json();
+	
+	if(state!=0){
+		marker.bindPopup(`📍 当前位置：<br>纬度：${lat}<br>经度：${lng}<br>${data.display_name}`).openPopup();
+	}
+      
+      console.log("选择的坐标：", lat, lng);
+	  
+	  uni.postMessage({
+	      data: {
+	          data:`${lat};${lng}`, // 回传
+	  		type:88
+	      },
+	  });
+	  
+	  
+
+      if (markers.length === 2) {
+          const start = markers[0].getLatLng();
+          const end = markers[1].getLatLng();
+
+          // 请求 OSRM 路线 API
+          const url = `https://router.project-osrm.org/route/v1/driving/${start.lng},${start.lat};${end.lng},${end.lat}?overview=full&geometries=geojson`;
+
+          const response = await fetch(url);
+          const json = await response.json();
+
+          if (json.code === 'Ok') {
+              const coords = json.routes[0].geometry.coordinates.map(c => [c[1], c[0]]);
+              routeLine = L.polyline(coords, { color: 'blue', weight: 5 }).addTo(map);
+              map.fitBounds(routeLine.getBounds());
+
+              const distance = (json.routes[0].distance / 1000).toFixed(2);
+              const duration = (json.routes[0].duration / 60).toFixed(1);
+              alert(`路线规划完成：\n距离：${distance} 公里\n预计时间：${duration} 分钟`);
+          } else {
+              alert('路线规划失败');
+          }
+      }
+  });
+  
+  function showAddrMark (obj) {
+	  if (markers.length >= 1) {
+	      // 重置
+	      markers.forEach(m => map.removeLayer(m));
+	      markers = [];
+	      if (routeLine) {
+	          map.removeLayer(routeLine);
+	          routeLine = null;
+	      }
+	  }
+	  const lat=obj.payload.lat;
+	  const lng = obj.payload.lon;
+	  const marker = L.marker([lat, lng]).addTo(map);
+	  markers.push(marker);
+  };
+
+</script>
+
+</html>

index.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <script>
+      var coverSupport = 'CSS' in window && typeof CSS.supports === 'function' && (CSS.supports('top: env(a)') ||
+        CSS.supports('top: constant(a)'))
+      document.write(
+        '<meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0' +
+        (coverSupport ? ', viewport-fit=cover' : '') + '" />')
+    </script>
+    <title></title>
+    <!--preload-links-->
+    <!--app-context-->
+  </head>
+  <body>
+    <div id="app"><!--app-html--></div>
+    <script type="module" src="/main.js"></script>
+  </body>
+</html>

main.js

@@ -0,0 +1,22 @@
+import App from './App'
+
+// #ifndef VUE3
+import Vue from 'vue'
+import './uni.promisify.adaptor'
+Vue.config.productionTip = false
+App.mpType = 'app'
+const app = new Vue({
+  ...App
+})
+app.$mount()
+// #endif
+
+// #ifdef VUE3
+import { createSSRApp } from 'vue'
+export function createApp() {
+  const app = createSSRApp(App)
+  return {
+    app
+  }
+}
+// #endif

manifest.json

@@ -0,0 +1,75 @@
+{
+    "name" : "openmapTest",
+    "appid" : "__UNI__15EAF3D",
+    "description" : "",
+    "versionName" : "1.0.0",
+    "versionCode" : 1001,
+    "transformPx" : false,
+    /* 5+App特有相关 */
+    "app-plus" : {
+        "usingComponents" : true,
+        "nvueStyleCompiler" : "uni-app",
+        "compilerVersion" : 3,
+        "splashscreen" : {
+            "alwaysShowBeforeRender" : true,
+            "waiting" : true,
+            "autoclose" : true,
+            "delay" : 0
+        },
+        /* 模块配置 */
+        "modules" : {},
+        /* 应用发布信息 */
+        "distribute" : {
+            /* android打包配置 */
+            "android" : {
+                "permissions" : [
+                    "<uses-permission android:name=\"android.permission.CHANGE_NETWORK_STATE\"/>",
+                    "<uses-permission android:name=\"android.permission.MOUNT_UNMOUNT_FILESYSTEMS\"/>",
+                    "<uses-permission android:name=\"android.permission.VIBRATE\"/>",
+                    "<uses-permission android:name=\"android.permission.READ_LOGS\"/>",
+                    "<uses-permission android:name=\"android.permission.ACCESS_WIFI_STATE\"/>",
+                    "<uses-feature android:name=\"android.hardware.camera.autofocus\"/>",
+                    "<uses-permission android:name=\"android.permission.ACCESS_NETWORK_STATE\"/>",
+                    "<uses-permission android:name=\"android.permission.CAMERA\"/>",
+                    "<uses-permission android:name=\"android.permission.GET_ACCOUNTS\"/>",
+                    "<uses-permission android:name=\"android.permission.READ_PHONE_STATE\"/>",
+                    "<uses-permission android:name=\"android.permission.CHANGE_WIFI_STATE\"/>",
+                    "<uses-permission android:name=\"android.permission.WAKE_LOCK\"/>",
+                    "<uses-permission android:name=\"android.permission.FLASHLIGHT\"/>",
+                    "<uses-feature android:name=\"android.hardware.camera\"/>",
+                    "<uses-permission android:name=\"android.permission.WRITE_SETTINGS\"/>",
+                    "<uses-permission android:name=\"android.permissiOn.INTERNET\"/>"
+                ]
+            },
+            /* ios打包配置 */
+            "ios" : {
+                "dSYMs" : false
+            },
+            /* SDK配置 */
+            "sdkConfigs" : {}
+        }
+    },
+    /* 快应用特有相关 */
+    "quickapp" : {},
+    /* 小程序特有相关 */
+    "mp-weixin" : {
+        "appid" : "",
+        "setting" : {
+            "urlCheck" : false
+        },
+        "usingComponents" : true
+    },
+    "mp-alipay" : {
+        "usingComponents" : true
+    },
+    "mp-baidu" : {
+        "usingComponents" : true
+    },
+    "mp-toutiao" : {
+        "usingComponents" : true
+    },
+    "uniStatistics" : {
+        "enable" : false
+    },
+    "vueVersion" : "3"
+}

pages.json

@@ -0,0 +1,31 @@
+{
+	"pages": [ //pages数组中第一项表示应用启动页，参考：https://uniapp.dcloud.io/collocation/pages
+		{
+			"path": "pages/index/index",
+			"style": {
+				"navigationBarTitleText": "uni-app"
+			}
+		},
+		{
+			"path" : "pages/index/xianshiLJ",
+			"style" : 
+			{
+				"navigationBarTitleText" : ""
+			}
+		},
+		{
+			"path" : "pages/index/openNavMap",
+			"style" : 
+			{
+				"navigationBarTitleText" : ""
+			}
+		}
+	],
+	"globalStyle": {
+		"navigationBarTextStyle": "black",
+		"navigationBarTitleText": "uni-app",
+		"navigationBarBackgroundColor": "#F8F8F8",
+		"backgroundColor": "#F8F8F8"
+	},
+	"uniIdRouter": {}
+}

pages/api/mapAPI.js

@@ -0,0 +1,63 @@
+// 查询 OSM 周边所有 POI（不限制类型）
+export  function getOSMAround(lat, lon, radius = 500) {
+  // Overpass Query
+  const query = `
+    [out:json];
+    (
+      node(around:${radius},${lat},${lon})["amenity"];
+	  node(around:${radius},${lat},${lon})["shop"];
+	  node(around:${radius},${lat},${lon})["tourism"];
+	  node(around:${radius},${lat},${lon})["leisure"];
+	  node(around:${radius},${lat},${lon})["public_transport"];
+    );
+    out center;
+  `;
+
+  return new Promise((resolve, reject) => {
+    uni.request({
+      url: "https://overpass-api.de/api/interpreter",
+      method: "POST",
+      header: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      data: query,
+      success: (res) => {
+        if (res.data && res.data.elements) {
+          resolve(res.data.elements); // 返回 OSM 对象列表
+        } else {
+          resolve([]);
+        }
+      },
+      fail: (err) => {
+        reject(err);
+      }
+    });
+  });
+};
+
+export function geoByName(keyword) {
+  return new Promise((resolve, reject) => {
+    uni.request({
+      url: "https://nominatim.openstreetmap.org/search",
+      method: "GET",
+      data: {
+        q: keyword,       // 地名
+        format: "jsonv2", // 返回 JSON 格式
+        addressdetails: 1 // 返回详细地址
+      },
+      header: {
+        "User-Agent": "uni-app - OSM Demo"
+      },
+      success: (res) => {
+        if (res.data && res.data.length > 0) {
+          resolve(res.data[0]); // 返回最匹配项
+        } else {
+          resolve(null);
+        }
+      },
+      fail: (err) => reject(err)
+    });
+  });
+};
+
+

pages/index/index.nvue

@@ -0,0 +1,75 @@
+<template>
+  <view>
+	  <view >
+		  <web-view ref="webview" :style="{ height: statusBarHeight + 'px'}" :src="mapUrl" @onPostMessage="getMessage"></web-view>
+	  </view>
+	  <view style="margin-top: 40rpx;background-color: burlywood;height: 60rpx;" @click="xianshilj">显示路径</view>
+  </view>
+</template>
+
+<script>
+import {getOSMAround,geoByName} from "@/pages/api/mapAPI.js"
+var wv=null;//计划创建的webview
+export default {
+  data() {
+    return {
+      mapUrl: '',// 你保存的 HTML
+	  statusBarHeight:0,
+	  screenWidth:0,
+    }
+  },
+  onLoad() {
+	console.log("onLoad");
+	this.statusBarHeight = uni.getSystemInfoSync().screenHeight-240;
+	this.screenWidth = uni.getSystemInfoSync().screenWidth+100;
+  	this.mapUrl='/hybrid/html/openMap/map.html?shstate=0&dlat=22.822607&dlng=108.373454'
+  },
+  onShow() {
+	  console.log("onShow");
+	  var that = this;
+	  setTimeout(function() {
+	  	that.showMark();
+	  }, 3600); //需要延时一下，防抖动
+  },
+  methods:{
+	  getMessage(e) {
+	  	console.log("--getMessage--",e);
+	  	
+	  },
+	  
+	  showMark(){
+		  getOSMAround(22.822607, 108.373454, 600)
+		    .then(data => {
+		      console.log("附近OSM对象：", data);
+				var poiObj = data[0];
+				var jwd = {
+					lat:poiObj.lat,
+					lon:poiObj.lon
+				}
+				var obj={
+					payload:jwd,
+					type:1
+				};
+				var str = JSON.stringify(obj);
+				console.log(obj);
+				this.$refs.webview.evalJs('showAddrMark('+str+')');
+				
+			})
+		    .catch(err => {
+		      console.error(err);
+		    });
+	  },
+	  xianshilj(){
+		uni.navigateTo({
+			url:'/pages/index/openNavMap'
+		})
+	  },
+	  
+  }
+}
+</script>
+
+<style>
+.container { width: 100%; height: 100vh; }
+</style>
+

pages/index/openNavMap.vue

@@ -0,0 +1,155 @@
+<template>
+  <view style="height:100vh;">
+    <view id="map"></view>
+
+    <view class="info-box">
+      <text>{{currentStep}}</text>
+    </view>
+  </view>
+</template>
+
+<script>
+export default {
+  data() {
+    return {
+      map: null,
+      routeLatLngs: [],
+      marker: null,
+      watchId: null,
+      currentStep: "正在规划路线...",
+      instructions: [],
+      instrIndex: 0,
+      start: [39.916527, 116.397128],
+      end: [39.904211, 116.407395]
+    };
+  },
+
+  onReady() {
+    this.initMap();
+    this.calcRoute();
+    this.startGPS();
+  },
+
+  methods: {
+    /** 1. 初始化地图 */
+    initMap() {
+      this.map = L.map("map").setView(this.start, 15);
+
+      L.tileLayer("https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", {
+        maxZoom: 19,
+      }).addTo(this.map);
+    },
+
+    /** 2. GraphHopper 路线规划 */
+    calcRoute() {
+      const url =
+        `https://graphhopper.com/api/1/route?` +
+        `point=${this.start[0]},${this.start[1]}` +
+        `&point=${this.end[0]},${this.end[1]}` +
+        `&vehicle=car&instructions=true&locale=cn&key=fb959050-3a0c-4c6b-b722-5c322b2085c9`;
+
+      uni.request({
+        url,
+        success: (res) => {
+          const path = res.data.paths[0];
+          this.instructions = path.instructions;
+
+          const coords = path.points.coordinates;
+          this.routeLatLngs = coords.map(c => [c[1], c[0]]);
+
+          // 绘路线
+          L.polyline(this.routeLatLngs, { color: "blue", weight: 5 }).addTo(this.map);
+          this.map.fitBounds(this.routeLatLngs);
+
+          // 设置起点终点 Marker
+          L.marker(this.start).addTo(this.map).bindPopup("起点");
+          L.marker(this.end).addTo(this.map).bindPopup("终点");
+
+          this.currentStep = "路线规划完成，开始导航...";
+        }
+      });
+    },
+
+    /** 3. 开始实时 GPS 监听 */
+    startGPS() {
+      const _this = this;
+
+      this.watchId = navigator.geolocation.watchPosition(
+        (pos) => {
+          const lat = pos.coords.latitude;
+          const lng = pos.coords.longitude;
+
+          _this.updatePosition(lat, lng);
+          _this.checkNextInstruction(lat, lng);
+        },
+        (err) => { console.log("GPS error:", err); },
+        { enableHighAccuracy: true, timeout: 5000, maximumAge: 0 }
+      );
+    },
+
+    /** 4. 更新用户位置 + 地图跟随 */
+    updatePosition(lat, lng) {
+      if (!this.marker) {
+        this.marker = L.marker([lat, lng]).addTo(this.map);
+      } else {
+        this.marker.setLatLng([lat, lng]);
+      }
+
+      // 地图跟随
+      this.map.panTo([lat, lng]);
+    },
+
+    /** 5. 判断导航步骤 */
+    checkNextInstruction(lat, lng) {
+      if (!this.instructions.length) return;
+
+      const step = this.instructions[this.instrIndex];
+      const [fromIdx, toIdx] = step.interval;
+
+      const stepCoords = this.routeLatLngs[fromIdx];
+
+      const dist = this.getDistance(lat, lng, stepCoords[0], stepCoords[1]);
+
+      if (dist < 20) { // 距离下一个步骤 < 20 米时触发
+        this.currentStep = step.text;
+
+        // 进入下一步
+        if (this.instrIndex < this.instructions.length - 1) {
+          this.instrIndex++;
+        }
+      }
+    },
+
+    /** 工具：两点间距离 */
+    getDistance(lat1, lon1, lat2, lon2) {
+      const R = 6378137;
+      const dLat = (lat2 - lat1) * Math.PI / 180;
+      const dLon = (lon2 - lon1) * Math.PI / 180;
+      const a =
+        Math.sin(dLat/2) * Math.sin(dLat/2) +
+        Math.cos(lat1 * Math.PI/180) *
+        Math.cos(lat2 * Math.PI/180) *
+        Math.sin(dLon/2) * Math.sin(dLon/2);
+      return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+    }
+  },
+
+  onUnload() {
+    if (this.watchId) {
+      navigator.geolocation.clearWatch(this.watchId);
+    }
+  }
+};
+</script>
+
+<style>
+#map { width: 100%; height: 75vh; }
+.info-box {
+  padding: 20rpx;
+  font-size: 32rpx;
+}
+</style>
+
+<!-- Leaflet -->
+<script src="https://unpkg.com/leaflet/dist/leaflet.js"></script>
+<link rel="stylesheet" href="https://unpkg.com/leaflet/dist/leaflet.css">

pages/index/xianshiLJ.nvue

@@ -0,0 +1,70 @@
+<template>
+  <view>
+	  <view >
+		  <web-view ref="webview" :style="{ height: statusBarHeight + 'px'}" :src="mapUrl" @onPostMessage="getMessage"></web-view>
+	  </view>
+	  <view style="margin-top: 40rpx;background-color: burlywood;height: 60rpx;" @click="xianshilj">显示路径</view>
+  </view>
+</template>
+
+<script>
+import {getOSMAround,geoByName} from "@/pages/api/mapAPI.js"
+var wv=null;//计划创建的webview
+export default {
+  data() {
+    return {
+      mapUrl: '',// 你保存的 HTML
+	  statusBarHeight:0,
+	  screenWidth:0,
+    }
+  },
+  onLoad() {
+	console.log("onLoad");
+	this.statusBarHeight = uni.getSystemInfoSync().screenHeight-240;
+	this.screenWidth = uni.getSystemInfoSync().screenWidth+100;
+  	this.mapUrl='/hybrid/html/openMap/pathmap.html?shstate=0&dlat=22.822607&dlng=108.373454'
+  },
+  onShow() {
+	  console.log("onShow");
+	  var that = this;
+	  setTimeout(function() {
+	  	that.showMark();
+	  }, 3600); //需要延时一下，防抖动
+  },
+  methods:{
+	  getMessage(e) {
+	  	console.log("--getMessage--",e);
+	  	
+	  },
+	  
+	  showMark(){
+		  getOSMAround(22.822607, 108.373454, 600)
+		    .then(data => {
+		      console.log("附近OSM对象：", data);
+				var poiObj = data[0];
+				var jwd = {
+					lat:poiObj.lat,
+					lon:poiObj.lon
+				}
+				var obj={
+					payload:jwd,
+					type:1
+				};
+				var str = JSON.stringify(obj);
+				console.log(obj);
+				this.$refs.webview.evalJs('showAddrMark('+str+')');
+				
+			})
+		    .catch(err => {
+		      console.error(err);
+		    });
+	  },
+	  
+	  
+  }
+}
+</script>
+
+<style>
+.container { width: 100%; height: 100vh; }
+</style>

uni.promisify.adaptor.js

@@ -0,0 +1,13 @@
+uni.addInterceptor({
+  returnValue (res) {
+    if (!(!!res && (typeof res === "object" || typeof res === "function") && typeof res.then === "function")) {
+      return res;
+    }
+    return new Promise((resolve, reject) => {
+      res.then((res) => {
+        if (!res) return resolve(res) 
+        return res[0] ? reject(res[0]) : resolve(res[1])
+      });
+    });
+  },
+});

uni.scss

@@ -0,0 +1,76 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+
+/* 颜色变量 */
+
+/* 行为相关颜色 */
+$uni-color-primary: #007aff;
+$uni-color-success: #4cd964;
+$uni-color-warning: #f0ad4e;
+$uni-color-error: #dd524d;
+
+/* 文字基本颜色 */
+$uni-text-color:#333;//基本色
+$uni-text-color-inverse:#fff;//反色
+$uni-text-color-grey:#999;//辅助灰色，如加载更多的提示信息
+$uni-text-color-placeholder: #808080;
+$uni-text-color-disable:#c0c0c0;
+
+/* 背景颜色 */
+$uni-bg-color:#ffffff;
+$uni-bg-color-grey:#f8f8f8;
+$uni-bg-color-hover:#f1f1f1;//点击状态颜色
+$uni-bg-color-mask:rgba(0, 0, 0, 0.4);//遮罩颜色
+
+/* 边框颜色 */
+$uni-border-color:#c8c7cc;
+
+/* 尺寸变量 */
+
+/* 文字尺寸 */
+$uni-font-size-sm:12px;
+$uni-font-size-base:14px;
+$uni-font-size-lg:16px;
+
+/* 图片尺寸 */
+$uni-img-size-sm:20px;
+$uni-img-size-base:26px;
+$uni-img-size-lg:40px;
+
+/* Border Radius */
+$uni-border-radius-sm: 2px;
+$uni-border-radius-base: 3px;
+$uni-border-radius-lg: 6px;
+$uni-border-radius-circle: 50%;
+
+/* 水平间距 */
+$uni-spacing-row-sm: 5px;
+$uni-spacing-row-base: 10px;
+$uni-spacing-row-lg: 15px;
+
+/* 垂直间距 */
+$uni-spacing-col-sm: 4px;
+$uni-spacing-col-base: 8px;
+$uni-spacing-col-lg: 12px;
+
+/* 透明度 */
+$uni-opacity-disabled: 0.3; // 组件禁用态的透明度
+
+/* 文章场景相关 */
+$uni-color-title: #2C405A; // 文章标题颜色
+$uni-font-size-title:20px;
+$uni-color-subtitle: #555555; // 二级标题颜色
+$uni-font-size-subtitle:26px;
+$uni-color-paragraph: #3F536E; // 文章段落颜色
+$uni-font-size-paragraph:15px;

新建 文本文档.txt

@@ -0,0 +1,5 @@
+ MD5:  E7:2E:49:8F:CE:E2:04:52:6F:7A:34:0C:C9:C1:EE:EF
+         SHA1: 87:75:FD:46:8A:E3:86:7C:1F:F8:0A:76:21:B9:3C:33:75:9E:A5:59
+         SHA256: 98:70:02:63:C1:3C:42:F1:F9:BD:90:DC:E5:39:79:A8:9E:6B:FA:9A:E5:FD:FB:41:34:95:9E:A0:53:68:F8:80
+签名算法名称: SHA256withRSA
+主体公共密钥算法: 2048 位 RSA 密钥