import { At as onActivated, Bt as onUnmounted, Dr as normalizeStyle, Gn as reactive, It as onMounted, L as Teleport, Mt as onBeforeUnmount, N as Fragment, Nt as onBeforeUpdate, Ot as mergeProps, Pt as onDeactivated, R as Text, St as inject, T as withKeys, Tr as normalizeClass, Tt as isVNode, Vt as onUpdated, W as computed, Wt as provide, Zt as resolveDirective, _n as watch, dt as getCurrentInstance, et as createTextVNode, fr as init_shared_esm_bundler, i as createApp, jr as stringifyStyle, k as Comment, kt as nextTick, mt as h, qn as ref, rr as unref, rt as defineComponent, t as Transition, tt as createVNode, vn as watchEffect, w as vShow, wn as withDirectives, zn as isRef } from "./runtime-dom.esm-bundler-Oj6WMcVd.js";

//#region node_modules/vant/es/utils/basic.mjs
function noop() {}
var extend = Object.assign;
var inBrowser$1 = typeof window !== "undefined";
var isObject = (val) => val !== null && typeof val === "object";
var isDef = (val) => val !== void 0 && val !== null;
var isFunction = (val) => typeof val === "function";
var isPromise = (val) => isObject(val) && isFunction(val.then) && isFunction(val.catch);
var 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);
}
var isNumeric = (val) => typeof val === "number" || /^\d+(\.\d+)?$/.test(val);
var isIOS = () => inBrowser$1 ? /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase()) : false;
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;
	}, {});
}
var isSameValue = (newValue, oldValue) => JSON.stringify(newValue) === JSON.stringify(oldValue);
var toArray = (item) => Array.isArray(item) ? item : [item];
var flat = (arr) => arr.reduce((acc, val) => acc.concat(val), []);

//#endregion
//#region node_modules/vant/es/utils/props.mjs
var unknownProp = null;
var numericProp = [Number, String];
var truthProp = {
	type: Boolean,
	default: true
};
var makeRequiredProp = (type) => ({
	type,
	required: true
});
var makeArrayProp = () => ({
	type: Array,
	default: () => []
});
var makeNumberProp = (defaultVal) => ({
	type: Number,
	default: defaultVal
});
var makeNumericProp = (defaultVal) => ({
	type: numericProp,
	default: defaultVal
});
var makeStringProp = (defaultVal) => ({
	type: String,
	default: defaultVal
});

//#endregion
//#region node_modules/@vant/use/dist/index.esm.mjs
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 = 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 = ref(defaultValue);
	const toggle = (value = !state.value) => {
		state.value = value;
	};
	return [state, toggle];
}
function useParent(key) {
	const parent = inject(key, null);
	if (parent) {
		const instance$3 = getCurrentInstance();
		const { link, unlink, internalChildren } = parent;
		link(instance$3);
		onUnmounted(() => unlink(instance$3));
		return {
			parent,
			index: computed(() => internalChildren.indexOf(instance$3))
		};
	}
	return {
		parent: null,
		index: ref(-1)
	};
}
function flattenVNodes(children) {
	const result = [];
	const traverse = (children2) => {
		if (Array.isArray(children2)) children2.forEach((child) => {
			var _a;
			if (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) => {
		return orderedPublicChildren.indexOf(a) - orderedPublicChildren.indexOf(b);
	});
}
function useChildren(key) {
	const publicChildren = reactive([]);
	const internalChildren = reactive([]);
	const parent = 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);
		};
		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) {
	return {
		total: time,
		days: Math.floor(time / DAY),
		hours: Math.floor(time % DAY / HOUR),
		minutes: Math.floor(time % HOUR / MINUTE),
		seconds: Math.floor(time % MINUTE / SECOND),
		milliseconds: Math.floor(time % SECOND)
	};
}
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 = ref(options.time);
	const current$1 = 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 || _a.call(options, current$1.value);
		if (value === 0) {
			pause();
			(_b = options.onFinish) == null || _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 start$1 = () => {
		if (!counting) {
			endTime = Date.now() + remain.value;
			counting = true;
			tick();
		}
	};
	const reset = (totalTime = options.time) => {
		pause();
		remain.value = totalTime;
	};
	onBeforeUnmount(pause);
	onActivated(() => {
		if (deactivated) {
			counting = true;
			deactivated = false;
			tick();
		}
	});
	onDeactivated(() => {
		if (counting) {
			pause();
			deactivated = true;
		}
	});
	return {
		start: start$1,
		pause,
		reset,
		current: current$1
	};
}
function onMountedOrActivated(hook) {
	let mounted;
	onMounted(() => {
		hook();
		nextTick(() => {
			mounted = true;
		});
	});
	onActivated(() => {
		if (mounted) hook();
	});
}
function useEventListener(type, listener, options = {}) {
	if (!inBrowser) return;
	const { target = window, passive: passive$1 = false, capture = false } = options;
	let cleaned = false;
	let attached;
	const add = (target2) => {
		if (cleaned) return;
		const element = unref(target2);
		if (element && !attached) {
			element.addEventListener(type, listener, {
				capture,
				passive: passive$1
			});
			attached = true;
		}
	};
	const remove$1 = (target2) => {
		if (cleaned) return;
		const element = unref(target2);
		if (element && attached) {
			element.removeEventListener(type, listener, capture);
			attached = false;
		}
	};
	onUnmounted(() => remove$1(target));
	onDeactivated(() => remove$1(target));
	onMountedOrActivated(() => add(target));
	let stopWatch;
	if (isRef(target)) stopWatch = watch(target, (val, oldVal) => {
		remove$1(oldVal);
		add(val);
	});
	return () => {
		stopWatch?.();
		remove$1(target);
		cleaned = true;
	};
}
function useClickAway(target, listener, options = {}) {
	if (!inBrowser) return;
	const { eventName = "click" } = options;
	const onClick = (event) => {
		if ((Array.isArray(target) ? target : [target]).every((item) => {
			const element = unref(item);
			return element && !element.contains(event.target);
		})) listener(event);
	};
	useEventListener(eventName, onClick, { target: document });
}
var width;
var height;
function useWindowSize() {
	if (!width) {
		width = ref(0);
		height = 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) {
	return node.tagName !== "HTML" && node.tagName !== "BODY" && node.nodeType === 1;
}
function getScrollParent(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 = ref();
	onMounted(() => {
		if (el.value) scrollParent.value = getScrollParent(el.value, root);
	});
	return scrollParent;
}
var visibility;
function usePageVisibility() {
	if (!visibility) {
		visibility = 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 = inject(CUSTOM_FIELD_INJECTION_KEY, null);
	if (field && !field.customValue.value) {
		field.customValue.value = customValue;
		watch(customValue, () => {
			field.resetValidation();
			field.validateWithTrigger("onChange");
		});
	}
}

//#endregion
//#region node_modules/vant/es/utils/dom.mjs
function getScrollTop(el) {
	const top$1 = "scrollTop" in el ? el.scrollTop : el.pageYOffset;
	return Math.max(top$1, 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;
}
var isIOS$1 = isIOS();
function resetScroll() {
	if (isIOS$1) setRootScrollTop(getRootScrollTop());
}
var 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 = 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;
}
var { width: windowWidth, height: windowHeight } = useWindowSize();
function isContainingBlock(el) {
	const css = window.getComputedStyle(el);
	return css.transform !== "none" || css.perspective !== "none" || [
		"transform",
		"perspective",
		"filter"
	].some((value) => (css.willChange || "").includes(value));
}
function getContainingBlock$1(el) {
	let node = el.parentElement;
	while (node) {
		if (node && node.tagName !== "HTML" && node.tagName !== "BODY" && isContainingBlock(node)) return node;
		node = node.parentElement;
	}
	return null;
}

//#endregion
//#region node_modules/vant/es/utils/format.mjs
function addUnit(value) {
	if (isDef(value)) return isNumeric(value) ? `${value}px` : String(value);
}
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;
}
var 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);
}
var camelizeRE = /-(\w)/g;
var camelize = (str) => str.replace(camelizeRE, (_, c) => c.toUpperCase());
var 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;
}
var 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;
}

//#endregion
//#region node_modules/vant/es/utils/deep-assign.mjs
var { 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;
}

//#endregion
//#region node_modules/vant/es/locale/lang/zh-CN.mjs
var stdin_default$122 = {
	name: "姓名",
	tel: "电话",
	save: "保存",
	clear: "清空",
	cancel: "取消",
	confirm: "确认",
	delete: "删除",
	loading: "加载中...",
	noCoupon: "暂无优惠券",
	nameEmpty: "请填写姓名",
	addContact: "添加联系人",
	telInvalid: "请填写正确的电话",
	vanCalendar: {
		end: "结束",
		start: "开始",
		title: "日期选择",
		weekdays: [
			"日",
			"一",
			"二",
			"三",
			"四",
			"五",
			"六"
		],
		monthTitle: (year, month) => `${year}\u5E74${month}\u6708`,
		rangePrompt: (maxRange) => `\u6700\u591A\u9009\u62E9 ${maxRange} \u5929`
	},
	vanCascader: { select: "请选择" },
	vanPagination: {
		prev: "上一页",
		next: "下一页"
	},
	vanPullRefresh: {
		pulling: "下拉即可刷新...",
		loosing: "释放即可刷新..."
	},
	vanSubmitBar: { label: "合计:" },
	vanCoupon: {
		unlimited: "无门槛",
		discount: (discount) => `${discount}\u6298`,
		condition: (condition) => `\u6EE1${condition}\u5143\u53EF\u7528`
	},
	vanCouponCell: {
		title: "优惠券",
		count: (count) => `${count}\u5F20\u53EF\u7528`
	},
	vanCouponList: {
		exchange: "兑换",
		close: "不使用",
		enable: "可用",
		disabled: "不可用",
		placeholder: "输入优惠码"
	},
	vanAddressEdit: {
		area: "地区",
		areaEmpty: "请选择地区",
		addressEmpty: "请填写详细地址",
		addressDetail: "详细地址",
		defaultAddress: "设为默认收货地址"
	},
	vanAddressList: { add: "新增地址" }
};

//#endregion
//#region node_modules/vant/es/locale/index.mjs
var lang = ref("zh-CN");
var messages = reactive({ "zh-CN": stdin_default$122 });
var Locale = {
	messages() {
		return messages[lang.value];
	},
	use(newLang, newMessages) {
		lang.value = newLang;
		this.add({ [newLang]: newMessages });
	},
	add(newMessages = {}) {
		deepAssign(messages, newMessages);
	}
};
var useCurrentLang = () => lang;
var stdin_default$121 = Locale;

//#endregion
//#region node_modules/vant/es/utils/create.mjs
function createTranslate(name$111) {
	const prefix = camelize(name$111) + ".";
	return (path, ...args) => {
		const messages$1 = stdin_default$121.messages();
		const message = get(messages$1, prefix + path) || get(messages$1, path);
		return isFunction(message) ? message(...args) : message;
	};
}
function genBem(name$111, mods) {
	if (!mods) return "";
	if (typeof mods === "string") return ` ${name$111}--${mods}`;
	if (Array.isArray(mods)) return mods.reduce((ret, item) => ret + genBem(name$111, item), "");
	return Object.keys(mods).reduce((ret, key) => ret + (mods[key] ? genBem(name$111, key) : ""), "");
}
function createBEM(name$111) {
	return (el, mods) => {
		if (el && typeof el !== "string") {
			mods = el;
			el = "";
		}
		el = el ? `${name$111}__${el}` : name$111;
		return `${el}${genBem(el, mods)}`;
	};
}
function createNamespace(name$111) {
	const prefixedName = `van-${name$111}`;
	return [
		prefixedName,
		createBEM(prefixedName),
		createTranslate(prefixedName)
	];
}

//#endregion
//#region node_modules/vant/es/utils/constant.mjs
var BORDER = "van-hairline";
var BORDER_TOP = `${BORDER}--top`;
var BORDER_LEFT = `${BORDER}--left`;
var BORDER_RIGHT = `${BORDER}--right`;
var BORDER_BOTTOM = `${BORDER}--bottom`;
var BORDER_SURROUND = `${BORDER}--surround`;
var BORDER_TOP_BOTTOM = `${BORDER}--top-bottom`;
var BORDER_UNSET_TOP_BOTTOM = `${BORDER}-unset--top-bottom`;
var HAPTICS_FEEDBACK = "van-haptics-feedback";
var FORM_KEY = Symbol("van-form");
var LONG_PRESS_START_TIME = 500;
var TAP_OFFSET = 5;

//#endregion
//#region node_modules/vant/es/utils/interceptor.mjs
function callInterceptor(interceptor, { args = [], done, canceled, error }) {
	if (interceptor) {
		const returnVal = interceptor.apply(null, args);
		if (isPromise(returnVal)) returnVal.then((value) => {
			if (value) done();
			else if (canceled) canceled();
		}).catch(error || noop);
		else if (returnVal) done();
		else if (canceled) canceled();
	} else done();
}

//#endregion
//#region node_modules/vant/es/utils/with-install.mjs
function withInstall(options) {
	options.install = (app) => {
		const { name: name$111 } = options;
		if (name$111) {
			app.component(name$111, options);
			app.component(camelize(`-${name$111}`), options);
		}
	};
	return options;
}

//#endregion
//#region node_modules/vant/es/utils/closest.mjs
function closest(arr, target) {
	return arr.reduce((pre, cur) => Math.abs(pre - target) < Math.abs(cur - target) ? pre : cur);
}

//#endregion
//#region node_modules/vant/es/composables/on-popup-reopen.mjs
var POPUP_TOGGLE_KEY = Symbol();
function onPopupReopen(callback) {
	const popupToggleStatus = inject(POPUP_TOGGLE_KEY, null);
	if (popupToggleStatus) watch(popupToggleStatus, (show) => {
		if (show) callback();
	});
}

//#endregion
//#region node_modules/vant/es/composables/use-height.mjs
var useHeight = (element, withSafeArea) => {
	const height$1 = ref();
	const setHeight = () => {
		height$1.value = useRect(element).height;
	};
	onMounted(() => {
		nextTick(setHeight);
		if (withSafeArea) for (let i = 1; i <= 3; i++) setTimeout(setHeight, 100 * i);
	});
	onPopupReopen(() => nextTick(setHeight));
	watch([windowWidth, windowHeight], setHeight);
	return height$1;
};

//#endregion
//#region node_modules/vant/es/composables/use-placeholder.mjs
function usePlaceholder(contentRef, bem$106) {
	const height$1 = useHeight(contentRef, true);
	return (renderContent) => createVNode("div", {
		"class": bem$106("placeholder"),
		"style": { height: height$1.value ? `${height$1.value}px` : void 0 }
	}, [renderContent()]);
}

//#endregion
//#region node_modules/vant/es/action-bar/ActionBar.mjs
var [name$110, bem$105] = createNamespace("action-bar");
var ACTION_BAR_KEY = Symbol(name$110);
var actionBarProps = {
	placeholder: Boolean,
	safeAreaInsetBottom: truthProp
};
var stdin_default$120 = defineComponent({
	name: name$110,
	props: actionBarProps,
	setup(props$1, { slots }) {
		const root = ref();
		const renderPlaceholder = usePlaceholder(root, bem$105);
		const { linkChildren } = useChildren(ACTION_BAR_KEY);
		linkChildren();
		const renderActionBar = () => {
			var _a;
			return createVNode("div", {
				"ref": root,
				"class": [bem$105(), { "van-safe-area-bottom": props$1.safeAreaInsetBottom }]
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
		return () => {
			if (props$1.placeholder) return renderPlaceholder(renderActionBar);
			return renderActionBar();
		};
	}
});

//#endregion
//#region node_modules/vant/es/action-bar/index.mjs
var ActionBar = withInstall(stdin_default$120);

//#endregion
//#region node_modules/vant/es/composables/use-expose.mjs
function useExpose(apis) {
	const instance$3 = getCurrentInstance();
	if (instance$3) extend(instance$3.proxy, apis);
}

//#endregion
//#region node_modules/vant/es/composables/use-route.mjs
var 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 = getCurrentInstance().proxy;
	return () => route(vm);
}

//#endregion
//#region node_modules/vant/es/badge/Badge.mjs
var [name$109, bem$104] = createNamespace("badge");
var badgeProps = {
	dot: Boolean,
	max: numericProp,
	tag: makeStringProp("div"),
	color: String,
	offset: Array,
	content: numericProp,
	showZero: truthProp,
	position: makeStringProp("top-right")
};
var stdin_default$119 = defineComponent({
	name: name$109,
	props: badgeProps,
	setup(props$1, { slots }) {
		const hasContent = () => {
			if (slots.content) return true;
			const { content, showZero } = props$1;
			return isDef(content) && content !== "" && (showZero || content !== 0 && content !== "0");
		};
		const renderContent = () => {
			const { dot, max, content } = props$1;
			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 = computed(() => {
			const style2 = { background: props$1.color };
			if (props$1.offset) {
				const [x, y] = props$1.offset;
				const { position } = props$1;
				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$1.dot) return createVNode("div", {
				"class": bem$104([props$1.position, {
					dot: props$1.dot,
					fixed: !!slots.default
				}]),
				"style": style.value
			}, [renderContent()]);
		};
		return () => {
			if (slots.default) {
				const { tag } = props$1;
				return createVNode(tag, { "class": bem$104("wrapper") }, { default: () => [slots.default(), renderBadge()] });
			}
			return renderBadge();
		};
	}
});

//#endregion
//#region node_modules/vant/es/badge/index.mjs
var Badge = withInstall(stdin_default$119);

//#endregion
//#region node_modules/vant/es/composables/use-global-z-index.mjs
var globalZIndex = 2e3;
var useGlobalZIndex = () => ++globalZIndex;
var setGlobalZIndex = (val) => {
	globalZIndex = val;
};

//#endregion
//#region node_modules/vant/es/config-provider/ConfigProvider.mjs
var [name$108, bem$103] = createNamespace("config-provider");
var CONFIG_PROVIDER_KEY = Symbol(name$108);
var configProviderProps = {
	tag: makeStringProp("div"),
	theme: makeStringProp("light"),
	zIndex: Number,
	themeVars: Object,
	themeVarsDark: Object,
	themeVarsLight: Object,
	themeVarsScope: makeStringProp("local"),
	iconPrefix: String
};
function insertDash(str) {
	return str.replace(/([a-zA-Z])(\d)/g, "$1-$2");
}
function mapThemeVarsToCSSVars(themeVars) {
	const cssVars = {};
	Object.keys(themeVars).forEach((key) => {
		const formattedKey = insertDash(kebabCase(key));
		cssVars[`--van-${formattedKey}`] = themeVars[key];
	});
	return cssVars;
}
function syncThemeVarsOnRoot(newStyle = {}, oldStyle = {}) {
	Object.keys(newStyle).forEach((key) => {
		if (newStyle[key] !== oldStyle[key]) document.documentElement.style.setProperty(key, newStyle[key]);
	});
	Object.keys(oldStyle).forEach((key) => {
		if (!newStyle[key]) document.documentElement.style.removeProperty(key);
	});
}
var stdin_default$71 = defineComponent({
	name: name$108,
	props: configProviderProps,
	setup(props$1, { slots }) {
		const style = computed(() => mapThemeVarsToCSSVars(extend({}, props$1.themeVars, props$1.theme === "dark" ? props$1.themeVarsDark : props$1.themeVarsLight)));
		if (inBrowser$1) {
			const addTheme = () => {
				document.documentElement.classList.add(`van-theme-${props$1.theme}`);
			};
			const removeTheme = (theme = props$1.theme) => {
				document.documentElement.classList.remove(`van-theme-${theme}`);
			};
			watch(() => props$1.theme, (newVal, oldVal) => {
				if (oldVal) removeTheme(oldVal);
				addTheme();
			}, { immediate: true });
			onActivated(addTheme);
			onDeactivated(removeTheme);
			onBeforeUnmount(removeTheme);
			watch(style, (newStyle, oldStyle) => {
				if (props$1.themeVarsScope === "global") syncThemeVarsOnRoot(newStyle, oldStyle);
			});
			watch(() => props$1.themeVarsScope, (newScope, oldScope) => {
				if (oldScope === "global") syncThemeVarsOnRoot({}, style.value);
				if (newScope === "global") syncThemeVarsOnRoot(style.value, {});
			});
			if (props$1.themeVarsScope === "global") syncThemeVarsOnRoot(style.value, {});
		}
		provide(CONFIG_PROVIDER_KEY, props$1);
		watchEffect(() => {
			if (props$1.zIndex !== void 0) setGlobalZIndex(props$1.zIndex);
		});
		return () => createVNode(props$1.tag, {
			"class": bem$103(),
			"style": props$1.themeVarsScope === "local" ? style.value : void 0
		}, { default: () => {
			var _a;
			return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
		} });
	}
});

//#endregion
//#region node_modules/vant/es/icon/Icon.mjs
var [name$107, bem$102] = createNamespace("icon");
var isImage$1 = (name2) => name2 == null ? void 0 : name2.includes("/");
var iconProps = {
	dot: Boolean,
	tag: makeStringProp("i"),
	name: String,
	size: numericProp,
	badge: numericProp,
	color: String,
	badgeProps: Object,
	classPrefix: String
};
var stdin_default$118 = defineComponent({
	name: name$107,
	props: iconProps,
	setup(props$1, { slots }) {
		const config = inject(CONFIG_PROVIDER_KEY, null);
		const classPrefix = computed(() => props$1.classPrefix || (config == null ? void 0 : config.iconPrefix) || bem$102());
		return () => {
			const { tag, dot, name: name2, size, badge, color } = props$1;
			const isImageIcon = isImage$1(name2);
			return createVNode(Badge, mergeProps({
				"dot": dot,
				"tag": tag,
				"class": [classPrefix.value, isImageIcon ? "" : `${classPrefix.value}-${name2}`],
				"style": {
					color,
					fontSize: addUnit(size)
				},
				"content": badge
			}, props$1.badgeProps), { default: () => {
				var _a;
				return [(_a = slots.default) == null ? void 0 : _a.call(slots), isImageIcon && createVNode("img", {
					"class": bem$102("image"),
					"src": name2
				}, null)];
			} });
		};
	}
});

//#endregion
//#region node_modules/vant/es/icon/index.mjs
var Icon = withInstall(stdin_default$118);
var stdin_default$57 = Icon;

//#endregion
//#region node_modules/vant/es/loading/Loading.mjs
var [name$106, bem$101] = createNamespace("loading");
var SpinIcon = Array(12).fill(null).map((_, index) => createVNode("i", { "class": bem$101("line", String(index + 1)) }, null));
var CircularIcon = createVNode("svg", {
	"class": bem$101("circular"),
	"viewBox": "25 25 50 50"
}, [createVNode("circle", {
	"cx": "50",
	"cy": "50",
	"r": "20",
	"fill": "none"
}, null)]);
var loadingProps = {
	size: numericProp,
	type: makeStringProp("circular"),
	color: String,
	vertical: Boolean,
	textSize: numericProp,
	textColor: String
};
var stdin_default$117 = defineComponent({
	name: name$106,
	props: loadingProps,
	setup(props$1, { slots }) {
		const spinnerStyle = computed(() => extend({ color: props$1.color }, getSizeStyle(props$1.size)));
		const renderIcon = () => {
			const DefaultIcon = props$1.type === "spinner" ? SpinIcon : CircularIcon;
			return createVNode("span", {
				"class": bem$101("spinner", props$1.type),
				"style": spinnerStyle.value
			}, [slots.icon ? slots.icon() : DefaultIcon]);
		};
		const renderText = () => {
			var _a;
			if (slots.default) return createVNode("span", {
				"class": bem$101("text"),
				"style": {
					fontSize: addUnit(props$1.textSize),
					color: (_a = props$1.textColor) != null ? _a : props$1.color
				}
			}, [slots.default()]);
		};
		return () => {
			const { type, vertical } = props$1;
			return createVNode("div", {
				"class": bem$101([type, { vertical }]),
				"aria-live": "polite",
				"aria-busy": true
			}, [renderIcon(), renderText()]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/loading/index.mjs
var Loading = withInstall(stdin_default$117);

//#endregion
//#region node_modules/vant/es/button/Button.mjs
var [name$105, bem$100] = createNamespace("button");
var 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$116 = defineComponent({
	name: name$105,
	props: buttonProps,
	emits: ["click"],
	setup(props$1, { emit, slots }) {
		const route$1 = useRoute();
		const renderLoadingIcon = () => {
			if (slots.loading) return slots.loading();
			return createVNode(Loading, {
				"size": props$1.loadingSize,
				"type": props$1.loadingType,
				"class": bem$100("loading")
			}, null);
		};
		const renderIcon = () => {
			if (props$1.loading) return renderLoadingIcon();
			if (slots.icon) return createVNode("div", { "class": bem$100("icon") }, [slots.icon()]);
			if (props$1.icon) return createVNode(Icon, {
				"name": props$1.icon,
				"class": bem$100("icon"),
				"classPrefix": props$1.iconPrefix
			}, null);
		};
		const renderText = () => {
			let text;
			if (props$1.loading) text = props$1.loadingText;
			else text = slots.default ? slots.default() : props$1.text;
			if (text) return createVNode("span", { "class": bem$100("text") }, [text]);
		};
		const getStyle = () => {
			const { color, plain } = props$1;
			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$1.loading) preventDefault(event);
			else if (!props$1.disabled) {
				emit("click", event);
				route$1();
			}
		};
		return () => {
			const { tag, type, size, block, round: round$1, plain, square, loading, disabled, hairline, nativeType, iconPosition } = props$1;
			const classes = [bem$100([
				type,
				size,
				{
					plain,
					block,
					round: round$1,
					square,
					loading,
					disabled,
					hairline
				}
			]), { [BORDER_SURROUND]: hairline }];
			return createVNode(tag, {
				"type": nativeType,
				"class": classes,
				"style": getStyle(),
				"disabled": disabled,
				"onClick": onClick
			}, { default: () => [createVNode("div", { "class": bem$100("content") }, [
				iconPosition === "left" && renderIcon(),
				renderText(),
				iconPosition === "right" && renderIcon()
			])] });
		};
	}
});

//#endregion
//#region node_modules/vant/es/button/index.mjs
var Button = withInstall(stdin_default$116);

//#endregion
//#region node_modules/vant/es/action-bar-button/ActionBarButton.mjs
var [name$104, bem$99] = createNamespace("action-bar-button");
var actionBarButtonProps = extend({}, routeProps, {
	type: String,
	text: String,
	icon: String,
	color: String,
	loading: Boolean,
	disabled: Boolean
});
var stdin_default$115 = defineComponent({
	name: name$104,
	props: actionBarButtonProps,
	setup(props$1, { slots }) {
		const route$1 = useRoute();
		const { parent, index } = useParent(ACTION_BAR_KEY);
		const isFirst = computed(() => {
			if (parent) {
				const prev = parent.children[index.value - 1];
				return !(prev && "isButton" in prev);
			}
		});
		const isLast = 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$1;
			return createVNode(Button, {
				"class": bem$99([type, {
					last: isLast.value,
					first: isFirst.value
				}]),
				"size": "large",
				"type": type,
				"icon": icon,
				"color": color,
				"loading": loading,
				"disabled": disabled,
				"onClick": route$1
			}, { default: () => [slots.default ? slots.default() : text] });
		};
	}
});

//#endregion
//#region node_modules/vant/es/action-bar-button/index.mjs
var ActionBarButton = withInstall(stdin_default$115);

//#endregion
//#region node_modules/vant/es/action-bar-icon/ActionBarIcon.mjs
var [name$103, bem$98] = createNamespace("action-bar-icon");
var actionBarIconProps = extend({}, routeProps, {
	dot: Boolean,
	text: String,
	icon: String,
	color: String,
	badge: numericProp,
	iconClass: unknownProp,
	badgeProps: Object,
	iconPrefix: String
});
var stdin_default$114 = defineComponent({
	name: name$103,
	props: actionBarIconProps,
	setup(props$1, { slots }) {
		const route$1 = useRoute();
		useParent(ACTION_BAR_KEY);
		const renderIcon = () => {
			const { dot, badge, icon, color, iconClass, badgeProps: badgeProps$1, iconPrefix } = props$1;
			if (slots.icon) return createVNode(Badge, mergeProps({
				"dot": dot,
				"class": bem$98("icon"),
				"content": badge
			}, badgeProps$1), { default: slots.icon });
			return createVNode(Icon, {
				"tag": "div",
				"dot": dot,
				"name": icon,
				"badge": badge,
				"color": color,
				"class": [bem$98("icon"), iconClass],
				"badgeProps": badgeProps$1,
				"classPrefix": iconPrefix
			}, null);
		};
		return () => createVNode("div", {
			"role": "button",
			"class": bem$98(),
			"tabindex": 0,
			"onClick": route$1
		}, [renderIcon(), slots.default ? slots.default() : props$1.text]);
	}
});

//#endregion
//#region node_modules/vant/es/action-bar-icon/index.mjs
var ActionBarIcon = withInstall(stdin_default$114);

//#endregion
//#region node_modules/vant/es/popup/shared.mjs
var popupSharedProps = {
	show: Boolean,
	zIndex: numericProp,
	overlay: truthProp,
	duration: numericProp,
	teleport: [String, Object],
	lockScroll: truthProp,
	lazyRender: truthProp,
	beforeClose: Function,
	overlayProps: Object,
	overlayStyle: Object,
	overlayClass: unknownProp,
	transitionAppear: Boolean,
	closeOnClickOverlay: truthProp
};
var popupSharedPropKeys = Object.keys(popupSharedProps);

//#endregion
//#region node_modules/vant/es/composables/use-touch.mjs
function getDirection(x, y) {
	if (x > y) return "horizontal";
	if (y > x) return "vertical";
	return "";
}
function useTouch() {
	const startX = ref(0);
	const startY = ref(0);
	const deltaX = ref(0);
	const deltaY = ref(0);
	const offsetX = ref(0);
	const offsetY = ref(0);
	const direction = ref("");
	const isTap = ref(true);
	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 = "";
		isTap.value = true;
	};
	const start$1 = (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);
		if (isTap.value && (offsetX.value > TAP_OFFSET || offsetY.value > TAP_OFFSET)) isTap.value = false;
	};
	return {
		move,
		start: start$1,
		reset,
		startX,
		startY,
		deltaX,
		deltaY,
		offsetX,
		offsetY,
		direction,
		isVertical,
		isHorizontal,
		isTap
	};
}

//#endregion
//#region node_modules/vant/es/composables/use-lock-scroll.mjs
var totalLockCount = 0;
var 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 { scrollHeight, offsetHeight, scrollTop } = getScrollParent(event.target, rootRef.value);
		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);
	onDeactivated(destroy);
	onBeforeUnmount(destroy);
	watch(shouldLock, (value) => {
		value ? lock() : unlock();
	});
}

//#endregion
//#region node_modules/vant/es/composables/use-lazy-render.mjs
function useLazyRender(show) {
	const inited = ref(false);
	watch(show, (value) => {
		if (value) inited.value = value;
	}, { immediate: true });
	return (render) => () => inited.value ? render() : null;
}

//#endregion
//#region node_modules/vant/es/composables/use-scope-id.mjs
var useScopeId = () => {
	var _a;
	const { scopeId } = ((_a = getCurrentInstance()) == null ? void 0 : _a.vnode) || {};
	return scopeId ? { [scopeId]: "" } : null;
};

//#endregion
//#region node_modules/vant/es/overlay/Overlay.mjs
var [name$102, bem$97] = createNamespace("overlay");
var overlayProps = {
	show: Boolean,
	zIndex: numericProp,
	duration: numericProp,
	className: unknownProp,
	lockScroll: truthProp,
	lazyRender: truthProp,
	customStyle: Object,
	teleport: [String, Object]
};
var stdin_default$113 = defineComponent({
	name: name$102,
	inheritAttrs: false,
	props: overlayProps,
	setup(props$1, { attrs, slots }) {
		const root = ref();
		const lazyRender = useLazyRender(() => props$1.show || !props$1.lazyRender);
		const onTouchMove = (event) => {
			if (props$1.lockScroll) preventDefault(event, true);
		};
		const renderOverlay = lazyRender(() => {
			var _a;
			const style = extend(getZIndexStyle(props$1.zIndex), props$1.customStyle);
			if (isDef(props$1.duration)) style.animationDuration = `${props$1.duration}s`;
			return withDirectives(createVNode("div", mergeProps({
				"ref": root,
				"style": style,
				"class": [bem$97(), props$1.className]
			}, attrs), [(_a = slots.default) == null ? void 0 : _a.call(slots)]), [[vShow, props$1.show]]);
		});
		useEventListener("touchmove", onTouchMove, { target: root });
		return () => {
			const Content = createVNode(Transition, {
				"name": "van-fade",
				"appear": true
			}, { default: renderOverlay });
			if (props$1.teleport) return createVNode(Teleport, { "to": props$1.teleport }, { default: () => [Content] });
			return Content;
		};
	}
});

//#endregion
//#region node_modules/vant/es/overlay/index.mjs
var Overlay = withInstall(stdin_default$113);

//#endregion
//#region node_modules/vant/es/popup/Popup.mjs
var popupProps$2 = extend({}, popupSharedProps, {
	round: Boolean,
	position: makeStringProp("center"),
	closeIcon: makeStringProp("cross"),
	closeable: Boolean,
	transition: String,
	iconPrefix: String,
	closeOnPopstate: Boolean,
	closeIconPosition: makeStringProp("top-right"),
	destroyOnClose: Boolean,
	safeAreaInsetTop: Boolean,
	safeAreaInsetBottom: Boolean
});
var [name$101, bem$96] = createNamespace("popup");
var stdin_default$112 = defineComponent({
	name: name$101,
	inheritAttrs: false,
	props: popupProps$2,
	emits: [
		"open",
		"close",
		"opened",
		"closed",
		"keydown",
		"update:show",
		"clickOverlay",
		"clickCloseIcon"
	],
	setup(props$1, { emit, attrs, slots }) {
		let opened;
		let shouldReopen;
		const zIndex = ref();
		const popupRef = ref();
		const lazyRender = useLazyRender(() => props$1.show || !props$1.lazyRender);
		const style = computed(() => {
			const style2 = { zIndex: zIndex.value };
			if (isDef(props$1.duration)) {
				const key = props$1.position === "center" ? "animationDuration" : "transitionDuration";
				style2[key] = `${props$1.duration}s`;
			}
			return style2;
		});
		const open = () => {
			if (!opened) {
				opened = true;
				zIndex.value = props$1.zIndex !== void 0 ? +props$1.zIndex : useGlobalZIndex();
				emit("open");
			}
		};
		const close = () => {
			if (opened) callInterceptor(props$1.beforeClose, { done() {
				opened = false;
				emit("close");
				emit("update:show", false);
			} });
		};
		const onClickOverlay = (event) => {
			emit("clickOverlay", event);
			if (props$1.closeOnClickOverlay) close();
		};
		const renderOverlay = () => {
			if (props$1.overlay) return createVNode(Overlay, mergeProps(extend({
				show: props$1.show,
				class: props$1.overlayClass,
				zIndex: zIndex.value,
				duration: props$1.duration,
				customStyle: props$1.overlayStyle,
				role: props$1.closeOnClickOverlay ? "button" : void 0,
				tabindex: props$1.closeOnClickOverlay ? 0 : void 0
			}, props$1.overlayProps), useScopeId(), { "onClick": onClickOverlay }), { default: slots["overlay-content"] });
		};
		const onClickCloseIcon = (event) => {
			emit("clickCloseIcon", event);
			close();
		};
		const renderCloseIcon = () => {
			if (props$1.closeable) return createVNode(Icon, {
				"role": "button",
				"tabindex": 0,
				"name": props$1.closeIcon,
				"class": [bem$96("close-icon", props$1.closeIconPosition), HAPTICS_FEEDBACK],
				"classPrefix": props$1.iconPrefix,
				"onClick": onClickCloseIcon
			}, null);
		};
		let timer$1;
		const onOpened = () => {
			if (timer$1) clearTimeout(timer$1);
			timer$1 = setTimeout(() => {
				emit("opened");
			});
		};
		const onClosed = () => emit("closed");
		const onKeydown = (event) => emit("keydown", event);
		const renderPopup = lazyRender(() => {
			var _a;
			const { destroyOnClose, round: round$1, position, safeAreaInsetTop, safeAreaInsetBottom, show } = props$1;
			if (!show && destroyOnClose) return;
			return withDirectives(createVNode("div", mergeProps({
				"ref": popupRef,
				"style": style.value,
				"role": "dialog",
				"tabindex": 0,
				"class": [bem$96({
					round: round$1,
					[position]: position
				}), {
					"van-safe-area-top": safeAreaInsetTop,
					"van-safe-area-bottom": safeAreaInsetBottom
				}],
				"onKeydown": onKeydown
			}, attrs, useScopeId()), [(_a = slots.default) == null ? void 0 : _a.call(slots), renderCloseIcon()]), [[vShow, show]]);
		});
		const renderTransition = () => {
			const { position, transition, transitionAppear } = props$1;
			const name2 = position === "center" ? "van-fade" : `van-popup-slide-${position}`;
			return createVNode(Transition, {
				"name": transition || name2,
				"appear": transitionAppear,
				"onAfterEnter": onOpened,
				"onAfterLeave": onClosed
			}, { default: renderPopup });
		};
		watch(() => props$1.show, (show) => {
			if (show && !opened) {
				open();
				if (attrs.tabindex === 0) nextTick(() => {
					var _a;
					(_a = popupRef.value) == null || _a.focus();
				});
			}
			if (!show && opened) {
				opened = false;
				emit("close");
			}
		});
		useExpose({ popupRef });
		useLockScroll(popupRef, () => props$1.show && props$1.lockScroll);
		useEventListener("popstate", () => {
			if (props$1.closeOnPopstate) {
				close();
				shouldReopen = false;
			}
		});
		onMounted(() => {
			if (props$1.show) open();
		});
		onActivated(() => {
			if (shouldReopen) {
				emit("update:show", true);
				shouldReopen = false;
			}
		});
		onDeactivated(() => {
			if (props$1.show && props$1.teleport) {
				close();
				shouldReopen = true;
			}
		});
		provide(POPUP_TOGGLE_KEY, () => props$1.show);
		return () => {
			if (props$1.teleport) return createVNode(Teleport, { "to": props$1.teleport }, { default: () => [renderOverlay(), renderTransition()] });
			return createVNode(Fragment, null, [renderOverlay(), renderTransition()]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/popup/index.mjs
var Popup = withInstall(stdin_default$112);

//#endregion
//#region node_modules/vant/es/action-sheet/ActionSheet.mjs
var [name$100, bem$95] = createNamespace("action-sheet");
var actionSheetProps = extend({}, popupSharedProps, {
	title: String,
	round: truthProp,
	actions: makeArrayProp(),
	closeIcon: makeStringProp("cross"),
	closeable: truthProp,
	cancelText: String,
	description: String,
	closeOnPopstate: truthProp,
	closeOnClickAction: Boolean,
	safeAreaInsetBottom: truthProp
});
var popupInheritKeys$2 = [
	...popupSharedPropKeys,
	"round",
	"closeOnPopstate",
	"safeAreaInsetBottom"
];
var stdin_default$111 = defineComponent({
	name: name$100,
	props: actionSheetProps,
	emits: [
		"select",
		"cancel",
		"update:show"
	],
	setup(props$1, { slots, emit }) {
		const updateShow = (show) => emit("update:show", show);
		const onCancel = () => {
			updateShow(false);
			emit("cancel");
		};
		const renderHeader = () => {
			if (props$1.title) return createVNode("div", { "class": bem$95("header") }, [props$1.title, props$1.closeable && createVNode(Icon, {
				"name": props$1.closeIcon,
				"class": [bem$95("close"), HAPTICS_FEEDBACK],
				"onClick": onCancel
			}, null)]);
		};
		const renderCancel = () => {
			if (slots.cancel || props$1.cancelText) return [createVNode("div", { "class": bem$95("gap") }, null), createVNode("button", {
				"type": "button",
				"class": bem$95("cancel"),
				"onClick": onCancel
			}, [slots.cancel ? slots.cancel() : props$1.cancelText])];
		};
		const renderIcon = (action) => {
			if (action.icon) return createVNode(Icon, {
				"class": bem$95("item-icon"),
				"name": action.icon
			}, null);
		};
		const renderActionContent = (action, index) => {
			if (action.loading) return createVNode(Loading, { "class": bem$95("loading-icon") }, null);
			if (slots.action) return slots.action({
				action,
				index
			});
			return [createVNode("span", { "class": bem$95("name") }, [action.name]), action.subname && createVNode("div", { "class": bem$95("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$1.closeOnClickAction) updateShow(false);
				nextTick(() => emit("select", action, index));
			};
			return createVNode("button", {
				"type": "button",
				"style": { color },
				"class": [bem$95("item", {
					loading,
					disabled
				}), className],
				"onClick": onClick
			}, [renderIcon(action), renderActionContent(action, index)]);
		};
		const renderDescription = () => {
			if (props$1.description || slots.description) {
				const content = slots.description ? slots.description() : props$1.description;
				return createVNode("div", { "class": bem$95("description") }, [content]);
			}
		};
		return () => createVNode(Popup, mergeProps({
			"class": bem$95(),
			"position": "bottom",
			"onUpdate:show": updateShow
		}, pick(props$1, popupInheritKeys$2)), { default: () => {
			var _a;
			return [
				renderHeader(),
				renderDescription(),
				createVNode("div", { "class": bem$95("content") }, [props$1.actions.map(renderAction), (_a = slots.default) == null ? void 0 : _a.call(slots)]),
				renderCancel()
			];
		} });
	}
});

//#endregion
//#region node_modules/vant/es/action-sheet/index.mjs
var ActionSheet = withInstall(stdin_default$111);

//#endregion
//#region node_modules/vant/es/picker/utils.mjs
var [name$89, bem$85, t$20] = createNamespace("picker");
var 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;
}
var isOptionExist = (options, value, fields) => value !== void 0 && options.some((option) => option[fields.value] === value);
function findOptionByValue(options, value, fields) {
	return options[findIndexOfEnabledOption(options, options.findIndex((option) => option[fields.value] === value))];
}
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);
}

//#endregion
//#region node_modules/vant/es/picker/PickerColumn.mjs
var DEFAULT_DURATION = 200;
var MOMENTUM_TIME = 300;
var MOMENTUM_DISTANCE = 15;
var [name$99, bem$94] = createNamespace("picker-column");
var PICKER_KEY = Symbol(name$99);
var stdin_default$103 = defineComponent({
	name: name$99,
	props: {
		value: numericProp,
		fields: makeRequiredProp(Object),
		options: makeArrayProp(),
		readonly: Boolean,
		allowHtml: Boolean,
		optionHeight: makeRequiredProp(Number),
		swipeDuration: makeRequiredProp(numericProp),
		visibleOptionNum: makeRequiredProp(numericProp)
	},
	emits: [
		"change",
		"clickOption",
		"scrollInto"
	],
	setup(props$1, { emit, slots }) {
		let moving;
		let startOffset;
		let touchStartTime;
		let momentumOffset;
		let transitionEndTrigger;
		const root = ref();
		const wrapper = ref();
		const currentOffset = ref(0);
		const currentDuration = ref(0);
		const touch = useTouch();
		const count = () => props$1.options.length;
		const baseOffset = () => props$1.optionHeight * (+props$1.visibleOptionNum - 1) / 2;
		const updateValueByIndex = (index) => {
			let enabledIndex = findIndexOfEnabledOption(props$1.options, index);
			const offset$1 = -enabledIndex * props$1.optionHeight;
			const trigger = () => {
				if (enabledIndex > count() - 1) enabledIndex = findIndexOfEnabledOption(props$1.options, index);
				const value = props$1.options[enabledIndex][props$1.fields.value];
				if (value !== props$1.value) emit("change", value);
			};
			if (moving && offset$1 !== currentOffset.value) transitionEndTrigger = trigger;
			else trigger();
			currentOffset.value = offset$1;
		};
		const isReadonly = () => props$1.readonly || !props$1.options.length;
		const onClickOption = (index) => {
			if (moving || isReadonly()) return;
			transitionEndTrigger = null;
			currentDuration.value = DEFAULT_DURATION;
			updateValueByIndex(index);
			emit("clickOption", props$1.options[index]);
		};
		const getIndexByOffset = (offset$1) => clamp(Math.round(-offset$1 / props$1.optionHeight), 0, count() - 1);
		const currentIndex = computed(() => getIndexByOffset(currentOffset.value));
		const momentum = (distance, duration) => {
			const speed = Math.abs(distance / duration);
			distance = currentOffset.value + speed / .003 * (distance < 0 ? -1 : 1);
			const index = getIndexByOffset(distance);
			currentDuration.value = +props$1.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);
			}
			const newOffset = clamp(startOffset + touch.deltaY.value, -(count() * props$1.optionHeight), props$1.optionHeight);
			const newIndex = getIndexByOffset(newOffset);
			if (newIndex !== currentIndex.value) emit("scrollInto", props$1.options[newIndex]);
			currentOffset.value = newOffset;
			const now = Date.now();
			if (now - touchStartTime > MOMENTUM_TIME) {
				touchStartTime = now;
				momentumOffset = newOffset;
			}
		};
		const onTouchEnd = () => {
			if (isReadonly()) return;
			const distance = currentOffset.value - momentumOffset;
			const duration = Date.now() - touchStartTime;
			if (duration < MOMENTUM_TIME && Math.abs(distance) > MOMENTUM_DISTANCE) {
				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$1.optionHeight}px` };
			return props$1.options.map((option, index) => {
				const text = option[props$1.fields.text];
				const { disabled } = option;
				const value = option[props$1.fields.value];
				const data = {
					role: "button",
					style: optionStyle,
					tabindex: disabled ? -1 : 0,
					class: [bem$94("item", {
						disabled,
						selected: value === props$1.value
					}), option.className],
					onClick: () => onClickOption(index)
				};
				const childData = {
					class: "van-ellipsis",
					[props$1.allowHtml ? "innerHTML" : "textContent"]: text
				};
				return createVNode("li", data, [slots.option ? slots.option(option, index) : createVNode("div", childData, null)]);
			});
		};
		useParent(PICKER_KEY);
		useExpose({ stopMomentum });
		watchEffect(() => {
			const index = moving ? Math.floor(-currentOffset.value / props$1.optionHeight) : props$1.options.findIndex((option) => option[props$1.fields.value] === props$1.value);
			const enabledIndex = findIndexOfEnabledOption(props$1.options, index);
			const offset$1 = -enabledIndex * props$1.optionHeight;
			if (moving && enabledIndex < index) stopMomentum();
			currentOffset.value = offset$1;
		});
		useEventListener("touchmove", onTouchMove, { target: root });
		return () => createVNode("div", {
			"ref": root,
			"class": bem$94(),
			"onTouchstartPassive": onTouchStart,
			"onTouchend": onTouchEnd,
			"onTouchcancel": onTouchEnd
		}, [createVNode("ul", {
			"ref": wrapper,
			"style": {
				transform: `translate3d(0, ${currentOffset.value + baseOffset()}px, 0)`,
				transitionDuration: `${currentDuration.value}ms`,
				transitionProperty: currentDuration.value ? "all" : "none"
			},
			"class": bem$94("wrapper"),
			"onTransitionend": stopMomentum
		}, [renderOptions()])]);
	}
});

//#endregion
//#region node_modules/vant/es/picker/PickerToolbar.mjs
var [name$98] = createNamespace("picker-toolbar");
var pickerToolbarProps = {
	title: String,
	cancelButtonText: String,
	confirmButtonText: String
};
var pickerToolbarSlots = [
	"cancel",
	"confirm",
	"title",
	"toolbar"
];
var pickerToolbarPropKeys = Object.keys(pickerToolbarProps);
var stdin_default$104 = defineComponent({
	name: name$98,
	props: pickerToolbarProps,
	emits: ["confirm", "cancel"],
	setup(props$1, { emit, slots }) {
		const renderTitle = () => {
			if (slots.title) return slots.title();
			if (props$1.title) return createVNode("div", { "class": [bem$85("title"), "van-ellipsis"] }, [props$1.title]);
		};
		const onCancel = () => emit("cancel");
		const onConfirm = () => emit("confirm");
		const renderCancel = () => {
			var _a;
			const text = (_a = props$1.cancelButtonText) != null ? _a : t$20("cancel");
			if (!slots.cancel && !text) return;
			return createVNode("button", {
				"type": "button",
				"class": [bem$85("cancel"), HAPTICS_FEEDBACK],
				"onClick": onCancel
			}, [slots.cancel ? slots.cancel() : text]);
		};
		const renderConfirm = () => {
			var _a;
			const text = (_a = props$1.confirmButtonText) != null ? _a : t$20("confirm");
			if (!slots.confirm && !text) return;
			return createVNode("button", {
				"type": "button",
				"class": [bem$85("confirm"), HAPTICS_FEEDBACK],
				"onClick": onConfirm
			}, [slots.confirm ? slots.confirm() : text]);
		};
		return () => createVNode("div", { "class": bem$85("toolbar") }, [slots.toolbar ? slots.toolbar() : [
			renderCancel(),
			renderTitle(),
			renderConfirm()
		]]);
	}
});

//#endregion
//#region node_modules/vant/es/composables/use-sync-prop-ref.mjs
var useSyncPropRef = (getProp, setProp) => {
	const propRef = ref(getProp());
	watch(getProp, (value) => {
		if (value !== propRef.value) propRef.value = value;
	});
	watch(propRef, (value) => {
		if (value !== getProp()) setProp(value);
	});
	return propRef;
};

//#endregion
//#region node_modules/vant/es/tabs/utils.mjs
function scrollLeftTo(scroller, to, duration) {
	let rafId;
	let count = 0;
	const from = scroller.scrollLeft;
	const frames = duration === 0 ? 1 : Math.round(duration * 1e3 / 16);
	let scrollLeft = from;
	function cancel() {
		cancelRaf(rafId);
	}
	function animate() {
		scrollLeft += (to - from) / frames;
		scroller.scrollLeft = scrollLeft;
		if (++count < frames) rafId = raf(animate);
	}
	animate();
	return cancel;
}
function scrollTopTo(scroller, to, duration, callback) {
	let rafId;
	let current$1 = getScrollTop(scroller);
	const isDown = current$1 < to;
	const frames = duration === 0 ? 1 : Math.round(duration * 1e3 / 16);
	const step = (to - current$1) / frames;
	function cancel() {
		cancelRaf(rafId);
	}
	function animate() {
		current$1 += step;
		if (isDown && current$1 > to || !isDown && current$1 < to) current$1 = to;
		setScrollTop(scroller, current$1);
		if (isDown && current$1 < to || !isDown && current$1 > to) rafId = raf(animate);
		else if (callback) rafId = raf(callback);
	}
	animate();
	return cancel;
}

//#endregion
//#region node_modules/vant/es/composables/use-id.mjs
var current = 0;
function useId() {
	const vm = getCurrentInstance();
	const { name: name$111 = "unknown" } = (vm == null ? void 0 : vm.type) || {};
	return `${name$111}-${++current}`;
}

//#endregion
//#region node_modules/vant/es/composables/use-refs.mjs
function useRefs() {
	const refs = ref([]);
	const cache = [];
	onBeforeUpdate(() => {
		refs.value = [];
	});
	const setRefs = (index) => {
		if (!cache[index]) cache[index] = (el) => {
			refs.value[index] = el;
		};
		return cache[index];
	};
	return [refs, setRefs];
}

//#endregion
//#region node_modules/vant/es/composables/use-visibility-change.mjs
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);
	};
	onDeactivated(unobserve);
	onBeforeUnmount(unobserve);
	onMountedOrActivated(observe);
}

//#endregion
//#region node_modules/vant/es/sticky/Sticky.mjs
var [name$97, bem$93] = createNamespace("sticky");
var stickyProps = {
	zIndex: numericProp,
	position: makeStringProp("top"),
	container: Object,
	offsetTop: makeNumericProp(0),
	offsetBottom: makeNumericProp(0)
};
var stdin_default$110 = defineComponent({
	name: name$97,
	props: stickyProps,
	emits: ["scroll", "change"],
	setup(props$1, { emit, slots }) {
		const root = ref();
		const scrollParent = useScrollParent(root);
		const state = reactive({
			fixed: false,
			width: 0,
			height: 0,
			transform: 0
		});
		const isReset = ref(false);
		const offset$1 = computed(() => unitToPx(props$1.position === "top" ? props$1.offsetTop : props$1.offsetBottom));
		const rootStyle = computed(() => {
			if (isReset.value) return;
			const { fixed, height: height$1, width: width$1 } = state;
			if (fixed) return {
				width: `${width$1}px`,
				height: `${height$1}px`
			};
		});
		const stickyStyle = computed(() => {
			if (!state.fixed || isReset.value) return;
			const style = extend(getZIndexStyle(props$1.zIndex), {
				width: `${state.width}px`,
				height: `${state.height}px`,
				[props$1.position]: `${offset$1.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$1;
			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 - offset$1.value - state.height;
				state.fixed = offset$1.value > rootRect.top && containerRect.bottom > 0;
				state.transform = difference < 0 ? difference : 0;
			} else state.fixed = offset$1.value > rootRect.top;
			else {
				const { clientHeight } = document.documentElement;
				if (container) {
					const containerRect = useRect(container);
					const difference = clientHeight - containerRect.top - offset$1.value - state.height;
					state.fixed = clientHeight - offset$1.value < rootRect.bottom && clientHeight > containerRect.top;
					state.transform = difference < 0 ? -difference : 0;
				} else state.fixed = clientHeight - offset$1.value < rootRect.bottom;
			}
			emitScroll(scrollTop);
		};
		watch(() => state.fixed, (value) => emit("change", value));
		useEventListener("scroll", onScroll, {
			target: scrollParent,
			passive: true
		});
		useVisibilityChange(root, onScroll);
		watch([windowWidth, windowHeight], () => {
			if (!root.value || isHidden(root) || !state.fixed) return;
			isReset.value = true;
			nextTick(() => {
				const rootRect = useRect(root);
				state.width = rootRect.width;
				state.height = rootRect.height;
				isReset.value = false;
			});
		});
		return () => {
			var _a;
			return createVNode("div", {
				"ref": root,
				"style": rootStyle.value
			}, [createVNode("div", {
				"class": bem$93({ fixed: state.fixed && !isReset.value }),
				"style": stickyStyle.value
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/sticky/index.mjs
var Sticky = withInstall(stdin_default$110);

//#endregion
//#region node_modules/vant/es/swipe/Swipe.mjs
var [name$96, bem$92] = createNamespace("swipe");
var 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
};
var SWIPE_KEY = Symbol(name$96);
var stdin_default$109 = defineComponent({
	name: name$96,
	props: swipeProps,
	emits: [
		"change",
		"dragStart",
		"dragEnd"
	],
	setup(props$1, { emit, slots }) {
		const root = ref();
		const track = ref();
		const state = 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 = computed(() => children.length);
		const size = computed(() => state[props$1.vertical ? "height" : "width"]);
		const delta = computed(() => props$1.vertical ? touch.deltaY.value : touch.deltaX.value);
		const minOffset = computed(() => {
			if (state.rect) return (props$1.vertical ? state.rect.height : state.rect.width) - size.value * count.value;
			return 0;
		});
		const maxCount = computed(() => size.value ? Math.ceil(Math.abs(minOffset.value) / size.value) : count.value);
		const trackSize = computed(() => count.value * size.value);
		const activeIndicator = computed(() => (state.active + count.value) % count.value);
		const isCorrectDirection = computed(() => {
			const expect = props$1.vertical ? "vertical" : "horizontal";
			return touch.direction.value === expect;
		});
		const trackStyle = computed(() => {
			const style = {
				transitionDuration: `${state.swiping ? 0 : props$1.duration}ms`,
				transform: `translate${props$1.vertical ? "Y" : "X"}(${+state.offset.toFixed(2)}px)`
			};
			if (size.value) {
				const mainAxis = props$1.vertical ? "height" : "width";
				const crossAxis = props$1.vertical ? "width" : "height";
				style[mainAxis] = `${trackSize.value}px`;
				style[crossAxis] = props$1[crossAxis] ? `${props$1[crossAxis]}px` : "";
			}
			return style;
		});
		const getTargetActive = (pace) => {
			const { active } = state;
			if (pace) {
				if (props$1.loop) return clamp(active + pace, -1, count.value);
				return clamp(active + pace, 0, maxCount.value);
			}
			return active;
		};
		const getTargetOffset = (targetActive, offset$1 = 0) => {
			let currentPosition = targetActive * size.value;
			if (!props$1.loop) currentPosition = Math.min(currentPosition, -minOffset.value);
			let targetOffset = offset$1 - currentPosition;
			if (!props$1.loop) targetOffset = clamp(targetOffset, minOffset.value, 0);
			return targetOffset;
		};
		const move = ({ pace = 0, offset: offset$1 = 0, emitChange }) => {
			if (count.value <= 1) return;
			const { active } = state;
			const targetActive = getTargetActive(pace);
			const targetOffset = getTargetOffset(targetActive, offset$1);
			if (props$1.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$1.autoplay > 0 && count.value > 1) autoplayTimer = setTimeout(() => {
				next();
				autoplay();
			}, +props$1.autoplay);
		};
		const initialize = (active = +props$1.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$1.width) != null ? _a : rect.width);
					state.height = +((_b = props$1.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)) nextTick().then(cb);
			else cb();
		};
		const resize = () => initialize(state.active);
		let touchStartTime;
		const onTouchStart = (event) => {
			if (!props$1.touchable || event.touches.length > 1) return;
			touch.start(event);
			dragging = false;
			touchStartTime = Date.now();
			stopAutoplay();
			correctPosition();
		};
		const onTouchMove = (event) => {
			if (props$1.touchable && state.swiping) {
				touch.move(event);
				if (isCorrectDirection.value) {
					if (!(!props$1.loop && (state.active === 0 && delta.value > 0 || state.active === count.value - 1 && delta.value < 0))) {
						preventDefault(event, props$1.stopPropagation);
						move({ offset: delta.value });
						if (!dragging) {
							emit("dragStart", { index: activeIndicator.value });
							dragging = true;
						}
					}
				}
			}
		};
		const onTouchEnd = () => {
			if (!props$1.touchable || !state.swiping) return;
			const duration = Date.now() - touchStartTime;
			const speed = delta.value / duration;
			if ((Math.abs(speed) > .25 || Math.abs(delta.value) > size.value / 2) && isCorrectDirection.value) {
				const offset$1 = props$1.vertical ? touch.offsetY.value : touch.offsetX.value;
				let pace = 0;
				if (props$1.loop) pace = offset$1 > 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$1.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$1.indicatorColor } : void 0;
			return createVNode("i", {
				"style": style,
				"class": bem$92("indicator", { active })
			}, null);
		};
		const renderIndicator = () => {
			if (slots.indicator) return slots.indicator({
				active: activeIndicator.value,
				total: count.value
			});
			if (props$1.showIndicators && count.value > 1) return createVNode("div", { "class": bem$92("indicators", { vertical: props$1.vertical }) }, [Array(count.value).fill("").map(renderDot)]);
		};
		useExpose({
			prev,
			next,
			state,
			resize,
			swipeTo
		});
		linkChildren({
			size,
			props: props$1,
			count,
			activeIndicator
		});
		watch(() => props$1.initialSwipe, (value) => initialize(+value));
		watch(count, () => initialize(state.active));
		watch(() => props$1.autoplay, autoplay);
		watch([
			windowWidth,
			windowHeight,
			() => props$1.width,
			() => props$1.height
		], resize);
		watch(usePageVisibility(), (visible) => {
			if (visible === "visible") autoplay();
			else stopAutoplay();
		});
		onMounted(initialize);
		onActivated(() => initialize(state.active));
		onPopupReopen(() => initialize(state.active));
		onDeactivated(stopAutoplay);
		onBeforeUnmount(stopAutoplay);
		useEventListener("touchmove", onTouchMove, { target: track });
		return () => {
			var _a;
			return createVNode("div", {
				"ref": root,
				"class": bem$92()
			}, [createVNode("div", {
				"ref": track,
				"style": trackStyle.value,
				"class": bem$92("track", { vertical: props$1.vertical }),
				"onTouchstartPassive": onTouchStart,
				"onTouchend": onTouchEnd,
				"onTouchcancel": onTouchEnd
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]), renderIndicator()]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/swipe/index.mjs
var Swipe = withInstall(stdin_default$109);

//#endregion
//#region node_modules/vant/es/tabs/TabsContent.mjs
var [name$95, bem$91] = createNamespace("tabs");
var stdin_default$108 = defineComponent({
	name: name$95,
	props: {
		count: makeRequiredProp(Number),
		inited: Boolean,
		animated: Boolean,
		duration: makeRequiredProp(numericProp),
		swipeable: Boolean,
		lazyRender: Boolean,
		currentIndex: makeRequiredProp(Number)
	},
	emits: ["change"],
	setup(props$1, { emit, slots }) {
		const swipeRef = ref();
		const onChange = (index) => emit("change", index);
		const renderChildren = () => {
			var _a;
			const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
			if (props$1.animated || props$1.swipeable) return createVNode(Swipe, {
				"ref": swipeRef,
				"loop": false,
				"class": bem$91("track"),
				"duration": +props$1.duration * 1e3,
				"touchable": props$1.swipeable,
				"lazyRender": props$1.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$1.inited });
		};
		watch(() => props$1.currentIndex, swipeToCurrentTab);
		onMounted(() => {
			swipeToCurrentTab(props$1.currentIndex);
		});
		useExpose({ swipeRef });
		return () => createVNode("div", { "class": bem$91("content", { animated: props$1.animated || props$1.swipeable }) }, [renderChildren()]);
	}
});

//#endregion
//#region node_modules/vant/es/tabs/Tabs.mjs
var [name$94, bem$90] = createNamespace("tabs");
var tabsProps = {
	type: makeStringProp("line"),
	color: String,
	border: Boolean,
	sticky: Boolean,
	shrink: Boolean,
	active: makeNumericProp(0),
	duration: makeNumericProp(.3),
	animated: Boolean,
	ellipsis: truthProp,
	swipeable: Boolean,
	scrollspy: Boolean,
	offsetTop: makeNumericProp(0),
	background: String,
	lazyRender: truthProp,
	showHeader: truthProp,
	lineWidth: numericProp,
	lineHeight: numericProp,
	beforeChange: Function,
	swipeThreshold: makeNumericProp(5),
	titleActiveColor: String,
	titleInactiveColor: String
};
var TABS_KEY = Symbol(name$94);
var stdin_default$105 = defineComponent({
	name: name$94,
	props: tabsProps,
	emits: [
		"change",
		"scroll",
		"rendered",
		"clickTab",
		"update:active"
	],
	setup(props$1, { emit, slots }) {
		let tabHeight;
		let lockScroll;
		let stickyFixed;
		let cancelScrollLeftToRaf;
		let cancelScrollTopToRaf;
		const root = ref();
		const navRef = ref();
		const wrapRef = ref();
		const contentRef = ref();
		const id = useId();
		const scroller = useScrollParent(root);
		const [titleRefs, setTitleRefs] = useRefs();
		const { children, linkChildren } = useChildren(TABS_KEY);
		const state = reactive({
			inited: false,
			position: "",
			lineStyle: {},
			currentIndex: -1
		});
		const scrollable = computed(() => children.length > +props$1.swipeThreshold || !props$1.ellipsis || props$1.shrink);
		const navStyle = computed(() => ({
			borderColor: props$1.color,
			background: props$1.background
		}));
		const getTabName = (tab, index) => {
			var _a;
			return (_a = tab.name) != null ? _a : index;
		};
		const currentName = computed(() => {
			const activeTab = children[state.currentIndex];
			if (activeTab) return getTabName(activeTab, state.currentIndex);
		});
		const offsetTopPx = computed(() => unitToPx(props$1.offsetTop));
		const scrollOffset = computed(() => {
			if (props$1.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;
			if (cancelScrollLeftToRaf) cancelScrollLeftToRaf();
			cancelScrollLeftToRaf = scrollLeftTo(nav, to, immediate ? 0 : +props$1.duration);
		};
		const setLine = () => {
			const shouldAnimate = state.inited;
			nextTick(() => {
				const titles = titleRefs.value;
				if (!titles || !titles[state.currentIndex] || props$1.type !== "line" || isHidden(root.value)) return;
				const title = titles[state.currentIndex].$el;
				const { lineWidth, lineHeight } = props$1;
				const left$1 = title.offsetLeft + title.offsetWidth / 2;
				const lineStyle = {
					width: addUnit(lineWidth),
					backgroundColor: props$1.color,
					transform: `translateX(${left$1}px) translateX(-50%)`
				};
				if (shouldAnimate) lineStyle.transitionDuration = `${props$1.duration}s`;
				if (isDef(lineHeight)) {
					const height$1 = addUnit(lineHeight);
					lineStyle.height = height$1;
					lineStyle.borderRadius = height$1;
				}
				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$1.active) {
				emit("update:active", newName);
				if (shouldEmitChange) emit("change", newName, newTab.title);
			}
			if (stickyFixed && !props$1.scrollspy) setRootScrollTop(Math.ceil(getElementTop(root.value) - offsetTopPx.value));
		};
		const setCurrentIndexByName = (name2, skipScrollIntoView) => {
			const index = children.findIndex((tab, index2) => getTabName(tab, index2) === name2);
			setCurrentIndex(index === -1 ? 0 : index, skipScrollIntoView);
		};
		const scrollToCurrentContent = (immediate = false) => {
			if (props$1.scrollspy) {
				const target = children[state.currentIndex].$el;
				if (target && scroller.value) {
					const to = getElementTop(target, scroller.value) - scrollOffset.value;
					lockScroll = true;
					if (cancelScrollTopToRaf) cancelScrollTopToRaf();
					cancelScrollTopToRaf = scrollTopTo(scroller.value, to, immediate ? 0 : +props$1.duration, () => {
						lockScroll = false;
					});
				}
			}
		};
		const onClickTab = (item, index, event) => {
			const { title, disabled } = children[index];
			const name2 = getTabName(children[index], index);
			if (!disabled) {
				callInterceptor(props$1.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) => {
			nextTick(() => {
				setCurrentIndexByName(name2);
				scrollToCurrentContent(true);
			});
		};
		const getCurrentIndexOnScroll = () => {
			for (let index = 0; index < children.length; index++) {
				const { top: top$1 } = useRect(children[index].$el);
				if (top$1 > scrollOffset.value) return index === 0 ? 0 : index - 1;
			}
			return children.length - 1;
		};
		const onScroll = () => {
			if (props$1.scrollspy && !lockScroll) setCurrentIndex(getCurrentIndexOnScroll());
		};
		const renderLine = () => {
			if (props$1.type === "line" && children.length) return createVNode("div", {
				"class": bem$90("line"),
				"style": state.lineStyle
			}, null);
		};
		const renderHeader = () => {
			var _a, _b, _c;
			const { type, border, sticky } = props$1;
			const Header = [createVNode("div", {
				"ref": sticky ? void 0 : wrapRef,
				"class": [bem$90("wrap"), { [BORDER_TOP_BOTTOM]: type === "line" && border }]
			}, [createVNode("div", {
				"ref": navRef,
				"role": "tablist",
				"class": bem$90("nav", [type, {
					shrink: props$1.shrink,
					complete: scrollable.value
				}]),
				"style": navStyle.value,
				"aria-orientation": "horizontal"
			}, [
				(_a = slots["nav-left"]) == null ? void 0 : _a.call(slots),
				children.map((item) => item.renderTitle(onClickTab)),
				renderLine(),
				(_b = slots["nav-right"]) == null ? void 0 : _b.call(slots)
			])]), (_c = slots["nav-bottom"]) == null ? void 0 : _c.call(slots)];
			if (sticky) return createVNode("div", { "ref": wrapRef }, [Header]);
			return Header;
		};
		const resize = () => {
			setLine();
			nextTick(() => {
				var _a, _b;
				scrollIntoView(true);
				(_b = (_a = contentRef.value) == null ? void 0 : _a.swipeRef.value) == null || _b.resize();
			});
		};
		watch(() => [
			props$1.color,
			props$1.duration,
			props$1.lineWidth,
			props$1.lineHeight
		], setLine);
		watch(windowWidth, resize);
		watch(() => props$1.active, (value) => {
			if (value !== currentName.value) setCurrentIndexByName(value);
		});
		watch(() => children.length, () => {
			if (state.inited) {
				setCurrentIndexByName(props$1.active);
				setLine();
				nextTick(() => {
					scrollIntoView(true);
				});
			}
		});
		const init = () => {
			setCurrentIndexByName(props$1.active, true);
			nextTick(() => {
				state.inited = true;
				if (wrapRef.value) tabHeight = useRect(wrapRef.value).height;
				scrollIntoView(true);
			});
		};
		const onRendered = (name2, title) => emit("rendered", name2, title);
		useExpose({
			resize,
			scrollTo
		});
		onActivated(setLine);
		onPopupReopen(setLine);
		onMountedOrActivated(init);
		useVisibilityChange(root, setLine);
		useEventListener("scroll", onScroll, {
			target: scroller,
			passive: true
		});
		linkChildren({
			id,
			props: props$1,
			setLine,
			scrollable,
			onRendered,
			currentName,
			setTitleRefs,
			scrollIntoView
		});
		return () => createVNode("div", {
			"ref": root,
			"class": bem$90([props$1.type])
		}, [props$1.showHeader ? props$1.sticky ? createVNode(Sticky, {
			"container": root.value,
			"offsetTop": offsetTopPx.value,
			"onScroll": onStickyScroll
		}, { default: () => [renderHeader()] }) : renderHeader() : null, createVNode(stdin_default$108, {
			"ref": contentRef,
			"count": children.length,
			"inited": state.inited,
			"animated": props$1.animated,
			"duration": props$1.duration,
			"swipeable": props$1.swipeable,
			"lazyRender": props$1.lazyRender,
			"currentIndex": state.currentIndex,
			"onChange": setCurrentIndex
		}, { default: () => {
			var _a;
			return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
		} })]);
	}
});

//#endregion
//#region node_modules/vant/es/composables/use-tab-status.mjs
var TAB_STATUS_KEY = Symbol();
var ALL_TAB_STATUS_KEY = Symbol();
var useTabStatus = () => inject(TAB_STATUS_KEY, null);
var useAllTabStatus = () => inject(ALL_TAB_STATUS_KEY, null);
var useProvideTabStatus = (status) => {
	const allTabStatus = useAllTabStatus();
	provide(TAB_STATUS_KEY, status);
	provide(ALL_TAB_STATUS_KEY, computed(() => {
		return (allTabStatus == null || allTabStatus.value) && status.value;
	}));
};

//#endregion
//#region node_modules/vant/es/tab/TabTitle.mjs
var [name$93, bem$89] = createNamespace("tab");
var TabTitle = defineComponent({
	name: name$93,
	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$1, { slots }) {
		const style = computed(() => {
			const style2 = {};
			const { type, color, disabled, isActive, activeColor, inactiveColor } = props$1;
			if (color && type === "card") {
				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$1 = createVNode("span", { "class": bem$89("text", { ellipsis: !props$1.scrollable }) }, [slots.title ? slots.title() : props$1.title]);
			if (props$1.dot || isDef(props$1.badge) && props$1.badge !== "") return createVNode(Badge, {
				"dot": props$1.dot,
				"content": props$1.badge,
				"showZero": props$1.showZeroBadge
			}, { default: () => [Text$1] });
			return Text$1;
		};
		return () => createVNode("div", {
			"id": props$1.id,
			"role": "tab",
			"class": [bem$89([props$1.type, {
				grow: props$1.scrollable && !props$1.shrink,
				shrink: props$1.shrink,
				active: props$1.isActive,
				disabled: props$1.disabled
			}])],
			"style": style.value,
			"tabindex": props$1.disabled ? void 0 : props$1.isActive ? 0 : -1,
			"aria-selected": props$1.isActive,
			"aria-disabled": props$1.disabled || void 0,
			"aria-controls": props$1.controls,
			"data-allow-mismatch": "attribute"
		}, [renderText()]);
	}
});

//#endregion
//#region node_modules/vant/es/swipe-item/SwipeItem.mjs
var [name$92, bem$88] = createNamespace("swipe-item");
var stdin_default$107 = defineComponent({
	name: name$92,
	setup(props$1, { slots }) {
		let rendered;
		const state = reactive({
			offset: 0,
			inited: false,
			mounted: false
		});
		const { parent, index } = useParent(SWIPE_KEY);
		if (!parent) {
			console.error("[Vant] <SwipeItem> must be a child component of <Swipe>.");
			return;
		}
		const style = 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 = 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 = (offset$1) => {
			state.offset = offset$1;
		};
		onMounted(() => {
			nextTick(() => {
				state.mounted = true;
			});
		});
		useExpose({ setOffset });
		return () => {
			var _a;
			return createVNode("div", {
				"class": bem$88(),
				"style": style.value
			}, [shouldRender.value ? (_a = slots.default) == null ? void 0 : _a.call(slots) : null]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/swipe-item/index.mjs
var SwipeItem = withInstall(stdin_default$107);

//#endregion
//#region node_modules/vant/es/tab/Tab.mjs
init_shared_esm_bundler();
var [name$91, bem$87] = createNamespace("tab");
var tabProps = extend({}, routeProps, {
	dot: Boolean,
	name: numericProp,
	badge: numericProp,
	title: String,
	disabled: Boolean,
	titleClass: unknownProp,
	titleStyle: [String, Object],
	showZeroBadge: truthProp
});
var stdin_default$106 = defineComponent({
	name: name$91,
	props: tabProps,
	setup(props$1, { slots }) {
		const id = useId();
		const inited = ref(false);
		const instance$3 = getCurrentInstance();
		const { parent, index } = useParent(TABS_KEY);
		if (!parent) {
			console.error("[Vant] <Tab> must be a child component of <Tabs>.");
			return;
		}
		const getName = () => {
			var _a;
			return (_a = props$1.name) != null ? _a : index.value;
		};
		const init = () => {
			inited.value = true;
			if (parent.props.lazyRender) nextTick(() => {
				parent.onRendered(getName(), props$1.title);
			});
		};
		const active = computed(() => {
			const isActive = getName() === parent.currentName.value;
			if (isActive && !inited.value) init();
			return isActive;
		});
		const parsedClass = ref("");
		const parsedStyle = ref("");
		watchEffect(() => {
			const { titleClass, titleStyle } = props$1;
			parsedClass.value = titleClass ? normalizeClass(titleClass) : "";
			parsedStyle.value = titleStyle && typeof titleStyle !== "string" ? stringifyStyle(normalizeStyle(titleStyle)) : titleStyle;
		});
		const renderTitle = (onClickTab) => createVNode(TabTitle, mergeProps({
			"key": id,
			"id": `${parent.id}-${index.value}`,
			"ref": parent.setTitleRefs(index.value),
			"style": parsedStyle.value,
			"class": parsedClass.value,
			"isActive": active.value,
			"controls": id,
			"scrollable": parent.scrollable.value,
			"activeColor": parent.props.titleActiveColor,
			"inactiveColor": parent.props.titleInactiveColor,
			"onClick": (event) => onClickTab(instance$3.proxy, index.value, event)
		}, pick(parent.props, [
			"type",
			"color",
			"shrink"
		]), pick(props$1, [
			"dot",
			"badge",
			"title",
			"disabled",
			"showZeroBadge"
		])), { title: slots.title });
		const hasInactiveClass = ref(!active.value);
		watch(active, (val) => {
			if (val) hasInactiveClass.value = false;
			else doubleRaf(() => {
				hasInactiveClass.value = true;
			});
		});
		watch(() => props$1.title, () => {
			parent.setLine();
			parent.scrollIntoView();
		});
		useProvideTabStatus(active);
		useExpose({
			id,
			renderTitle
		});
		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 createVNode(SwipeItem, {
				"id": id,
				"role": "tabpanel",
				"class": bem$87("panel-wrapper", { inactive: hasInactiveClass.value }),
				"tabindex": active.value ? 0 : -1,
				"aria-hidden": !active.value,
				"aria-labelledby": label,
				"data-allow-mismatch": "attribute"
			}, { default: () => {
				var _a2;
				return [createVNode("div", { "class": bem$87("panel") }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)])];
			} });
			const Content = inited.value || scrollspy || !lazyRender ? (_a = slots.default) == null ? void 0 : _a.call(slots) : null;
			return withDirectives(createVNode("div", {
				"id": id,
				"role": "tabpanel",
				"class": bem$87("panel"),
				"tabindex": show ? 0 : -1,
				"aria-labelledby": label,
				"data-allow-mismatch": "attribute"
			}, [Content]), [[vShow, show]]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/tab/index.mjs
var Tab = withInstall(stdin_default$106);

//#endregion
//#region node_modules/vant/es/tabs/index.mjs
var Tabs = withInstall(stdin_default$105);

//#endregion
//#region node_modules/vant/es/picker-group/PickerGroup.mjs
var [name$90, bem$86] = createNamespace("picker-group");
var PICKER_GROUP_KEY = Symbol(name$90);
var pickerGroupProps = extend({
	tabs: makeArrayProp(),
	activeTab: makeNumericProp(0),
	nextStepText: String,
	showToolbar: truthProp
}, pickerToolbarProps);
var stdin_default$39 = defineComponent({
	name: name$90,
	props: pickerGroupProps,
	emits: [
		"confirm",
		"cancel",
		"update:activeTab"
	],
	setup(props$1, { emit, slots }) {
		const activeTab = useSyncPropRef(() => props$1.activeTab, (value) => emit("update:activeTab", value));
		const { children, linkChildren } = useChildren(PICKER_GROUP_KEY);
		linkChildren();
		const showNextButton = () => +activeTab.value < props$1.tabs.length - 1 && props$1.nextStepText;
		const onConfirm = () => {
			if (showNextButton()) activeTab.value = +activeTab.value + 1;
			else emit("confirm", children.map((item) => item.confirm()));
		};
		const onCancel = () => emit("cancel");
		return () => {
			var _a, _b;
			let childNodes = (_b = (_a = slots.default) == null ? void 0 : _a.call(slots)) == null ? void 0 : _b.filter((node) => node.type !== Comment).map((node) => {
				if (node.type === Fragment) return node.children;
				return node;
			});
			if (childNodes) childNodes = flat(childNodes);
			const confirmButtonText = showNextButton() ? props$1.nextStepText : props$1.confirmButtonText;
			return createVNode("div", { "class": bem$86() }, [props$1.showToolbar ? createVNode(stdin_default$104, {
				"title": props$1.title,
				"cancelButtonText": props$1.cancelButtonText,
				"confirmButtonText": confirmButtonText,
				"onConfirm": onConfirm,
				"onCancel": onCancel
			}, pick(slots, pickerToolbarSlots)) : null, createVNode(Tabs, {
				"active": activeTab.value,
				"onUpdate:active": ($event) => activeTab.value = $event,
				"class": bem$86("tabs"),
				"shrink": true,
				"animated": true,
				"lazyRender": false
			}, { default: () => [props$1.tabs.map((title, index) => createVNode(Tab, {
				"title": title,
				"titleClass": bem$86("tab-title")
			}, { default: () => [childNodes == null ? void 0 : childNodes[index]] }))] })]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/picker/Picker.mjs
var pickerSharedProps = extend({
	loading: Boolean,
	readonly: Boolean,
	allowHtml: Boolean,
	optionHeight: makeNumericProp(44),
	showToolbar: truthProp,
	swipeDuration: makeNumericProp(1e3),
	visibleOptionNum: makeNumericProp(6)
}, pickerToolbarProps);
var pickerProps = extend({}, pickerSharedProps, {
	columns: makeArrayProp(),
	modelValue: makeArrayProp(),
	toolbarPosition: makeStringProp("top"),
	columnsFieldNames: Object
});
var stdin_default$102 = defineComponent({
	name: name$89,
	props: pickerProps,
	emits: [
		"confirm",
		"cancel",
		"change",
		"scrollInto",
		"clickOption",
		"update:modelValue"
	],
	setup(props$1, { emit, slots }) {
		const columnsRef = ref();
		const selectedValues = ref(props$1.modelValue.slice(0));
		const { parent } = useParent(PICKER_GROUP_KEY);
		const { children, linkChildren } = useChildren(PICKER_KEY);
		linkChildren();
		const fields = computed(() => assignDefaultFields(props$1.columnsFieldNames));
		const optionHeight = computed(() => unitToPx(props$1.optionHeight));
		const columnsType = computed(() => getColumnsType(props$1.columns, fields.value));
		const currentColumns = computed(() => {
			const { columns } = props$1;
			switch (columnsType.value) {
				case "multiple": return columns;
				case "cascade": return formatCascadeColumns(columns, fields.value, selectedValues);
				default: return [columns];
			}
		});
		const hasOptions = computed(() => currentColumns.value.some((options) => options.length));
		const selectedOptions = computed(() => currentColumns.value.map((options, index) => findOptionByValue(options, selectedValues.value[index], fields.value)));
		const selectedIndexes = 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);
			});
			nextTick(() => {
				emit("change", extend({ columnIndex }, getEventParams()));
			});
		};
		const onClickOption = (currentOption, columnIndex) => {
			const params = {
				columnIndex,
				currentOption
			};
			emit("clickOption", extend(getEventParams(), params));
			emit("scrollInto", params);
		};
		const confirm = () => {
			children.forEach((child) => child.stopMomentum());
			const params = getEventParams();
			nextTick(() => {
				emit("confirm", getEventParams());
			});
			return params;
		};
		const cancel = () => emit("cancel", getEventParams());
		const renderColumnItems = () => currentColumns.value.map((options, columnIndex) => createVNode(stdin_default$103, {
			"value": selectedValues.value[columnIndex],
			"fields": fields.value,
			"options": options,
			"readonly": props$1.readonly,
			"allowHtml": props$1.allowHtml,
			"optionHeight": optionHeight.value,
			"swipeDuration": props$1.swipeDuration,
			"visibleOptionNum": props$1.visibleOptionNum,
			"onChange": (value) => onChange(value, columnIndex),
			"onClickOption": (option) => onClickOption(option, columnIndex),
			"onScrollInto": (option) => {
				emit("scrollInto", {
					currentOption: 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 [createVNode("div", {
					"class": bem$85("mask"),
					"style": maskStyle
				}, null), createVNode("div", {
					"class": [BORDER_UNSET_TOP_BOTTOM, bem$85("frame")],
					"style": frameStyle
				}, null)];
			}
		};
		const renderColumns = () => {
			const wrapHeight = optionHeight.value * +props$1.visibleOptionNum;
			const columnsStyle = { height: `${wrapHeight}px` };
			if (!props$1.loading && !hasOptions.value && slots.empty) return slots.empty();
			return createVNode("div", {
				"ref": columnsRef,
				"class": bem$85("columns"),
				"style": columnsStyle
			}, [renderColumnItems(), renderMask(wrapHeight)]);
		};
		const renderToolbar = () => {
			if (props$1.showToolbar && !parent) return createVNode(stdin_default$104, mergeProps(pick(props$1, pickerToolbarPropKeys), {
				"onConfirm": confirm,
				"onCancel": cancel
			}), pick(slots, pickerToolbarSlots));
		};
		const resetSelectedValues = (columns) => {
			columns.forEach((options, index) => {
				if (options.length && !isOptionExist(options, selectedValues.value[index], fields.value)) setValue(index, getFirstEnabledOption(options)[fields.value.value]);
			});
		};
		watch(currentColumns, (columns) => resetSelectedValues(columns), { immediate: true });
		let lastEmittedModelValue;
		watch(() => props$1.modelValue, (newValues) => {
			if (!isSameValue(newValues, selectedValues.value) && !isSameValue(newValues, lastEmittedModelValue)) {
				selectedValues.value = newValues.slice(0);
				lastEmittedModelValue = newValues.slice(0);
			}
			if (props$1.modelValue.length === 0) resetSelectedValues(currentColumns.value);
		}, { deep: true });
		watch(selectedValues, (newValues) => {
			if (!isSameValue(newValues, props$1.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 createVNode("div", { "class": bem$85() }, [
				props$1.toolbarPosition === "top" ? renderToolbar() : null,
				props$1.loading ? createVNode(Loading, { "class": bem$85("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$1.toolbarPosition === "bottom" ? renderToolbar() : null
			]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/area/utils.mjs
var AREA_EMPTY_CODE = "000000";
var INHERIT_SLOTS = [
	"title",
	"cancel",
	"confirm",
	"toolbar",
	"columns-top",
	"columns-bottom"
];
var INHERIT_PROPS = [
	"title",
	"loading",
	"readonly",
	"optionHeight",
	"swipeDuration",
	"visibleOptionNum",
	"cancelButtonText",
	"confirmButtonText"
];
var 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 > 1 ? [makeOption(placeholder[1], 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 > 2 ? [makeOption(placeholder[2])] : [];
		};
		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;
}

//#endregion
//#region node_modules/vant/es/picker/index.mjs
var Picker = withInstall(stdin_default$102);

//#endregion
//#region node_modules/vant/es/area/Area.mjs
var [name$88, bem$84] = createNamespace("area");
var areaProps = extend({}, pick(pickerSharedProps, INHERIT_PROPS), {
	modelValue: String,
	columnsNum: makeNumericProp(3),
	columnsPlaceholder: makeArrayProp(),
	areaList: {
		type: Object,
		default: () => ({})
	}
});
var stdin_default$101 = defineComponent({
	name: name$88,
	props: areaProps,
	emits: [
		"change",
		"confirm",
		"cancel",
		"update:modelValue"
	],
	setup(props$1, { emit, slots }) {
		const codes = ref([]);
		const picker = ref();
		const columns = computed(() => formatDataForCascade(props$1));
		const onChange = (...args) => emit("change", ...args);
		const onCancel = (...args) => emit("cancel", ...args);
		const onConfirm = (...args) => emit("confirm", ...args);
		watch(codes, (newCodes) => {
			const lastCode = newCodes.length ? newCodes[newCodes.length - 1] : "";
			if (lastCode && lastCode !== props$1.modelValue) emit("update:modelValue", lastCode);
		}, { deep: true });
		watch(() => props$1.modelValue, (newCode) => {
			if (newCode) {
				if (newCode !== (codes.value.length ? codes.value[codes.value.length - 1] : "")) codes.value = [
					`${newCode.slice(0, 2)}0000`,
					`${newCode.slice(0, 4)}00`,
					newCode
				].slice(0, +props$1.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 () => createVNode(Picker, mergeProps({
			"ref": picker,
			"modelValue": codes.value,
			"onUpdate:modelValue": ($event) => codes.value = $event,
			"class": bem$84(),
			"columns": columns.value,
			"onChange": onChange,
			"onCancel": onCancel,
			"onConfirm": onConfirm
		}, pick(props$1, INHERIT_PROPS)), pick(slots, INHERIT_SLOTS));
	}
});

//#endregion
//#region node_modules/vant/es/area/index.mjs
var Area = withInstall(stdin_default$101);

//#endregion
//#region node_modules/vant/es/cell/Cell.mjs
var [name$87, bem$83] = createNamespace("cell");
var cellSharedProps = {
	tag: makeStringProp("div"),
	icon: String,
	size: String,
	title: numericProp,
	value: numericProp,
	label: numericProp,
	center: Boolean,
	isLink: Boolean,
	border: truthProp,
	iconPrefix: String,
	valueClass: unknownProp,
	labelClass: unknownProp,
	titleClass: unknownProp,
	titleStyle: null,
	arrowDirection: String,
	required: {
		type: [Boolean, String],
		default: null
	},
	clickable: {
		type: Boolean,
		default: null
	}
};
var cellProps = extend({}, cellSharedProps, routeProps);
var stdin_default$100 = defineComponent({
	name: name$87,
	props: cellProps,
	setup(props$1, { slots }) {
		const route$1 = useRoute();
		const renderLabel = () => {
			if (slots.label || isDef(props$1.label)) return createVNode("div", { "class": [bem$83("label"), props$1.labelClass] }, [slots.label ? slots.label() : props$1.label]);
		};
		const renderTitle = () => {
			var _a;
			if (slots.title || isDef(props$1.title)) {
				const titleSlot = (_a = slots.title) == null ? void 0 : _a.call(slots);
				if (Array.isArray(titleSlot) && titleSlot.length === 0) return;
				return createVNode("div", {
					"class": [bem$83("title"), props$1.titleClass],
					"style": props$1.titleStyle
				}, [titleSlot || createVNode("span", null, [props$1.title]), renderLabel()]);
			}
		};
		const renderValue = () => {
			const slot = slots.value || slots.default;
			if (slot || isDef(props$1.value)) return createVNode("div", { "class": [bem$83("value"), props$1.valueClass] }, [slot ? slot() : createVNode("span", null, [props$1.value])]);
		};
		const renderLeftIcon = () => {
			if (slots.icon) return slots.icon();
			if (props$1.icon) return createVNode(Icon, {
				"name": props$1.icon,
				"class": bem$83("left-icon"),
				"classPrefix": props$1.iconPrefix
			}, null);
		};
		const renderRightIcon = () => {
			if (slots["right-icon"]) return slots["right-icon"]();
			if (props$1.isLink) {
				const name2 = props$1.arrowDirection && props$1.arrowDirection !== "right" ? `arrow-${props$1.arrowDirection}` : "arrow";
				return createVNode(Icon, {
					"name": name2,
					"class": bem$83("right-icon")
				}, null);
			}
		};
		return () => {
			var _a;
			const { tag, size, center, border, isLink, required } = props$1;
			const clickable = (_a = props$1.clickable) != null ? _a : isLink;
			const classes = {
				center,
				required: !!required,
				clickable,
				borderless: !border
			};
			if (size) classes[size] = !!size;
			return createVNode(tag, {
				"class": bem$83(classes),
				"role": clickable ? "button" : void 0,
				"tabindex": clickable ? 0 : void 0,
				"onClick": route$1
			}, { default: () => {
				var _a2;
				return [
					renderLeftIcon(),
					renderTitle(),
					renderValue(),
					renderRightIcon(),
					(_a2 = slots.extra) == null ? void 0 : _a2.call(slots)
				];
			} });
		};
	}
});

//#endregion
//#region node_modules/vant/es/cell/index.mjs
var Cell = withInstall(stdin_default$100);

//#endregion
//#region node_modules/vant/es/form/Form.mjs
var [name$86, bem$82] = createNamespace("form");
var formProps = {
	colon: Boolean,
	disabled: Boolean,
	readonly: Boolean,
	required: [Boolean, String],
	showError: Boolean,
	labelWidth: numericProp,
	labelAlign: String,
	inputAlign: String,
	scrollToError: Boolean,
	scrollToErrorPosition: String,
	validateFirst: Boolean,
	submitOnEnter: truthProp,
	showErrorMessage: truthProp,
	errorMessageAlign: String,
	validateTrigger: {
		type: [String, Array],
		default: "onBlur"
	}
};
var stdin_default$99 = defineComponent({
	name: name$86,
	props: formProps,
	emits: ["submit", "failed"],
	setup(props$1, { 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 = [];
			getFieldsByNames(names).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$1.validateFirst ? validateSeq(name2) : validateAll(name2);
		};
		const resetValidation = (name2) => {
			if (typeof name2 === "string") name2 = [name2];
			getFieldsByNames(name2).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
				});
				const { scrollToError, scrollToErrorPosition } = props$1;
				if (scrollToError && errors[0].name) scrollToField(errors[0].name, scrollToErrorPosition ? { block: scrollToErrorPosition } : void 0);
			});
		};
		const onSubmit = (event) => {
			preventDefault(event);
			submit();
		};
		linkChildren({ props: props$1 });
		useExpose({
			submit,
			validate,
			getValues,
			scrollToField,
			resetValidation,
			getValidationStatus
		});
		return () => {
			var _a;
			return createVNode("form", {
				"class": bem$82(),
				"onSubmit": onSubmit
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/form/index.mjs
var Form = withInstall(stdin_default$99);

//#endregion
//#region node_modules/vant/es/field/utils.mjs
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 height$1 = input.scrollHeight;
	if (isObject(autosize)) {
		const { maxHeight, minHeight } = autosize;
		if (maxHeight !== void 0) height$1 = Math.min(height$1, maxHeight);
		if (minHeight !== void 0) height$1 = Math.max(height$1, minHeight);
	}
	if (height$1) {
		input.style.height = `${height$1}px`;
		setRootScrollTop(scrollTop);
	}
}
function mapInputType(type, inputmode) {
	if (type === "number") {
		type = "text";
		inputmode ??= "decimal";
	}
	if (type === "digit") {
		type = "tel";
		inputmode ??= "numeric";
	}
	return {
		type,
		inputmode
	};
}
function getStringLength(str) {
	return [...str].length;
}
function cutString(str, maxlength) {
	return [...str].slice(0, maxlength).join("");
}

//#endregion
//#region node_modules/vant/es/field/Field.mjs
var [name$85, bem$81] = createNamespace("field");
var fieldSharedProps = {
	id: String,
	name: String,
	leftIcon: String,
	rightIcon: String,
	autofocus: Boolean,
	clearable: Boolean,
	maxlength: numericProp,
	max: Number,
	min: Number,
	formatter: Function,
	clearIcon: makeStringProp("clear"),
	modelValue: makeNumericProp(""),
	inputAlign: String,
	placeholder: String,
	autocomplete: String,
	autocapitalize: String,
	autocorrect: String,
	errorMessage: String,
	enterkeyhint: String,
	clearTrigger: makeStringProp("focus"),
	formatTrigger: makeStringProp("onChange"),
	spellcheck: {
		type: Boolean,
		default: null
	},
	error: {
		type: Boolean,
		default: null
	},
	disabled: {
		type: Boolean,
		default: null
	},
	readonly: {
		type: Boolean,
		default: null
	},
	inputmode: String
};
var 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$98 = defineComponent({
	name: name$85,
	props: fieldProps,
	emits: [
		"blur",
		"focus",
		"clear",
		"keypress",
		"clickInput",
		"endValidate",
		"startValidate",
		"clickLeftIcon",
		"clickRightIcon",
		"update:modelValue"
	],
	setup(props$1, { emit, slots }) {
		const id = useId();
		const state = reactive({
			status: "unvalidated",
			focused: false,
			validateMessage: ""
		});
		const inputRef = ref();
		const clearIconRef = ref();
		const customValue = ref();
		const { parent: form } = useParent(FORM_KEY);
		const getModelValue = () => {
			var _a;
			return String((_a = props$1.modelValue) != null ? _a : "");
		};
		const getProp = (key) => {
			if (isDef(props$1[key])) return props$1[key];
			if (form && isDef(form.props[key])) return form.props[key];
		};
		const showClear = computed(() => {
			const readonly = getProp("readonly");
			if (props$1.clearable && !readonly) {
				const hasValue = getModelValue() !== "";
				const trigger = props$1.clearTrigger === "always" || props$1.clearTrigger === "focus" && state.focused;
				return hasValue && trigger;
			}
			return false;
		});
		const formValue = computed(() => {
			if (customValue.value && slots.input) return customValue.value();
			return props$1.modelValue;
		});
		const showRequiredMark = computed(() => {
			var _a;
			const required = getProp("required");
			if (required === "auto") return (_a = props$1.rules) == null ? void 0 : _a.some((rule) => rule.required);
			return required;
		});
		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$1.rules) => new Promise((resolve) => {
			resetValidation();
			if (rules) {
				emit("startValidate");
				runRules(rules).then(() => {
					if (state.status === "failed") {
						resolve({
							name: props$1.name,
							message: state.validateMessage
						});
						endValidate();
					} else {
						state.status = "passed";
						resolve();
						endValidate();
					}
				});
			} else resolve();
		});
		const validateWithTrigger = (trigger) => {
			if (form && props$1.rules) {
				const { validateTrigger } = form.props;
				const defaultTrigger = toArray(validateTrigger).includes(trigger);
				const rules = props$1.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$1;
			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") => {
			var _a, _b;
			const originalValue = value;
			value = limitValueLength(value);
			const limitDiffLen = getStringLength(originalValue) - getStringLength(value);
			if (props$1.type === "number" || props$1.type === "digit") {
				const isNumber = props$1.type === "number";
				value = formatNumber(value, isNumber, isNumber);
				if (trigger === "onBlur" && value !== "" && (props$1.min !== void 0 || props$1.max !== void 0)) {
					const adjustedValue = clamp(+value, (_a = props$1.min) != null ? _a : -Infinity, (_b = props$1.max) != null ? _b : Infinity);
					if (+value !== adjustedValue) value = adjustedValue.toString();
				}
			}
			let formatterDiffLen = 0;
			if (props$1.formatter && trigger === props$1.formatTrigger) {
				const { formatter, maxlength } = props$1;
				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$1.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$1.type === "textarea" && props$1.autosize && input) resizeTextarea(input, props$1.autosize);
		};
		const onFocus = (event) => {
			state.focused = true;
			emit("focus", event);
			nextTick(adjustTextareaSize);
			if (getProp("readonly")) blur();
		};
		const onBlur = (event) => {
			state.focused = false;
			updateValue(getModelValue(), "onBlur");
			emit("blur", event);
			if (getProp("readonly")) return;
			validateWithTrigger("onBlur");
			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 = computed(() => {
			if (typeof props$1.error === "boolean") return props$1.error;
			if (form && form.props.showError && state.status === "failed") return true;
		});
		const labelStyle = computed(() => {
			const labelWidth = getProp("labelWidth");
			const labelAlign = getProp("labelAlign");
			if (labelWidth && labelAlign !== "top") return { width: addUnit(labelWidth) };
		});
		const onKeypress = (event) => {
			if (event.keyCode === 13) {
				if (!(form && form.props.submitOnEnter) && props$1.type !== "textarea") preventDefault(event);
				if (props$1.type === "search") blur();
			}
			emit("keypress", event);
		};
		const getInputId = () => props$1.id || `${id}-input`;
		const getValidationStatus = () => state.status;
		const renderInput = () => {
			const controlClass = bem$81("control", [getProp("inputAlign"), {
				error: showError.value,
				custom: !!slots.input,
				"min-height": props$1.type === "textarea" && !props$1.autosize
			}]);
			if (slots.input) return createVNode("div", {
				"class": controlClass,
				"onClick": onClickInput
			}, [slots.input()]);
			const inputAttrs = {
				id: getInputId(),
				ref: inputRef,
				name: props$1.name,
				rows: props$1.rows !== void 0 ? +props$1.rows : void 0,
				class: controlClass,
				disabled: getProp("disabled"),
				readonly: getProp("readonly"),
				autofocus: props$1.autofocus,
				placeholder: props$1.placeholder,
				autocomplete: props$1.autocomplete,
				autocapitalize: props$1.autocapitalize,
				autocorrect: props$1.autocorrect,
				enterkeyhint: props$1.enterkeyhint,
				spellcheck: props$1.spellcheck,
				"aria-labelledby": props$1.label ? `${id}-label` : void 0,
				"data-allow-mismatch": "attribute",
				onBlur,
				onFocus,
				onInput,
				onClick: onClickInput,
				onChange: endComposing,
				onKeypress,
				onCompositionend: endComposing,
				onCompositionstart: startComposing
			};
			if (props$1.type === "textarea") return createVNode("textarea", mergeProps(inputAttrs, { "inputmode": props$1.inputmode }), null);
			return createVNode("input", mergeProps(mapInputType(props$1.type, props$1.inputmode), inputAttrs), null);
		};
		const renderLeftIcon = () => {
			const leftIconSlot = slots["left-icon"];
			if (props$1.leftIcon || leftIconSlot) return createVNode("div", {
				"class": bem$81("left-icon"),
				"onClick": onClickLeftIcon
			}, [leftIconSlot ? leftIconSlot() : createVNode(Icon, {
				"name": props$1.leftIcon,
				"classPrefix": props$1.iconPrefix
			}, null)]);
		};
		const renderRightIcon = () => {
			const rightIconSlot = slots["right-icon"];
			if (props$1.rightIcon || rightIconSlot) return createVNode("div", {
				"class": bem$81("right-icon"),
				"onClick": onClickRightIcon
			}, [rightIconSlot ? rightIconSlot() : createVNode(Icon, {
				"name": props$1.rightIcon,
				"classPrefix": props$1.iconPrefix
			}, null)]);
		};
		const renderWordLimit = () => {
			if (props$1.showWordLimit && props$1.maxlength) {
				const count = getStringLength(getModelValue());
				return createVNode("div", { "class": bem$81("word-limit") }, [
					createVNode("span", { "class": bem$81("word-num") }, [count]),
					createTextVNode("/"),
					props$1.maxlength
				]);
			}
		};
		const renderMessage = () => {
			if (form && form.props.showErrorMessage === false) return;
			const message = props$1.errorMessage || state.validateMessage;
			if (message) {
				const slot = slots["error-message"];
				const errorMessageAlign = getProp("errorMessageAlign");
				return createVNode("div", { "class": bem$81("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$1.label) return createVNode("label", {
				"id": `${id}-label`,
				"for": slots.input ? void 0 : getInputId(),
				"data-allow-mismatch": "attribute",
				"onClick": (event) => {
					preventDefault(event);
					focus();
				},
				"style": labelAlign === "top" && labelWidth ? { width: addUnit(labelWidth) } : void 0
			}, [props$1.label + colon]);
		};
		const renderFieldBody = () => [
			createVNode("div", { "class": bem$81("body") }, [
				renderInput(),
				showClear.value && createVNode(Icon, {
					"ref": clearIconRef,
					"name": props$1.clearIcon,
					"class": bem$81("clear")
				}, null),
				renderRightIcon(),
				slots.button && createVNode("div", { "class": bem$81("button") }, [slots.button()])
			]),
			renderWordLimit(),
			renderMessage()
		];
		useExpose({
			blur,
			focus,
			validate,
			formValue,
			resetValidation,
			getValidationStatus
		});
		provide(CUSTOM_FIELD_INJECTION_KEY, {
			customValue,
			resetValidation,
			validateWithTrigger
		});
		watch(() => props$1.modelValue, () => {
			updateValue(getModelValue());
			resetValidation();
			validateWithTrigger("onChange");
			nextTick(adjustTextareaSize);
		});
		onMounted(() => {
			updateValue(getModelValue(), props$1.formatTrigger);
			nextTick(adjustTextareaSize);
		});
		useEventListener("touchstart", onClear, { target: 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 createVNode(Cell, {
				"size": props$1.size,
				"class": bem$81({
					error: showError.value,
					disabled,
					[`label-${labelAlign}`]: labelAlign
				}),
				"center": props$1.center,
				"border": props$1.border,
				"isLink": props$1.isLink,
				"clickable": props$1.clickable,
				"titleStyle": labelStyle.value,
				"valueClass": bem$81("value"),
				"titleClass": [bem$81("label", [labelAlign, { required: showRequiredMark.value }]), props$1.labelClass],
				"arrowDirection": props$1.arrowDirection
			}, {
				icon: LeftIcon && labelAlign !== "top" ? () => LeftIcon : null,
				title: renderTitle,
				value: renderFieldBody,
				extra: slots.extra
			});
		};
	}
});

//#endregion
//#region node_modules/vant/es/field/index.mjs
var Field = withInstall(stdin_default$98);

//#endregion
//#region node_modules/vant/es/toast/lock-click.mjs
var 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");
	}
}

//#endregion
//#region node_modules/vant/es/toast/Toast.mjs
var [name$84, bem$80] = createNamespace("toast");
var popupInheritProps$1 = [
	"show",
	"overlay",
	"teleport",
	"transition",
	"overlayClass",
	"overlayStyle",
	"closeOnClickOverlay",
	"zIndex"
];
var 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,
	zIndex: numericProp
};
var stdin_default$97 = defineComponent({
	name: name$84,
	props: toastProps,
	emits: ["update:show"],
	setup(props$1, { emit, slots }) {
		let timer$1;
		let clickable = false;
		const toggleClickable = () => {
			const newValue = props$1.show && props$1.forbidClick;
			if (clickable !== newValue) {
				clickable = newValue;
				lockClick(clickable);
			}
		};
		const updateShow = (show) => emit("update:show", show);
		const onClick = () => {
			if (props$1.closeOnClick) updateShow(false);
		};
		const clearTimer = () => clearTimeout(timer$1);
		const renderIcon = () => {
			const { icon, type, iconSize, iconPrefix, loadingType } = props$1;
			if (icon || type === "success" || type === "fail") return createVNode(Icon, {
				"name": icon || type,
				"size": iconSize,
				"class": bem$80("icon"),
				"classPrefix": iconPrefix
			}, null);
			if (type === "loading") return createVNode(Loading, {
				"class": bem$80("loading"),
				"size": iconSize,
				"type": loadingType
			}, null);
		};
		const renderMessage = () => {
			const { type, message } = props$1;
			if (slots.message) return createVNode("div", { "class": bem$80("text") }, [slots.message()]);
			if (isDef(message) && message !== "") return type === "html" ? createVNode("div", {
				"key": 0,
				"class": bem$80("text"),
				"innerHTML": String(message)
			}, null) : createVNode("div", { "class": bem$80("text") }, [message]);
		};
		watch(() => [props$1.show, props$1.forbidClick], toggleClickable);
		watch(() => [
			props$1.show,
			props$1.type,
			props$1.message,
			props$1.duration
		], () => {
			clearTimer();
			if (props$1.show && props$1.duration > 0) timer$1 = setTimeout(() => {
				updateShow(false);
			}, props$1.duration);
		});
		onMounted(toggleClickable);
		onUnmounted(toggleClickable);
		return () => createVNode(Popup, mergeProps({
			"class": [bem$80([
				props$1.position,
				props$1.wordBreak === "normal" ? "break-normal" : props$1.wordBreak,
				{ [props$1.type]: !props$1.icon }
			]), props$1.className],
			"lockScroll": false,
			"onClick": onClick,
			"onClosed": clearTimer,
			"onUpdate:show": updateShow
		}, pick(props$1, popupInheritProps$1)), { default: () => [renderIcon(), renderMessage()] });
	}
});

//#endregion
//#region node_modules/vant/es/utils/mount-component.mjs
function usePopupState() {
	const state = reactive({ show: false });
	const toggle = (show) => {
		state.show = show;
	};
	const open = (props$1) => {
		extend(state, props$1, { transitionAppear: true });
		toggle(true);
	};
	const close = () => toggle(false);
	useExpose({
		open,
		close,
		toggle
	});
	return {
		open,
		close,
		state,
		toggle
	};
}
function mountComponent(RootComponent) {
	const app = createApp(RootComponent);
	const root = document.createElement("div");
	document.body.appendChild(root);
	return {
		instance: app.mount(root),
		unmount() {
			app.unmount();
			document.body.removeChild(root);
		}
	};
}

//#endregion
//#region node_modules/vant/es/toast/function-call.mjs
var 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
};
var queue = [];
var allowMultiple = false;
var currentOptions$2 = extend({}, defaultOptions$1);
var defaultOptionsMap = /* @__PURE__ */ new Map();
function parseOptions$1(message) {
	if (isObject(message)) return message;
	return { message };
}
function createInstance() {
	const { instance: instance$3, unmount } = mountComponent({ setup() {
		const message = ref("");
		const { open, state, close, toggle } = usePopupState();
		const onClosed = () => {
			if (allowMultiple) {
				queue = queue.filter((item) => item !== instance$3);
				unmount();
			}
		};
		const render = () => {
			return createVNode(stdin_default$97, mergeProps(state, {
				onClosed,
				"onUpdate:show": toggle
			}), null);
		};
		watch(message, (val) => {
			state.message = val;
		});
		getCurrentInstance().render = render;
		return {
			open,
			close,
			message
		};
	} });
	return instance$3;
}
function getInstance() {
	if (!queue.length || allowMultiple) {
		const instance$3 = createInstance();
		queue.push(instance$3);
	}
	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;
}
var createMethod = (type) => (options) => showToast(extend({ type }, parseOptions$1(options)));
var showLoadingToast = createMethod("loading");
var showSuccessToast = createMethod("success");
var showFailToast = createMethod("fail");
var 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 || _a.close();
};
function setToastDefaultOptions(type, options) {
	if (typeof type === "string") defaultOptionsMap.set(type, options);
	else extend(currentOptions$2, type);
}
var resetToastDefaultOptions = (type) => {
	if (typeof type === "string") defaultOptionsMap.delete(type);
	else {
		currentOptions$2 = extend({}, defaultOptions$1);
		defaultOptionsMap.clear();
	}
};
var allowMultipleToast = (value = true) => {
	allowMultiple = value;
};

//#endregion
//#region node_modules/vant/es/toast/index.mjs
var Toast = withInstall(stdin_default$97);

//#endregion
//#region node_modules/vant/es/switch/Switch.mjs
var [name$83, bem$79] = createNamespace("switch");
var 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$96 = defineComponent({
	name: name$83,
	props: switchProps,
	emits: ["change", "update:modelValue"],
	setup(props$1, { emit, slots }) {
		const isChecked = () => props$1.modelValue === props$1.activeValue;
		const onClick = () => {
			if (!props$1.disabled && !props$1.loading) {
				const newValue = isChecked() ? props$1.inactiveValue : props$1.activeValue;
				emit("update:modelValue", newValue);
				emit("change", newValue);
			}
		};
		const renderLoading = () => {
			if (props$1.loading) {
				const color = isChecked() ? props$1.activeColor : props$1.inactiveColor;
				return createVNode(Loading, {
					"class": bem$79("loading"),
					"color": color
				}, null);
			}
			if (slots.node) return slots.node();
		};
		useCustomFieldValue(() => props$1.modelValue);
		return () => {
			var _a;
			const { size, loading, disabled, activeColor, inactiveColor } = props$1;
			const checked = isChecked();
			const style = {
				fontSize: addUnit(size),
				backgroundColor: checked ? activeColor : inactiveColor
			};
			return createVNode("div", {
				"role": "switch",
				"class": bem$79({
					on: checked,
					loading,
					disabled
				}),
				"style": style,
				"tabindex": disabled ? void 0 : 0,
				"aria-checked": checked,
				"onClick": onClick
			}, [createVNode("div", { "class": bem$79("node") }, [renderLoading()]), (_a = slots.background) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/switch/index.mjs
var Switch = withInstall(stdin_default$96);

//#endregion
//#region node_modules/vant/es/address-edit/AddressEditDetail.mjs
var [name$82, bem$78] = createNamespace("address-edit-detail");
var t$19 = createNamespace("address-edit")[2];
var stdin_default$95 = defineComponent({
	name: name$82,
	props: {
		show: Boolean,
		rows: numericProp,
		value: String,
		rules: Array,
		focused: Boolean,
		maxlength: numericProp,
		searchResult: Array,
		showSearchResult: Boolean
	},
	emits: [
		"blur",
		"focus",
		"input",
		"selectSearch"
	],
	setup(props$1, { emit }) {
		const field = ref();
		const showSearchResult = () => props$1.focused && props$1.searchResult && props$1.showSearchResult;
		const onSelect = (express) => {
			emit("selectSearch", express);
			emit("input", `${express.address || ""} ${express.name || ""}`.trim());
		};
		const renderSearchResult = () => {
			if (!showSearchResult()) return;
			const { searchResult } = props$1;
			return searchResult.map((express) => createVNode(Cell, {
				"clickable": true,
				"key": (express.name || "") + (express.address || ""),
				"icon": "location-o",
				"title": express.name,
				"label": express.address,
				"class": bem$78("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$1.show) return createVNode(Fragment, null, [createVNode(Field, {
				"autosize": true,
				"clearable": true,
				"ref": field,
				"class": bem$78(),
				"rows": props$1.rows,
				"type": "textarea",
				"rules": props$1.rules,
				"label": t$19("addressDetail"),
				"border": !showSearchResult(),
				"maxlength": props$1.maxlength,
				"modelValue": props$1.value,
				"placeholder": t$19("addressDetail"),
				"onBlur": onBlur,
				"onFocus": onFocus,
				"onUpdate:modelValue": onInput
			}, null), renderSearchResult()]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/address-edit/AddressEdit.mjs
var [name$81, bem$77, t$18] = createNamespace("address-edit");
var DEFAULT_DATA = {
	name: "",
	tel: "",
	city: "",
	county: "",
	province: "",
	areaCode: "",
	isDefault: false,
	addressDetail: ""
};
var 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$94 = defineComponent({
	name: name$81,
	props: addressEditProps,
	emits: [
		"save",
		"focus",
		"change",
		"delete",
		"clickArea",
		"changeArea",
		"changeDetail",
		"selectSearch",
		"changeDefault"
	],
	setup(props$1, { emit, slots }) {
		const areaRef = ref();
		const data = reactive({});
		const showAreaPopup = ref(false);
		const detailFocused = ref(false);
		const areaListLoaded = computed(() => isObject(props$1.areaList) && Object.keys(props$1.areaList).length);
		const areaText = 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 = computed(() => {
			var _a;
			return ((_a = props$1.searchResult) == null ? void 0 : _a.length) && detailFocused.value;
		});
		const onFocus = (key) => {
			detailFocused.value = key === "addressDetail";
			emit("focus", key);
		};
		const onChange = (key, value) => {
			emit("change", {
				key,
				value
			});
		};
		const rules = computed(() => {
			const { validator, telValidator } = props$1;
			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$18("nameEmpty"))],
				tel: [makeRule("tel", t$18("telInvalid")), {
					validator: telValidator,
					message: t$18("telInvalid")
				}],
				areaCode: [makeRule("areaCode", t$18("areaEmpty"))],
				addressDetail: [makeRule("addressDetail", t$18("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$18("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$1.showSetDefault) {
				const slots2 = { "right-icon": () => createVNode(Switch, {
					"modelValue": data.isDefault,
					"onUpdate:modelValue": ($event) => data.isDefault = $event,
					"onChange": (event) => emit("changeDefault", event)
				}, null) };
				return withDirectives(createVNode(Cell, {
					"center": true,
					"border": false,
					"title": t$18("defaultAddress"),
					"class": bem$77("default")
				}, slots2), [[vShow, !hideBottomFields.value]]);
			}
		};
		useExpose({
			setAreaCode,
			setAddressDetail
		});
		watch(() => props$1.addressInfo, (value) => {
			extend(data, DEFAULT_DATA, value);
			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$1;
			return createVNode(Form, {
				"class": bem$77(),
				"onSubmit": onSave
			}, { default: () => {
				var _a;
				return [
					createVNode("div", { "class": bem$77("fields") }, [
						createVNode(Field, {
							"modelValue": data.name,
							"onUpdate:modelValue": [($event) => data.name = $event, (val) => onChange("name", val)],
							"clearable": true,
							"label": t$18("name"),
							"rules": rules.value.name,
							"placeholder": t$18("name"),
							"onFocus": () => onFocus("name")
						}, null),
						createVNode(Field, {
							"modelValue": data.tel,
							"onUpdate:modelValue": [($event) => data.tel = $event, (val) => onChange("tel", val)],
							"clearable": true,
							"type": "tel",
							"label": t$18("tel"),
							"rules": rules.value.tel,
							"maxlength": props$1.telMaxlength,
							"placeholder": t$18("tel"),
							"onFocus": () => onFocus("tel")
						}, null),
						withDirectives(createVNode(Field, {
							"readonly": true,
							"label": t$18("area"),
							"is-link": !disableArea,
							"modelValue": areaText.value,
							"rules": props$1.showArea ? rules.value.areaCode : void 0,
							"placeholder": props$1.areaPlaceholder || t$18("area"),
							"onFocus": () => onFocus("areaCode"),
							"onClick": () => {
								emit("clickArea");
								showAreaPopup.value = !disableArea;
							}
						}, null), [[vShow, props$1.showArea]]),
						createVNode(stdin_default$95, {
							"show": props$1.showDetail,
							"rows": props$1.detailRows,
							"rules": rules.value.addressDetail,
							"value": data.addressDetail,
							"focused": detailFocused.value,
							"maxlength": props$1.detailMaxlength,
							"searchResult": props$1.searchResult,
							"showSearchResult": props$1.showSearchResult,
							"onBlur": onDetailBlur,
							"onFocus": () => onFocus("addressDetail"),
							"onInput": onChangeDetail,
							"onSelectSearch": (event) => emit("selectSearch", event)
						}, null),
						(_a = slots.default) == null ? void 0 : _a.call(slots)
					]),
					renderSetDefaultCell(),
					withDirectives(createVNode("div", { "class": bem$77("buttons") }, [createVNode(Button, {
						"block": true,
						"round": true,
						"type": "primary",
						"text": props$1.saveButtonText || t$18("save"),
						"class": bem$77("button"),
						"loading": props$1.isSaving,
						"nativeType": "submit"
					}, null), props$1.showDelete && createVNode(Button, {
						"block": true,
						"round": true,
						"class": bem$77("button"),
						"loading": props$1.isDeleting,
						"text": props$1.deleteButtonText || t$18("delete"),
						"onClick": onDelete
					}, null)]), [[vShow, !hideBottomFields.value]]),
					createVNode(Popup, {
						"show": showAreaPopup.value,
						"onUpdate:show": ($event) => showAreaPopup.value = $event,
						"round": true,
						"teleport": "body",
						"position": "bottom",
						"lazyRender": false
					}, { default: () => [createVNode(Area, {
						"modelValue": data.areaCode,
						"onUpdate:modelValue": ($event) => data.areaCode = $event,
						"ref": areaRef,
						"loading": !areaListLoaded.value,
						"areaList": props$1.areaList,
						"columnsPlaceholder": props$1.areaColumnsPlaceholder,
						"onConfirm": onAreaConfirm,
						"onCancel": () => {
							showAreaPopup.value = false;
						}
					}, null)] })
				];
			} });
		};
	}
});

//#endregion
//#region node_modules/vant/es/address-edit/index.mjs
var AddressEdit = withInstall(stdin_default$94);

//#endregion
//#region node_modules/vant/es/radio-group/RadioGroup.mjs
var [name$80, bem$76] = createNamespace("radio-group");
var radioGroupProps = {
	shape: String,
	disabled: Boolean,
	iconSize: numericProp,
	direction: String,
	modelValue: unknownProp,
	checkedColor: String
};
var RADIO_KEY = Symbol(name$80);
var stdin_default$93 = defineComponent({
	name: name$80,
	props: radioGroupProps,
	emits: ["change", "update:modelValue"],
	setup(props$1, { emit, slots }) {
		const { linkChildren } = useChildren(RADIO_KEY);
		const updateValue = (value) => emit("update:modelValue", value);
		watch(() => props$1.modelValue, (value) => emit("change", value));
		linkChildren({
			props: props$1,
			updateValue
		});
		useCustomFieldValue(() => props$1.modelValue);
		return () => {
			var _a;
			return createVNode("div", {
				"class": bem$76([props$1.direction]),
				"role": "radiogroup"
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/radio-group/index.mjs
var RadioGroup = withInstall(stdin_default$93);

//#endregion
//#region node_modules/vant/es/checkbox-group/CheckboxGroup.mjs
var [name$79, bem$75] = createNamespace("checkbox-group");
var checkboxGroupProps = {
	max: numericProp,
	shape: makeStringProp("round"),
	disabled: Boolean,
	iconSize: numericProp,
	direction: String,
	modelValue: makeArrayProp(),
	checkedColor: String
};
var CHECKBOX_GROUP_KEY = Symbol(name$79);
var stdin_default$92 = defineComponent({
	name: name$79,
	props: checkboxGroupProps,
	emits: ["change", "update:modelValue"],
	setup(props$1, { 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;
			updateValue(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;
			}).map((item) => item.name));
		};
		watch(() => props$1.modelValue, (value) => emit("change", value));
		useExpose({ toggleAll });
		useCustomFieldValue(() => props$1.modelValue);
		linkChildren({
			props: props$1,
			updateValue
		});
		return () => {
			var _a;
			return createVNode("div", { "class": bem$75([props$1.direction]) }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/checkbox-group/index.mjs
var CheckboxGroup = withInstall(stdin_default$92);

//#endregion
//#region node_modules/vant/es/tag/Tag.mjs
var [name$78, bem$74] = createNamespace("tag");
var tagProps = {
	size: String,
	mark: Boolean,
	show: truthProp,
	type: makeStringProp("default"),
	color: String,
	plain: Boolean,
	round: Boolean,
	textColor: String,
	closeable: Boolean
};
var stdin_default$91 = defineComponent({
	name: name$78,
	props: tagProps,
	emits: ["close"],
	setup(props$1, { slots, emit }) {
		const onClose = (event) => {
			event.stopPropagation();
			emit("close", event);
		};
		const getStyle = () => {
			if (props$1.plain) return {
				color: props$1.textColor || props$1.color,
				borderColor: props$1.color
			};
			return {
				color: props$1.textColor,
				background: props$1.color
			};
		};
		const renderTag = () => {
			var _a;
			const { type, mark, plain, round: round$1, size, closeable } = props$1;
			const classes = {
				mark,
				plain,
				round: round$1
			};
			if (size) classes[size] = size;
			const CloseIcon = closeable && createVNode(Icon, {
				"name": "cross",
				"class": [bem$74("close"), HAPTICS_FEEDBACK],
				"onClick": onClose
			}, null);
			return createVNode("span", {
				"style": getStyle(),
				"class": bem$74([classes, type])
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots), CloseIcon]);
		};
		return () => createVNode(Transition, { "name": props$1.closeable ? "van-fade" : void 0 }, { default: () => [props$1.show ? renderTag() : null] });
	}
});

//#endregion
//#region node_modules/vant/es/tag/index.mjs
var Tag = withInstall(stdin_default$91);

//#endregion
//#region node_modules/vant/es/checkbox/Checker.mjs
var checkerProps = {
	name: unknownProp,
	disabled: Boolean,
	iconSize: numericProp,
	modelValue: unknownProp,
	checkedColor: String,
	labelPosition: String,
	labelDisabled: Boolean
};
var stdin_default$89 = defineComponent({
	props: extend({}, checkerProps, {
		bem: makeRequiredProp(Function),
		role: String,
		shape: String,
		parent: Object,
		checked: Boolean,
		bindGroup: truthProp,
		indeterminate: {
			type: Boolean,
			default: null
		}
	}),
	emits: ["click", "toggle"],
	setup(props$1, { emit, slots }) {
		const iconRef = ref();
		const getParentProp = (name$111) => {
			if (props$1.parent && props$1.bindGroup) return props$1.parent.props[name$111];
		};
		const disabled = computed(() => {
			if (props$1.parent && props$1.bindGroup) {
				const disabled2 = getParentProp("disabled") || props$1.disabled;
				if (props$1.role === "checkbox") {
					const checkedCount = getParentProp("modelValue").length;
					const max = getParentProp("max");
					const overlimit = max && checkedCount >= +max;
					return disabled2 || overlimit && !props$1.checked;
				}
				return disabled2;
			}
			return props$1.disabled;
		});
		const direction = computed(() => getParentProp("direction"));
		const iconStyle = computed(() => {
			const checkedColor = props$1.checkedColor || getParentProp("checkedColor");
			if (checkedColor && (props$1.checked || props$1.indeterminate) && !disabled.value) return {
				borderColor: checkedColor,
				backgroundColor: checkedColor
			};
		});
		const shape = computed(() => {
			return props$1.shape || getParentProp("shape") || "round";
		});
		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$1.labelDisabled)) emit("toggle");
			emit("click", event);
		};
		const renderIcon = () => {
			var _a, _b;
			const { bem: bem$106, checked, indeterminate } = props$1;
			const iconSize = props$1.iconSize || getParentProp("iconSize");
			return createVNode("div", {
				"ref": iconRef,
				"class": bem$106("icon", [shape.value, {
					disabled: disabled.value,
					checked,
					indeterminate
				}]),
				"style": shape.value !== "dot" ? { fontSize: addUnit(iconSize) } : {
					width: addUnit(iconSize),
					height: addUnit(iconSize),
					borderColor: (_a = iconStyle.value) == null ? void 0 : _a.borderColor
				}
			}, [slots.icon ? slots.icon({
				checked,
				disabled: disabled.value
			}) : shape.value !== "dot" ? createVNode(Icon, {
				"name": indeterminate ? "minus" : "success",
				"style": iconStyle.value
			}, null) : createVNode("div", {
				"class": bem$106("icon--dot__icon"),
				"style": { backgroundColor: (_b = iconStyle.value) == null ? void 0 : _b.backgroundColor }
			}, null)]);
		};
		const renderLabel = () => {
			const { checked } = props$1;
			if (slots.default) return createVNode("span", { "class": props$1.bem("label", [props$1.labelPosition, { disabled: disabled.value }]) }, [slots.default({
				checked,
				disabled: disabled.value
			})]);
		};
		return () => {
			const nodes = props$1.labelPosition === "left" ? [renderLabel(), renderIcon()] : [renderIcon(), renderLabel()];
			return createVNode("div", {
				"role": props$1.role,
				"class": props$1.bem([{
					disabled: disabled.value,
					"label-disabled": props$1.labelDisabled
				}, direction.value]),
				"tabindex": disabled.value ? void 0 : 0,
				"aria-checked": props$1.checked,
				"onClick": onClick
			}, [nodes]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/radio/Radio.mjs
var radioProps = extend({}, checkerProps, { shape: String });
var [name$77, bem$73] = createNamespace("radio");
var stdin_default$90 = defineComponent({
	name: name$77,
	props: radioProps,
	emits: ["update:modelValue"],
	setup(props$1, { emit, slots }) {
		const { parent } = useParent(RADIO_KEY);
		const checked = () => {
			return (parent ? parent.props.modelValue : props$1.modelValue) === props$1.name;
		};
		const toggle = () => {
			if (parent) parent.updateValue(props$1.name);
			else emit("update:modelValue", props$1.name);
		};
		return () => createVNode(stdin_default$89, mergeProps({
			"bem": bem$73,
			"role": "radio",
			"parent": parent,
			"checked": checked(),
			"onToggle": toggle
		}, props$1), pick(slots, ["default", "icon"]));
	}
});

//#endregion
//#region node_modules/vant/es/radio/index.mjs
var Radio = withInstall(stdin_default$90);

//#endregion
//#region node_modules/vant/es/checkbox/Checkbox.mjs
var [name$76, bem$72] = createNamespace("checkbox");
var checkboxProps = extend({}, checkerProps, {
	shape: String,
	bindGroup: truthProp,
	indeterminate: {
		type: Boolean,
		default: null
	}
});
var stdin_default$88 = defineComponent({
	name: name$76,
	props: checkboxProps,
	emits: ["change", "update:modelValue"],
	setup(props$1, { emit, slots }) {
		const { parent } = useParent(CHECKBOX_GROUP_KEY);
		const setParentValue = (checked2) => {
			const { name: name2 } = props$1;
			const { max, modelValue } = parent.props;
			const value = modelValue.slice();
			if (checked2) {
				if (!(max && value.length >= +max) && !value.includes(name2)) {
					value.push(name2);
					if (props$1.bindGroup) parent.updateValue(value);
				}
			} else {
				const index = value.indexOf(name2);
				if (index !== -1) {
					value.splice(index, 1);
					if (props$1.bindGroup) parent.updateValue(value);
				}
			}
		};
		const checked = computed(() => {
			if (parent && props$1.bindGroup) return parent.props.modelValue.indexOf(props$1.name) !== -1;
			return !!props$1.modelValue;
		});
		const toggle = (newValue = !checked.value) => {
			if (parent && props$1.bindGroup) setParentValue(newValue);
			else emit("update:modelValue", newValue);
			if (props$1.indeterminate !== null) emit("change", newValue);
		};
		watch(() => props$1.modelValue, (value) => {
			if (props$1.indeterminate === null) emit("change", value);
		});
		useExpose({
			toggle,
			props: props$1,
			checked
		});
		useCustomFieldValue(() => props$1.modelValue);
		return () => createVNode(stdin_default$89, mergeProps({
			"bem": bem$72,
			"role": "checkbox",
			"parent": parent,
			"checked": checked.value,
			"onToggle": toggle
		}, props$1), pick(slots, ["default", "icon"]));
	}
});

//#endregion
//#region node_modules/vant/es/checkbox/index.mjs
var Checkbox = withInstall(stdin_default$88);

//#endregion
//#region node_modules/vant/es/address-list/AddressListItem.mjs
var [name$75, bem$71] = createNamespace("address-item");
var stdin_default$87 = defineComponent({
	name: name$75,
	props: {
		address: makeRequiredProp(Object),
		disabled: Boolean,
		switchable: Boolean,
		singleChoice: Boolean,
		defaultTagText: String,
		rightIcon: makeStringProp("edit")
	},
	emits: [
		"edit",
		"click",
		"select"
	],
	setup(props$1, { slots, emit }) {
		const onClick = (event) => {
			if (props$1.switchable) emit("select");
			emit("click", event);
		};
		const renderRightIcon = () => createVNode(Icon, {
			"name": props$1.rightIcon,
			"class": bem$71("edit"),
			"onClick": (event) => {
				event.stopPropagation();
				emit("edit");
				emit("click", event);
			}
		}, null);
		const renderTag = () => {
			if (slots.tag) return slots.tag(props$1.address);
			if (props$1.address.isDefault && props$1.defaultTagText) return createVNode(Tag, {
				"type": "primary",
				"round": true,
				"class": bem$71("tag")
			}, { default: () => [props$1.defaultTagText] });
		};
		const renderContent = () => {
			const { address, disabled, switchable, singleChoice } = props$1;
			const Info = [createVNode("div", { "class": bem$71("name") }, [`${address.name} ${address.tel}`, renderTag()]), createVNode("div", { "class": bem$71("address") }, [address.address])];
			if (switchable && !disabled) if (singleChoice) return createVNode(Radio, {
				"name": address.id,
				"iconSize": 18
			}, { default: () => [Info] });
			else return createVNode(Checkbox, {
				"name": address.id,
				"iconSize": 18
			}, { default: () => [Info] });
			return Info;
		};
		return () => {
			var _a;
			const { disabled } = props$1;
			return createVNode("div", {
				"class": bem$71({ disabled }),
				"onClick": onClick
			}, [createVNode(Cell, {
				"border": false,
				"titleClass": bem$71("title")
			}, {
				title: renderContent,
				"right-icon": renderRightIcon
			}), (_a = slots.bottom) == null ? void 0 : _a.call(slots, extend({}, props$1.address, { disabled }))]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/address-list/AddressList.mjs
var [name$74, bem$70, t$17] = createNamespace("address-list");
var addressListProps = {
	list: makeArrayProp(),
	modelValue: [...numericProp, Array],
	switchable: truthProp,
	disabledText: String,
	disabledList: makeArrayProp(),
	showAddButton: truthProp,
	addButtonText: String,
	defaultTagText: String,
	rightIcon: makeStringProp("edit")
};
var stdin_default$86 = defineComponent({
	name: name$74,
	props: addressListProps,
	emits: [
		"add",
		"edit",
		"select",
		"clickItem",
		"editDisabled",
		"selectDisabled",
		"update:modelValue"
	],
	setup(props$1, { slots, emit }) {
		const singleChoice = computed(() => !Array.isArray(props$1.modelValue));
		const renderItem = (item, index, disabled) => {
			const onEdit = () => emit(disabled ? "editDisabled" : "edit", item, index);
			const onClick = (event) => emit("clickItem", item, index, { event });
			const onSelect = () => {
				emit(disabled ? "selectDisabled" : "select", item, index);
				if (!disabled) if (singleChoice.value) emit("update:modelValue", item.id);
				else {
					const value = props$1.modelValue;
					if (value.includes(item.id)) emit("update:modelValue", value.filter((id) => id !== item.id));
					else emit("update:modelValue", [...value, item.id]);
				}
			};
			return createVNode(stdin_default$87, {
				"key": item.id,
				"address": item,
				"disabled": disabled,
				"switchable": props$1.switchable,
				"singleChoice": singleChoice.value,
				"defaultTagText": props$1.defaultTagText,
				"rightIcon": props$1.rightIcon,
				"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 = () => props$1.showAddButton ? createVNode("div", { "class": [bem$70("bottom"), "van-safe-area-bottom"] }, [createVNode(Button, {
			"round": true,
			"block": true,
			"type": "primary",
			"text": props$1.addButtonText || t$17("add"),
			"class": bem$70("add"),
			"onClick": () => emit("add")
		}, null)]) : void 0;
		return () => {
			var _a, _b;
			const List$1 = renderList(props$1.list);
			const DisabledList = renderList(props$1.disabledList, true);
			const DisabledText = props$1.disabledText && createVNode("div", { "class": bem$70("disabled-text") }, [props$1.disabledText]);
			return createVNode("div", { "class": bem$70() }, [
				(_a = slots.top) == null ? void 0 : _a.call(slots),
				!singleChoice.value && Array.isArray(props$1.modelValue) ? createVNode(CheckboxGroup, { "modelValue": props$1.modelValue }, { default: () => [List$1] }) : createVNode(RadioGroup, { "modelValue": props$1.modelValue }, { default: () => [List$1] }),
				DisabledText,
				DisabledList,
				(_b = slots.default) == null ? void 0 : _b.call(slots),
				renderBottom()
			]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/address-list/index.mjs
var AddressList = withInstall(stdin_default$86);

//#endregion
//#region node_modules/vant/es/lazyload/vue-lazyload/util.mjs
var hasIntersectionObserver = inBrowser && "IntersectionObserver" in window && "IntersectionObserverEntry" in window && "intersectionRatio" in window.IntersectionObserverEntry.prototype;
var 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 containerWidth = el.parentNode.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;
}
var 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);
}
var loadImageAsync = (item, resolve, reject) => {
	const image = new Image();
	if (!item || !item.src) return reject(/* @__PURE__ */ 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);
};
var ImageCache = class {
	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();
	}
};

//#endregion
//#region node_modules/vant/es/back-top/BackTop.mjs
var [name$73, bem$69] = createNamespace("back-top");
var backTopProps = {
	right: numericProp,
	bottom: numericProp,
	zIndex: numericProp,
	target: [String, Object],
	offset: makeNumericProp(200),
	immediate: Boolean,
	teleport: {
		type: [String, Object],
		default: "body"
	}
};
var stdin_default$85 = defineComponent({
	name: name$73,
	inheritAttrs: false,
	props: backTopProps,
	emits: ["click"],
	setup(props$1, { emit, slots, attrs }) {
		let shouldReshow = false;
		const show = ref(false);
		const root = ref();
		const scrollParent = ref();
		const style = computed(() => extend(getZIndexStyle(props$1.zIndex), {
			right: addUnit(props$1.right),
			bottom: addUnit(props$1.bottom)
		}));
		const onClick = (event) => {
			var _a;
			emit("click", event);
			(_a = scrollParent.value) == null || _a.scrollTo({
				top: 0,
				behavior: props$1.immediate ? "auto" : "smooth"
			});
		};
		const scroll = () => {
			show.value = scrollParent.value ? getScrollTop(scrollParent.value) >= +props$1.offset : false;
		};
		const getTarget = () => {
			const { target } = props$1;
			if (typeof target === "string") {
				const el = document.querySelector(target);
				if (el) return el;
				console.error(`[Vant] BackTop: target element "${target}" was not found, the BackTop component will not be rendered.`);
			} else return target;
		};
		const updateTarget = () => {
			if (inBrowser$1) nextTick(() => {
				scrollParent.value = props$1.target ? getTarget() : getScrollParent(root.value);
				scroll();
			});
		};
		useEventListener("scroll", throttle(scroll, 100), { target: scrollParent });
		onMounted(updateTarget);
		onActivated(() => {
			if (shouldReshow) {
				show.value = true;
				shouldReshow = false;
			}
		});
		onDeactivated(() => {
			if (show.value && props$1.teleport) {
				show.value = false;
				shouldReshow = true;
			}
		});
		watch(() => props$1.target, updateTarget);
		return () => {
			const Content = createVNode("div", mergeProps({
				"ref": !props$1.teleport ? root : void 0,
				"class": bem$69({ active: show.value }),
				"style": style.value,
				"onClick": onClick
			}, attrs), [slots.default ? slots.default() : createVNode(Icon, {
				"name": "back-top",
				"class": bem$69("icon")
			}, null)]);
			if (props$1.teleport) return [createVNode("div", {
				"ref": root,
				"class": bem$69("placeholder")
			}, null), createVNode(Teleport, { "to": props$1.teleport }, { default: () => [Content] })];
			return Content;
		};
	}
});

//#endregion
//#region node_modules/vant/es/back-top/index.mjs
var BackTop = withInstall(stdin_default$85);

//#endregion
//#region node_modules/vant/es/barrage/Barrage.mjs
var __async = (__this, __arguments, generator) => {
	return new Promise((resolve, reject) => {
		var fulfilled = (value) => {
			try {
				step(generator.next(value));
			} catch (e) {
				reject(e);
			}
		};
		var rejected = (value) => {
			try {
				step(generator.throw(value));
			} catch (e) {
				reject(e);
			}
		};
		var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
		step((generator = generator.apply(__this, __arguments)).next());
	});
};
var barrageProps = {
	top: makeNumericProp(10),
	rows: makeNumericProp(4),
	duration: makeNumericProp(4e3),
	autoPlay: truthProp,
	delay: makeNumberProp(300),
	modelValue: makeArrayProp()
};
var [name$72, bem$68] = createNamespace("barrage");
var stdin_default$84 = defineComponent({
	name: name$72,
	props: barrageProps,
	emits: ["update:modelValue"],
	setup(props$1, { emit, slots }) {
		const barrageWrapper = ref();
		const className = bem$68("item");
		const total = ref(0);
		const barrageItems = [];
		const createBarrageItem = (text, delay = props$1.delay) => {
			const item = document.createElement("span");
			item.className = className;
			item.innerText = String(text);
			item.style.animationDuration = `${props$1.duration}ms`;
			item.style.animationDelay = `${delay}ms`;
			item.style.animationName = "van-barrage";
			item.style.animationTimingFunction = "linear";
			return item;
		};
		const isInitBarrage = ref(true);
		const isPlay = ref(props$1.autoPlay);
		const appendBarrageItem = ({ id, text }, i) => {
			var _a;
			const item = createBarrageItem(text, isInitBarrage.value ? i * props$1.delay : void 0);
			if (!props$1.autoPlay && isPlay.value === false) item.style.animationPlayState = "paused";
			(_a = barrageWrapper.value) == null || _a.append(item);
			total.value++;
			const top$1 = (total.value - 1) % +props$1.rows * item.offsetHeight + +props$1.top;
			item.style.top = `${top$1}px`;
			item.dataset.id = String(id);
			barrageItems.push(item);
			item.addEventListener("animationend", () => {
				emit("update:modelValue", [...props$1.modelValue].filter((v) => String(v.id) !== item.dataset.id));
			});
		};
		const updateBarrages = (newValue, oldValue) => {
			const map = new Map(oldValue.map((item) => [item.id, item]));
			newValue.forEach((item, i) => {
				if (map.has(item.id)) map.delete(item.id);
				else appendBarrageItem(item, i);
			});
			map.forEach((item) => {
				const index = barrageItems.findIndex((span) => span.dataset.id === String(item.id));
				if (index > -1) {
					barrageItems[index].remove();
					barrageItems.splice(index, 1);
				}
			});
			isInitBarrage.value = false;
		};
		watch(() => props$1.modelValue.slice(), (newValue, oldValue) => updateBarrages(newValue != null ? newValue : [], oldValue != null ? oldValue : []), { deep: true });
		const rootStyle = ref({});
		onMounted(() => __async(null, null, function* () {
			var _a;
			rootStyle.value["--move-distance"] = `-${(_a = barrageWrapper.value) == null ? void 0 : _a.offsetWidth}px`;
			yield nextTick();
			updateBarrages(props$1.modelValue, []);
		}));
		const play = () => {
			isPlay.value = true;
			barrageItems.forEach((item) => {
				item.style.animationPlayState = "running";
			});
		};
		const pause = () => {
			isPlay.value = false;
			barrageItems.forEach((item) => {
				item.style.animationPlayState = "paused";
			});
		};
		useExpose({
			play,
			pause
		});
		return () => {
			var _a;
			return createVNode("div", {
				"class": bem$68(),
				"ref": barrageWrapper,
				"style": rootStyle.value
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/barrage/index.mjs
var Barrage = withInstall(stdin_default$84);

//#endregion
//#region node_modules/vant/es/calendar/utils.mjs
var [name$68, bem$67, t$16] = createNamespace("calendar");
var formatMonthTitle = (date) => t$16("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;
}
var cloneDate = (date) => new Date(date);
var cloneDates = (dates) => Array.isArray(dates) ? dates.map(cloneDate) : cloneDate(dates);
function getDayByOffset(date, offset$1) {
	const cloned = cloneDate(date);
	cloned.setDate(cloned.getDate() + offset$1);
	return cloned;
}
function getMonthByOffset(date, offset$1) {
	const cloned = cloneDate(date);
	cloned.setMonth(cloned.getMonth() + offset$1);
	if (cloned.getDate() !== date.getDate()) cloned.setDate(0);
	return cloned;
}
function getYearByOffset(date, offset$1) {
	const cloned = cloneDate(date);
	cloned.setFullYear(cloned.getFullYear() + offset$1);
	if (cloned.getDate() !== date.getDate()) cloned.setDate(0);
	return cloned;
}
var getPrevDay = (date) => getDayByOffset(date, -1);
var getNextDay = (date) => getDayByOffset(date, 1);
var getPrevMonth = (date) => getMonthByOffset(date, -1);
var getNextMonth = (date) => getMonthByOffset(date, 1);
var getPrevYear = (date) => getYearByOffset(date, -1);
var getNextYear = (date) => getYearByOffset(date, 1);
var getToday = () => {
	const today = /* @__PURE__ */ new Date();
	today.setHours(0, 0, 0, 0);
	return today;
};
function calcDateNum(date) {
	const day1 = date[0].getTime();
	return (date[1].getTime() - day1) / (1e3 * 60 * 60 * 24) + 1;
}
function isLastRowInMonth(date, offset$1 = 0) {
	const lastDay = new Date(date.getFullYear(), date.getMonth() + 1, 0);
	const currentPos = offset$1 + date.getDate() - 1;
	const lastDayPos = offset$1 + lastDay.getDate() - 1;
	return Math.floor(currentPos / 7) === Math.floor(lastDayPos / 7);
}

//#endregion
//#region node_modules/vant/es/date-picker/utils.mjs
var sharedProps = extend({}, pickerSharedProps, {
	modelValue: makeArrayProp(),
	filter: Function,
	formatter: {
		type: Function,
		default: (type, option) => option
	}
});
var 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;
}
var getMonthEndDay = (year, month) => 32 - new Date(year, month - 1, 32).getDate();
var genOptions = (min, max, type, formatter, filter, values) => {
	const options = times(max - min + 1, (index) => {
		const value = padZero(min + index);
		return formatter(type, {
			text: value,
			value
		});
	});
	return filter ? filter(type, options, values) : options;
};
var formatValueRange = (values, columns) => values.map((value, index) => {
	const column = columns[index];
	if (column.length) {
		const minValue = +column[0].value;
		const maxValue = +column[column.length - 1].value;
		return padZero(clamp(+value, minValue, maxValue));
	}
	return value;
});

//#endregion
//#region node_modules/vant/es/calendar/CalendarDay.mjs
var [name$71] = createNamespace("calendar-day");
var stdin_default$83 = defineComponent({
	name: name$71,
	props: {
		item: makeRequiredProp(Object),
		color: String,
		index: Number,
		offset: makeNumberProp(0),
		rowHeight: String
	},
	emits: ["click", "clickDisabledDate"],
	setup(props$1, { emit, slots }) {
		const style = computed(() => {
			const { item, index, color, offset: offset$1, rowHeight } = props$1;
			const style2 = { height: rowHeight };
			if (item.type === "placeholder") {
				style2.width = "100%";
				return style2;
			}
			if (index === 0) style2.marginLeft = `${100 * offset$1 / 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 (item.date && isLastRowInMonth(item.date, offset$1)) style2.marginBottom = 0;
			return style2;
		});
		const onClick = () => {
			if (props$1.item.type !== "disabled") emit("click", props$1.item);
			else emit("clickDisabledDate", props$1.item);
		};
		const renderTopInfo = () => {
			const { topInfo } = props$1.item;
			if (topInfo || slots["top-info"]) return createVNode("div", { "class": bem$67("top-info") }, [slots["top-info"] ? slots["top-info"](props$1.item) : topInfo]);
		};
		const renderBottomInfo = () => {
			const { bottomInfo } = props$1.item;
			if (bottomInfo || slots["bottom-info"]) return createVNode("div", { "class": bem$67("bottom-info") }, [slots["bottom-info"] ? slots["bottom-info"](props$1.item) : bottomInfo]);
		};
		const renderText = () => {
			return slots.text ? slots.text(props$1.item) : props$1.item.text;
		};
		const renderContent = () => {
			const { item, color, rowHeight } = props$1;
			const { type } = item;
			const Nodes = [
				renderTopInfo(),
				renderText(),
				renderBottomInfo()
			];
			if (type === "selected") return createVNode("div", {
				"class": bem$67("selected-day"),
				"style": {
					width: rowHeight,
					height: rowHeight,
					background: color
				}
			}, [Nodes]);
			return Nodes;
		};
		return () => {
			const { type, className } = props$1.item;
			if (type === "placeholder") return createVNode("div", {
				"class": bem$67("day"),
				"style": style.value
			}, null);
			return createVNode("div", {
				"role": "gridcell",
				"style": style.value,
				"class": [bem$67("day", type), className],
				"tabindex": type === "disabled" ? void 0 : -1,
				"onClick": onClick
			}, [renderContent()]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/calendar/CalendarMonth.mjs
var [name$70] = createNamespace("calendar-month");
var stdin_default$81 = defineComponent({
	name: name$70,
	props: {
		date: makeRequiredProp(Date),
		type: String,
		color: String,
		minDate: Date,
		maxDate: Date,
		showMark: Boolean,
		rowHeight: numericProp,
		formatter: Function,
		lazyRender: Boolean,
		currentDate: [Date, Array],
		allowSameDay: Boolean,
		showSubtitle: Boolean,
		showMonthTitle: Boolean,
		firstDayOfWeek: Number
	},
	emits: ["click", "clickDisabledDate"],
	setup(props$1, { emit, slots }) {
		const [visible, setVisible] = useToggle();
		const daysRef = ref();
		const monthRef = ref();
		const height$1 = useHeight(monthRef);
		const title = computed(() => formatMonthTitle(props$1.date));
		const rowHeight = computed(() => addUnit(props$1.rowHeight));
		const offset$1 = computed(() => {
			const date = props$1.date.getDate();
			const realDay = (props$1.date.getDay() - date % 7 + 8) % 7;
			if (props$1.firstDayOfWeek) return (realDay + 7 - props$1.firstDayOfWeek) % 7;
			return realDay;
		});
		const totalDay = computed(() => getMonthEndDay(props$1.date.getFullYear(), props$1.date.getMonth() + 1));
		const shouldRender = computed(() => visible.value || !props$1.lazyRender);
		const getTitle = () => title.value;
		const getMultipleDayType = (day) => {
			const isSelected = (date) => props$1.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$1.currentDate;
			if (!startDay) return "";
			const compareToStart = compareDay(day, startDay);
			if (!endDay) return compareToStart === 0 ? "start" : "";
			const compareToEnd = compareDay(day, endDay);
			if (props$1.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$1;
			if (minDate && compareDay(day, minDate) < 0 || maxDate && 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$1.type === "range") {
				if (dayType === "start" || dayType === "end") return t$16(dayType);
				if (dayType === "start-end") return `${t$16("start")}/${t$16("end")}`;
			}
		};
		const renderTitle = () => {
			if (props$1.showMonthTitle) return createVNode("div", { "class": bem$67("month-title") }, [slots["month-title"] ? slots["month-title"]({
				date: props$1.date,
				text: title.value
			}) : title.value]);
		};
		const renderMark = () => {
			if (props$1.showMark && shouldRender.value) return createVNode("div", { "class": bem$67("month-mark") }, [props$1.date.getMonth() + 1]);
		};
		const placeholders = computed(() => {
			const count = Math.ceil((totalDay.value + offset$1.value) / 7);
			return Array(count).fill({ type: "placeholder" });
		});
		const days = computed(() => {
			const days2 = [];
			const year = props$1.date.getFullYear();
			const month = props$1.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$1.formatter) config = props$1.formatter(config);
				days2.push(config);
			}
			return days2;
		});
		const disabledDays = 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 rowOffset = (Math.ceil((targetDate.getDate() + offset$1.value) / 7) - 1) * daysRect.height / totalRows;
				setScrollTop(body, daysRect.top + rowOffset + body.scrollTop - useRect(body).top);
			}
		};
		const renderDay = (item, index) => createVNode(stdin_default$83, {
			"item": item,
			"index": index,
			"color": props$1.color,
			"offset": offset$1.value,
			"rowHeight": rowHeight.value,
			"onClick": (item2) => emit("click", item2),
			"onClickDisabledDate": (item2) => emit("clickDisabledDate", item2)
		}, pick(slots, [
			"top-info",
			"bottom-info",
			"text"
		]));
		const renderDays = () => createVNode("div", {
			"ref": daysRef,
			"role": "grid",
			"class": bem$67("days")
		}, [renderMark(), (shouldRender.value ? days : placeholders).value.map(renderDay)]);
		useExpose({
			getTitle,
			getHeight: () => height$1.value,
			setVisible,
			scrollToDate,
			disabledDays
		});
		return () => createVNode("div", {
			"class": bem$67("month"),
			"ref": monthRef
		}, [renderTitle(), renderDays()]);
	}
});

//#endregion
//#region node_modules/vant/es/calendar/CalendarHeader.mjs
var [name$69] = createNamespace("calendar-header");
var stdin_default$82 = defineComponent({
	name: name$69,
	props: {
		date: Date,
		minDate: Date,
		maxDate: Date,
		title: String,
		subtitle: String,
		showTitle: Boolean,
		showSubtitle: Boolean,
		firstDayOfWeek: Number,
		switchMode: makeStringProp("none")
	},
	emits: ["clickSubtitle", "panelChange"],
	setup(props$1, { slots, emit }) {
		const prevMonthDisabled = computed(() => props$1.date && props$1.minDate && compareMonth(getPrevMonth(props$1.date), props$1.minDate) < 0);
		const prevYearDisabled = computed(() => props$1.date && props$1.minDate && compareMonth(getPrevYear(props$1.date), props$1.minDate) < 0);
		const nextMonthDisabled = computed(() => props$1.date && props$1.maxDate && compareMonth(getNextMonth(props$1.date), props$1.maxDate) > 0);
		const nextYearDisabled = computed(() => props$1.date && props$1.maxDate && compareMonth(getNextYear(props$1.date), props$1.maxDate) > 0);
		const renderTitle = () => {
			if (props$1.showTitle) {
				const text = props$1.title || t$16("title");
				const title = slots.title ? slots.title() : text;
				return createVNode("div", { "class": bem$67("header-title") }, [title]);
			}
		};
		const onClickSubtitle = (event) => emit("clickSubtitle", event);
		const onPanelChange = (date) => emit("panelChange", date);
		const renderAction = (isNext) => {
			const showYearAction = props$1.switchMode === "year-month";
			const monthSlot = slots[isNext ? "next-month" : "prev-month"];
			const yearSlot = slots[isNext ? "next-year" : "prev-year"];
			const monthDisabled = isNext ? nextMonthDisabled.value : prevMonthDisabled.value;
			const yearDisabled = isNext ? nextYearDisabled.value : prevYearDisabled.value;
			const monthIconName = isNext ? "arrow" : "arrow-left";
			const yearIconName = isNext ? "arrow-double-right" : "arrow-double-left";
			const onMonthChange = () => onPanelChange((isNext ? getNextMonth : getPrevMonth)(props$1.date));
			const onYearChange = () => onPanelChange((isNext ? getNextYear : getPrevYear)(props$1.date));
			const MonthAction = createVNode("view", {
				"class": bem$67("header-action", { disabled: monthDisabled }),
				"onClick": monthDisabled ? void 0 : onMonthChange
			}, [monthSlot ? monthSlot({ disabled: monthDisabled }) : createVNode(Icon, {
				"class": { [HAPTICS_FEEDBACK]: !monthDisabled },
				"name": monthIconName
			}, null)]);
			const YearAction = showYearAction && createVNode("view", {
				"class": bem$67("header-action", { disabled: yearDisabled }),
				"onClick": yearDisabled ? void 0 : onYearChange
			}, [yearSlot ? yearSlot({ disabled: yearDisabled }) : createVNode(Icon, {
				"class": { [HAPTICS_FEEDBACK]: !yearDisabled },
				"name": yearIconName
			}, null)]);
			return isNext ? [MonthAction, YearAction] : [YearAction, MonthAction];
		};
		const renderSubtitle = () => {
			if (props$1.showSubtitle) {
				const title = slots.subtitle ? slots.subtitle({
					date: props$1.date,
					text: props$1.subtitle
				}) : props$1.subtitle;
				const canSwitch = props$1.switchMode !== "none";
				return createVNode("div", {
					"class": bem$67("header-subtitle", { "with-switch": canSwitch }),
					"onClick": onClickSubtitle
				}, [canSwitch ? [
					renderAction(),
					createVNode("div", { "class": bem$67("header-subtitle-text") }, [title]),
					renderAction(true)
				] : title]);
			}
		};
		const renderWeekDays = () => {
			const { firstDayOfWeek } = props$1;
			const weekdays = t$16("weekdays");
			const renderWeekDays2 = [...weekdays.slice(firstDayOfWeek, 7), ...weekdays.slice(0, firstDayOfWeek)];
			return createVNode("div", { "class": bem$67("weekdays") }, [renderWeekDays2.map((text) => createVNode("span", { "class": bem$67("weekday") }, [text]))]);
		};
		return () => createVNode("div", { "class": bem$67("header") }, [
			renderTitle(),
			renderSubtitle(),
			renderWeekDays()
		]);
	}
});

//#endregion
//#region node_modules/vant/es/calendar/Calendar.mjs
var calendarProps = {
	show: Boolean,
	type: makeStringProp("single"),
	switchMode: makeStringProp("none"),
	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
	},
	maxDate: {
		type: Date,
		validator: isDate
	},
	firstDayOfWeek: {
		type: numericProp,
		default: 0,
		validator: (val) => val >= 0 && val <= 6
	}
};
var stdin_default$80 = defineComponent({
	name: name$68,
	props: calendarProps,
	emits: [
		"select",
		"confirm",
		"unselect",
		"monthShow",
		"overRange",
		"update:show",
		"clickSubtitle",
		"clickDisabledDate",
		"clickOverlay",
		"panelChange"
	],
	setup(props$1, { emit, slots }) {
		const canSwitch = computed(() => props$1.switchMode !== "none");
		const minDate = computed(() => {
			if (!props$1.minDate && !canSwitch.value) return getToday();
			return props$1.minDate;
		});
		const maxDate = computed(() => {
			if (!props$1.maxDate && !canSwitch.value) return getMonthByOffset(getToday(), 6);
			return props$1.maxDate;
		});
		const limitDateRange = (date, min = minDate.value, max = maxDate.value) => {
			if (min && compareDay(date, min) === -1) return min;
			if (max && compareDay(date, max) === 1) return max;
			return date;
		};
		const getInitialDate = (defaultDate = props$1.defaultDate) => {
			const { type, allowSameDay } = props$1;
			if (defaultDate === null) return defaultDate;
			const now = getToday();
			if (type === "range") {
				if (!Array.isArray(defaultDate)) defaultDate = [];
				if (defaultDate.length === 1 && compareDay(defaultDate[0], now) === 1) defaultDate = [];
				const min = minDate.value;
				const max = maxDate.value;
				return [limitDateRange(defaultDate[0] || now, min, max ? allowSameDay ? max : getPrevDay(max) : void 0), limitDateRange(defaultDate[1] || (allowSameDay ? now : getNextDay(now)), min ? allowSameDay ? min : getNextDay(min) : void 0)];
			}
			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);
		};
		const getInitialPanelDate = () => {
			const date = Array.isArray(currentDate.value) ? currentDate.value[0] : currentDate.value;
			return date ? date : limitDateRange(getToday());
		};
		let bodyHeight;
		const bodyRef = ref();
		const currentDate = ref(getInitialDate());
		const currentPanelDate = ref(getInitialPanelDate());
		const currentMonthRef = ref();
		const [monthRefs, setMonthRefs] = useRefs();
		const dayOffset = computed(() => props$1.firstDayOfWeek ? +props$1.firstDayOfWeek % 7 : 0);
		const months = computed(() => {
			const months2 = [];
			if (!minDate.value || !maxDate.value) return months2;
			const cursor = new Date(minDate.value);
			cursor.setDate(1);
			do {
				months2.push(new Date(cursor));
				cursor.setMonth(cursor.getMonth() + 1);
			} while (compareMonth(cursor, maxDate.value) !== 1);
			return months2;
		});
		const buttonDisabled = computed(() => {
			if (currentDate.value) {
				if (props$1.type === "range") return !currentDate.value[0] || !currentDate.value[1];
				if (props$1.type === "multiple") return !currentDate.value.length;
			}
			return !currentDate.value;
		});
		const getSelectedDate = () => currentDate.value;
		const onScroll = () => {
			const top$1 = getScrollTop(bodyRef.value);
			const bottom$1 = top$1 + bodyHeight;
			const heights = months.value.map((item, index) => monthRefs.value[index].getHeight());
			if (bottom$1 > heights.reduce((a, b) => a + b, 0) && top$1 > 0) return;
			let height$1 = 0;
			let currentMonth;
			const visibleRange = [-1, -1];
			for (let i = 0; i < months.value.length; i++) {
				const month = monthRefs.value[i];
				if (height$1 <= bottom$1 && height$1 + heights[i] >= top$1) {
					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()
						});
					}
				}
				height$1 += heights[i];
			}
			months.value.forEach((month, index) => {
				const visible = index >= visibleRange[0] - 1 && index <= visibleRange[1] + 1;
				monthRefs.value[index].setVisible(visible);
			});
			if (currentMonth) currentMonthRef.value = currentMonth;
		};
		const scrollToDate = (targetDate) => {
			if (canSwitch.value) currentPanelDate.value = targetDate;
			else 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$1.poppable && !props$1.show) return;
			if (currentDate.value) {
				const targetDate = props$1.type === "single" ? currentDate.value : currentDate.value[0];
				if (isDate(targetDate)) scrollToDate(targetDate);
			} else if (!canSwitch.value) raf(onScroll);
		};
		const init = () => {
			if (props$1.poppable && !props$1.show) return;
			if (!canSwitch.value) raf(() => {
				bodyHeight = Math.floor(useRect(bodyRef).height);
			});
			scrollToCurrentDate();
		};
		const reset = (date = getInitialDate()) => {
			currentDate.value = date;
			scrollToCurrentDate();
		};
		const checkRange = (date) => {
			const { maxRange, rangePrompt, showRangePrompt } = props$1;
			if (maxRange && calcDateNum(date) > +maxRange) {
				if (showRangePrompt) showToast(rangePrompt || t$16("rangePrompt", maxRange));
				emit("overRange");
				return false;
			}
			return true;
		};
		const onPanelChange = (date) => {
			currentPanelDate.value = date;
			emit("panelChange", { date });
		};
		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$1.type === "range") {
				if (!checkRange(date)) {
					setCurrentDate([date[0], getDayByOffset(date[0], +props$1.maxRange - 1)]);
					return;
				}
			}
			setCurrentDate(date);
			if (complete && !props$1.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 = 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$1.readonly || !item.date) return;
			const { date } = item;
			const { type } = props$1;
			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$1.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$1.maxRange && dates.length >= +props$1.maxRange) showToast(props$1.rangePrompt || t$16("rangePrompt", props$1.maxRange));
				else select([...dates, date]);
			} else select(date, true);
		};
		const onClickOverlay = (event) => emit("clickOverlay", event);
		const updateShow = (value) => emit("update:show", value);
		const renderMonth = (date, index) => {
			const showMonthTitle = index !== 0 || !props$1.showSubtitle;
			return createVNode(stdin_default$81, mergeProps({
				"ref": canSwitch.value ? currentMonthRef : setMonthRefs(index),
				"date": date,
				"currentDate": currentDate.value,
				"showMonthTitle": showMonthTitle,
				"firstDayOfWeek": dayOffset.value,
				"lazyRender": canSwitch.value ? false : props$1.lazyRender,
				"maxDate": maxDate.value,
				"minDate": minDate.value
			}, pick(props$1, [
				"type",
				"color",
				"showMark",
				"formatter",
				"rowHeight",
				"showSubtitle",
				"allowSameDay"
			]), {
				"onClick": onClickDay,
				"onClickDisabledDate": (item) => emit("clickDisabledDate", item)
			}), pick(slots, [
				"top-info",
				"bottom-info",
				"month-title",
				"text"
			]));
		};
		const renderFooterButton = () => {
			if (slots.footer) return slots.footer();
			if (props$1.showConfirm) {
				const slot = slots["confirm-text"];
				const disabled = buttonDisabled.value;
				const text = disabled ? props$1.confirmDisabledText : props$1.confirmText;
				return createVNode(Button, {
					"round": true,
					"block": true,
					"type": "primary",
					"color": props$1.color,
					"class": bem$67("confirm"),
					"disabled": disabled,
					"nativeType": "button",
					"onClick": onConfirm
				}, { default: () => [slot ? slot({ disabled }) : text || t$16("confirm")] });
			}
		};
		const renderFooter = () => createVNode("div", { "class": [bem$67("footer"), { "van-safe-area-bottom": props$1.safeAreaInsetBottom }] }, [renderFooterButton()]);
		const renderCalendar = () => {
			var _a, _b;
			return createVNode("div", { "class": bem$67() }, [
				createVNode(stdin_default$82, {
					"date": (_a = currentMonthRef.value) == null ? void 0 : _a.date,
					"maxDate": maxDate.value,
					"minDate": minDate.value,
					"title": props$1.title,
					"subtitle": (_b = currentMonthRef.value) == null ? void 0 : _b.getTitle(),
					"showTitle": props$1.showTitle,
					"showSubtitle": props$1.showSubtitle,
					"switchMode": props$1.switchMode,
					"firstDayOfWeek": dayOffset.value,
					"onClickSubtitle": (event) => emit("clickSubtitle", event),
					"onPanelChange": onPanelChange
				}, pick(slots, [
					"title",
					"subtitle",
					"prev-month",
					"prev-year",
					"next-month",
					"next-year"
				])),
				createVNode("div", {
					"ref": bodyRef,
					"class": bem$67("body"),
					"onScroll": canSwitch.value ? void 0 : onScroll
				}, [canSwitch.value ? renderMonth(currentPanelDate.value, 0) : months.value.map(renderMonth)]),
				renderFooter()
			]);
		};
		watch(() => props$1.show, init);
		watch(() => [
			props$1.type,
			props$1.minDate,
			props$1.maxDate,
			props$1.switchMode
		], () => reset(getInitialDate(currentDate.value)));
		watch(() => props$1.defaultDate, (value) => {
			reset(value);
		});
		useExpose({
			reset,
			scrollToDate,
			getSelectedDate
		});
		onMountedOrActivated(init);
		return () => {
			if (props$1.poppable) return createVNode(Popup, {
				"show": props$1.show,
				"class": bem$67("popup"),
				"round": props$1.round,
				"position": props$1.position,
				"closeable": props$1.showTitle || props$1.showSubtitle,
				"teleport": props$1.teleport,
				"closeOnPopstate": props$1.closeOnPopstate,
				"safeAreaInsetTop": props$1.safeAreaInsetTop,
				"closeOnClickOverlay": props$1.closeOnClickOverlay,
				"onClickOverlay": onClickOverlay,
				"onUpdate:show": updateShow
			}, { default: renderCalendar });
			return renderCalendar();
		};
	}
});

//#endregion
//#region node_modules/vant/es/calendar/index.mjs
var Calendar = withInstall(stdin_default$80);

//#endregion
//#region node_modules/vant/es/image/Image.mjs
var [name$67, bem$66] = createNamespace("image");
var imageProps = {
	src: String,
	alt: String,
	fit: String,
	position: String,
	round: Boolean,
	block: Boolean,
	width: numericProp,
	height: numericProp,
	radius: numericProp,
	lazyLoad: Boolean,
	iconSize: numericProp,
	showError: truthProp,
	errorIcon: makeStringProp("photo-fail"),
	iconPrefix: String,
	showLoading: truthProp,
	loadingIcon: makeStringProp("photo"),
	crossorigin: String,
	referrerpolicy: String,
	decoding: String
};
var stdin_default$79 = defineComponent({
	name: name$67,
	props: imageProps,
	emits: ["load", "error"],
	setup(props$1, { emit, slots }) {
		const error = ref(false);
		const loading = ref(true);
		const imageRef = ref();
		const { $Lazyload } = getCurrentInstance().proxy;
		const style = computed(() => {
			const style2 = {
				width: addUnit(props$1.width),
				height: addUnit(props$1.height)
			};
			if (isDef(props$1.radius)) {
				style2.overflow = "hidden";
				style2.borderRadius = addUnit(props$1.radius);
			}
			return style2;
		});
		watch(() => props$1.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 createVNode(Icon, {
				"name": name2,
				"size": props$1.iconSize,
				"class": className,
				"classPrefix": props$1.iconPrefix
			}, null);
		};
		const renderPlaceholder = () => {
			if (loading.value && props$1.showLoading) return createVNode("div", { "class": bem$66("loading") }, [renderIcon(props$1.loadingIcon, bem$66("loading-icon"), slots.loading)]);
			if (error.value && props$1.showError) return createVNode("div", { "class": bem$66("error") }, [renderIcon(props$1.errorIcon, bem$66("error-icon"), slots.error)]);
		};
		const renderImage = () => {
			if (error.value || !props$1.src) return;
			const attrs = {
				alt: props$1.alt,
				class: bem$66("img"),
				decoding: props$1.decoding,
				style: {
					objectFit: props$1.fit,
					objectPosition: props$1.position
				},
				crossorigin: props$1.crossorigin,
				referrerpolicy: props$1.referrerpolicy
			};
			if (props$1.lazyLoad) return withDirectives(createVNode("img", mergeProps({ "ref": imageRef }, attrs), null), [[resolveDirective("lazy"), props$1.src]]);
			return createVNode("img", mergeProps({
				"ref": imageRef,
				"src": props$1.src,
				"onLoad": onLoad,
				"onError": onError
			}, attrs), null);
		};
		const onLazyLoaded = ({ el }) => {
			const check = () => {
				if (el === imageRef.value && loading.value) triggerLoad();
			};
			if (imageRef.value) check();
			else nextTick(check);
		};
		const onLazyLoadError = ({ el }) => {
			if (el === imageRef.value && !error.value) onError();
		};
		if ($Lazyload && inBrowser$1) {
			$Lazyload.$on("loaded", onLazyLoaded);
			$Lazyload.$on("error", onLazyLoadError);
			onBeforeUnmount(() => {
				$Lazyload.$off("loaded", onLazyLoaded);
				$Lazyload.$off("error", onLazyLoadError);
			});
		}
		onMounted(() => {
			nextTick(() => {
				var _a;
				if (((_a = imageRef.value) == null ? void 0 : _a.complete) && !props$1.lazyLoad) triggerLoad();
			});
		});
		return () => {
			var _a;
			return createVNode("div", {
				"class": bem$66({
					round: props$1.round,
					block: props$1.block
				}),
				"style": style.value
			}, [
				renderImage(),
				renderPlaceholder(),
				(_a = slots.default) == null ? void 0 : _a.call(slots)
			]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/image/index.mjs
var Image$1 = withInstall(stdin_default$79);

//#endregion
//#region node_modules/vant/es/card/Card.mjs
var [name$66, bem$65] = createNamespace("card");
var 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$78 = defineComponent({
	name: name$66,
	props: cardProps,
	emits: ["clickThumb"],
	setup(props$1, { slots, emit }) {
		const renderTitle = () => {
			if (slots.title) return slots.title();
			if (props$1.title) return createVNode("div", { "class": [bem$65("title"), "van-multi-ellipsis--l2"] }, [props$1.title]);
		};
		const renderThumbTag = () => {
			if (slots.tag || props$1.tag) return createVNode("div", { "class": bem$65("tag") }, [slots.tag ? slots.tag() : createVNode(Tag, {
				"mark": true,
				"type": "primary"
			}, { default: () => [props$1.tag] })]);
		};
		const renderThumbImage = () => {
			if (slots.thumb) return slots.thumb();
			return createVNode(Image$1, {
				"src": props$1.thumb,
				"fit": "cover",
				"width": "100%",
				"height": "100%",
				"lazyLoad": props$1.lazyLoad
			}, null);
		};
		const renderThumb = () => {
			if (slots.thumb || props$1.thumb) return createVNode("a", {
				"href": props$1.thumbLink,
				"class": bem$65("thumb"),
				"onClick": (event) => emit("clickThumb", event)
			}, [renderThumbImage(), renderThumbTag()]);
		};
		const renderDesc = () => {
			if (slots.desc) return slots.desc();
			if (props$1.desc) return createVNode("div", { "class": [bem$65("desc"), "van-ellipsis"] }, [props$1.desc]);
		};
		const renderPriceText = () => {
			const priceArr = props$1.price.toString().split(".");
			return createVNode("div", null, [
				createVNode("span", { "class": bem$65("price-currency") }, [props$1.currency]),
				createVNode("span", { "class": bem$65("price-integer") }, [priceArr[0]]),
				priceArr.length > 1 && createVNode(Fragment, null, [createTextVNode("."), createVNode("span", { "class": bem$65("price-decimal") }, [priceArr[1]])])
			]);
		};
		return () => {
			var _a, _b, _c;
			const showNum = slots.num || isDef(props$1.num);
			const showPrice = slots.price || isDef(props$1.price);
			const showOriginPrice = slots["origin-price"] || isDef(props$1.originPrice);
			const showBottom = showNum || showPrice || showOriginPrice || slots.bottom;
			const Price = showPrice && createVNode("div", { "class": bem$65("price") }, [slots.price ? slots.price() : renderPriceText()]);
			const OriginPrice = showOriginPrice && createVNode("div", { "class": bem$65("origin-price") }, [slots["origin-price"] ? slots["origin-price"]() : `${props$1.currency} ${props$1.originPrice}`]);
			const Num = showNum && createVNode("div", { "class": bem$65("num") }, [slots.num ? slots.num() : `x${props$1.num}`]);
			const Footer = slots.footer && createVNode("div", { "class": bem$65("footer") }, [slots.footer()]);
			const Bottom = showBottom && createVNode("div", { "class": bem$65("bottom") }, [
				(_a = slots["price-top"]) == null ? void 0 : _a.call(slots),
				Price,
				OriginPrice,
				Num,
				(_b = slots.bottom) == null ? void 0 : _b.call(slots)
			]);
			return createVNode("div", { "class": bem$65() }, [createVNode("div", { "class": bem$65("header") }, [renderThumb(), createVNode("div", { "class": bem$65("content", { centered: props$1.centered }) }, [createVNode("div", null, [
				renderTitle(),
				renderDesc(),
				(_c = slots.tags) == null ? void 0 : _c.call(slots)
			]), Bottom])]), Footer]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/card/index.mjs
var Card = withInstall(stdin_default$78);

//#endregion
//#region node_modules/vant/es/cascader/Cascader.mjs
var [name$65, bem$64, t$15] = createNamespace("cascader");
var 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$77 = defineComponent({
	name: name$65,
	props: cascaderProps,
	emits: [
		"close",
		"change",
		"finish",
		"clickTab",
		"update:modelValue"
	],
	setup(props$1, { slots, emit }) {
		const tabs = ref([]);
		const activeTab = ref(0);
		const [selectedElementRefs, setSelectedElementRefs] = useRefs();
		const { text: textKey, value: valueKey, children: childrenKey } = extend({
			text: "text",
			value: "value",
			children: "children"
		}, props$1.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$1;
			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
					});
					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);
				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$1.showHeader ? createVNode("div", { "class": bem$64("header") }, [createVNode("h2", { "class": bem$64("title") }, [slots.title ? slots.title() : props$1.title]), props$1.closeable ? createVNode(Icon, {
			"name": props$1.closeIcon,
			"class": [bem$64("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$1.activeColor : void 0);
			const Text$1 = slots.option ? slots.option({
				option,
				selected
			}) : createVNode("span", null, [option[textKey]]);
			return createVNode("li", {
				"ref": selected ? setSelectedElementRefs(tabIndex) : void 0,
				"role": "menuitemradio",
				"class": [bem$64("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$1, selected ? createVNode(Icon, {
				"name": "success",
				"class": bem$64("selected-icon")
			}, null) : null]);
		};
		const renderOptions = (options, selectedOption, tabIndex) => createVNode("ul", {
			"role": "menu",
			"class": bem$64("options")
		}, [options.map((option) => renderOption(option, selectedOption, tabIndex))]);
		const renderTab = (tab, tabIndex) => {
			const { options, selected } = tab;
			const placeholder = props$1.placeholder || t$15("select");
			const title = selected ? selected[textKey] : placeholder;
			return createVNode(Tab, {
				"title": title,
				"titleClass": bem$64("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 = () => createVNode(Tabs, {
			"active": activeTab.value,
			"onUpdate:active": ($event) => activeTab.value = $event,
			"shrink": true,
			"animated": true,
			"class": bem$64("tabs"),
			"color": props$1.activeColor,
			"swipeable": props$1.swipeable,
			"onClickTab": onClickTab
		}, { default: () => [tabs.value.map(renderTab)] });
		const scrollIntoView = (el) => {
			const scrollParent = el.parentElement;
			if (scrollParent) scrollParent.scrollTop = el.offsetTop - (scrollParent.offsetHeight - el.offsetHeight) / 2;
		};
		updateTabs();
		watch(activeTab, (value) => {
			const el = selectedElementRefs.value[value];
			if (el) scrollIntoView(el);
		});
		watch(() => props$1.options, updateTabs, { deep: true });
		watch(() => props$1.modelValue, (value) => {
			if (value !== void 0) {
				if (tabs.value.map((tab) => {
					var _a;
					return (_a = tab.selected) == null ? void 0 : _a[valueKey];
				}).includes(value)) return;
			}
			updateTabs();
		});
		return () => createVNode("div", { "class": bem$64() }, [renderHeader(), renderTabs()]);
	}
});

//#endregion
//#region node_modules/vant/es/cascader/index.mjs
var Cascader = withInstall(stdin_default$77);

//#endregion
//#region node_modules/vant/es/cell-group/CellGroup.mjs
var [name$64, bem$63] = createNamespace("cell-group");
var cellGroupProps = {
	title: String,
	inset: Boolean,
	border: truthProp
};
var stdin_default$76 = defineComponent({
	name: name$64,
	inheritAttrs: false,
	props: cellGroupProps,
	setup(props$1, { slots, attrs }) {
		const renderGroup = () => {
			var _a;
			return createVNode("div", mergeProps({ "class": [bem$63({ inset: props$1.inset }), { [BORDER_TOP_BOTTOM]: props$1.border && !props$1.inset }] }, attrs, useScopeId()), [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
		const renderTitle = () => createVNode("div", { "class": bem$63("title", { inset: props$1.inset }) }, [slots.title ? slots.title() : props$1.title]);
		return () => {
			if (props$1.title || slots.title) return createVNode(Fragment, null, [renderTitle(), renderGroup()]);
			return renderGroup();
		};
	}
});

//#endregion
//#region node_modules/vant/es/cell-group/index.mjs
var CellGroup = withInstall(stdin_default$76);

//#endregion
//#region node_modules/vant/es/circle/Circle.mjs
var [name$63, bem$62] = createNamespace("circle");
var uid = 0;
var 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`;
}
var 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$75 = defineComponent({
	name: name$63,
	props: circleProps,
	emits: ["update:currentRate"],
	setup(props$1, { emit, slots }) {
		const id = `van-circle-${uid++}`;
		const viewBoxSize = computed(() => +props$1.strokeWidth + 1e3);
		const path = computed(() => getPath(props$1.clockwise, viewBoxSize.value));
		const svgStyle = computed(() => {
			const angleValue = {
				top: 0,
				right: 90,
				bottom: 180,
				left: 270
			}[props$1.startPosition];
			if (angleValue) return { transform: `rotate(${angleValue}deg)` };
		});
		watch(() => props$1.rate, (rate) => {
			let rafId;
			const startTime = Date.now();
			const startRate = props$1.currentRate;
			const endRate = format$1(rate);
			const duration = Math.abs((startRate - endRate) * 1e3 / +props$1.speed);
			const animate = () => {
				const now = Date.now();
				const rate2 = Math.min((now - startTime) / duration, 1) * (endRate - startRate) + startRate;
				emit("update:currentRate", format$1(parseFloat(rate2.toFixed(1))));
				if (endRate > startRate ? rate2 < endRate : rate2 > endRate) rafId = raf(animate);
			};
			if (props$1.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$1;
			const offset$1 = PERIMETER * currentRate / 100;
			const color = isObject(props$1.color) ? `url(#${id})` : props$1.color;
			const style = {
				stroke: color,
				strokeWidth: `${+strokeWidth + 1}px`,
				strokeLinecap,
				strokeDasharray: `${offset$1}px ${PERIMETER}px`
			};
			return createVNode("path", {
				"d": path.value,
				"style": style,
				"class": bem$62("hover"),
				"stroke": color
			}, null);
		};
		const renderLayer = () => {
			const style = {
				fill: props$1.fill,
				stroke: props$1.layerColor,
				strokeWidth: `${props$1.strokeWidth}px`
			};
			return createVNode("path", {
				"class": bem$62("layer"),
				"style": style,
				"d": path.value
			}, null);
		};
		const renderGradient = () => {
			const { color } = props$1;
			if (!isObject(color)) return;
			const Stops = Object.keys(color).sort((a, b) => parseFloat(a) - parseFloat(b)).map((key, index) => createVNode("stop", {
				"key": index,
				"offset": key,
				"stop-color": color[key]
			}, null));
			return createVNode("defs", null, [createVNode("linearGradient", {
				"id": id,
				"x1": "100%",
				"y1": "0%",
				"x2": "0%",
				"y2": "0%"
			}, [Stops])]);
		};
		const renderText = () => {
			if (slots.default) return slots.default();
			if (props$1.text) return createVNode("div", { "class": bem$62("text") }, [props$1.text]);
		};
		return () => createVNode("div", {
			"class": bem$62(),
			"style": getSizeStyle(props$1.size)
		}, [createVNode("svg", {
			"viewBox": `0 0 ${viewBoxSize.value} ${viewBoxSize.value}`,
			"style": svgStyle.value
		}, [
			renderGradient(),
			renderLayer(),
			renderHover()
		]), renderText()]);
	}
});

//#endregion
//#region node_modules/vant/es/circle/index.mjs
var Circle = withInstall(stdin_default$75);

//#endregion
//#region node_modules/vant/es/row/Row.mjs
var [name$62, bem$61] = createNamespace("row");
var ROW_KEY = Symbol(name$62);
var rowProps = {
	tag: makeStringProp("div"),
	wrap: truthProp,
	align: String,
	gutter: {
		type: [
			String,
			Number,
			Array
		],
		default: 0
	},
	justify: String
};
var stdin_default$32 = defineComponent({
	name: name$62,
	props: rowProps,
	setup(props$1, { slots }) {
		const { children, linkChildren } = useChildren(ROW_KEY);
		const groups = 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;
		});
		linkChildren({
			spaces: computed(() => {
				let gutter = 0;
				if (Array.isArray(props$1.gutter)) gutter = Number(props$1.gutter[0]) || 0;
				else gutter = Number(props$1.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 left$1 = gutter - spaces2[item - 1].right;
							const right$1 = averagePadding - left$1;
							spaces2.push({
								left: left$1,
								right: right$1
							});
						}
					});
				});
				return spaces2;
			}),
			verticalSpaces: computed(() => {
				const { gutter } = props$1;
				const spaces2 = [];
				if (Array.isArray(gutter) && gutter.length > 1) {
					const bottom$1 = Number(gutter[1]) || 0;
					if (bottom$1 <= 0) return spaces2;
					groups.value.forEach((group, index) => {
						if (index === groups.value.length - 1) return;
						group.forEach(() => {
							spaces2.push({ bottom: bottom$1 });
						});
					});
				}
				return spaces2;
			})
		});
		return () => {
			const { tag, wrap, align, justify } = props$1;
			return createVNode(tag, { "class": bem$61({
				[`align-${align}`]: align,
				[`justify-${justify}`]: justify,
				nowrap: !wrap
			}) }, { default: () => {
				var _a;
				return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
			} });
		};
	}
});

//#endregion
//#region node_modules/vant/es/col/Col.mjs
var [name$61, bem$60] = createNamespace("col");
var colProps = {
	tag: makeStringProp("div"),
	span: makeNumericProp(0),
	offset: numericProp
};
var stdin_default$74 = defineComponent({
	name: name$61,
	props: colProps,
	setup(props$1, { slots }) {
		const { parent, index } = useParent(ROW_KEY);
		const style = computed(() => {
			if (!parent) return;
			const { spaces, verticalSpaces } = parent;
			let styles = {};
			if (spaces && spaces.value && spaces.value[index.value]) {
				const { left: left$1, right: right$1 } = spaces.value[index.value];
				styles = {
					paddingLeft: left$1 ? `${left$1}px` : null,
					paddingRight: right$1 ? `${right$1}px` : null
				};
			}
			const { bottom: bottom$1 } = verticalSpaces.value[index.value] || {};
			return extend(styles, { marginBottom: bottom$1 ? `${bottom$1}px` : null });
		});
		return () => {
			const { tag, span, offset: offset$1 } = props$1;
			return createVNode(tag, {
				"style": style.value,
				"class": bem$60({
					[span]: span,
					[`offset-${offset$1}`]: offset$1
				})
			}, { default: () => {
				var _a;
				return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
			} });
		};
	}
});

//#endregion
//#region node_modules/vant/es/col/index.mjs
var Col = withInstall(stdin_default$74);

//#endregion
//#region node_modules/vant/es/collapse/Collapse.mjs
var [name$60, bem$59] = createNamespace("collapse");
var COLLAPSE_KEY = Symbol(name$60);
var collapseProps = {
	border: truthProp,
	accordion: Boolean,
	modelValue: {
		type: [
			String,
			Number,
			Array
		],
		default: ""
	}
};
function validateModelValue(modelValue, accordion) {
	if (accordion && Array.isArray(modelValue)) {
		console.error("[Vant] Collapse: \"v-model\" should not be Array in accordion mode");
		return false;
	}
	if (!accordion && !Array.isArray(modelValue)) {
		console.error("[Vant] Collapse: \"v-model\" should be Array in non-accordion mode");
		return false;
	}
	return true;
}
var stdin_default$73 = defineComponent({
	name: name$60,
	props: collapseProps,
	emits: ["change", "update:modelValue"],
	setup(props$1, { 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$1;
			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$1.accordion) return;
			if (typeof options === "boolean") options = { expanded: options };
			const { expanded, skipDisabled } = options;
			updateName(children.filter((item) => {
				if (item.disabled && skipDisabled) return item.expanded.value;
				return expanded != null ? expanded : !item.expanded.value;
			}).map((item) => item.itemName.value));
		};
		const isExpanded = (name2) => {
			const { accordion, modelValue } = props$1;
			if (!validateModelValue(modelValue, accordion)) return false;
			return accordion ? modelValue === name2 : modelValue.includes(name2);
		};
		useExpose({ toggleAll });
		linkChildren({
			toggle,
			isExpanded
		});
		return () => {
			var _a;
			return createVNode("div", { "class": [bem$59(), { [BORDER_TOP_BOTTOM]: props$1.border }] }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/collapse/index.mjs
var Collapse = withInstall(stdin_default$73);

//#endregion
//#region node_modules/vant/es/collapse-item/CollapseItem.mjs
var [name$59, bem$58] = createNamespace("collapse-item");
var CELL_SLOTS = [
	"icon",
	"title",
	"value",
	"label",
	"right-icon"
];
var collapseItemProps = extend({}, cellSharedProps, {
	name: numericProp,
	isLink: truthProp,
	disabled: Boolean,
	readonly: Boolean,
	lazyRender: truthProp
});
var stdin_default$72 = defineComponent({
	name: name$59,
	props: collapseItemProps,
	setup(props$1, { slots }) {
		const wrapperRef = ref();
		const contentRef = ref();
		const { parent, index } = useParent(COLLAPSE_KEY);
		if (!parent) {
			console.error("[Vant] <CollapseItem> must be a child component of <Collapse>.");
			return;
		}
		const name2 = computed(() => {
			var _a;
			return (_a = props$1.name) != null ? _a : index.value;
		});
		const expanded = computed(() => parent.isExpanded(name2.value));
		const show = ref(expanded.value);
		const lazyRender = useLazyRender(() => show.value || !props$1.lazyRender);
		const onTransitionEnd = () => {
			if (!expanded.value) show.value = false;
			else if (wrapperRef.value) wrapperRef.value.style.height = "";
		};
		watch(expanded, (value, oldValue) => {
			if (oldValue === null) return;
			if (value) show.value = true;
			(value ? nextTick : raf)(() => {
				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$1.disabled && !props$1.readonly) toggle();
		};
		const renderTitle = () => {
			const { border, disabled, readonly } = props$1;
			const attrs = pick(props$1, Object.keys(cellSharedProps));
			if (readonly) attrs.isLink = false;
			if (disabled || readonly) attrs.clickable = false;
			return createVNode(Cell, mergeProps({
				"role": "button",
				"class": bem$58("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 withDirectives(createVNode("div", {
				"ref": wrapperRef,
				"class": bem$58("wrapper"),
				"onTransitionend": onTransitionEnd
			}, [createVNode("div", {
				"ref": contentRef,
				"class": bem$58("content")
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]), [[vShow, show.value]]);
		});
		useExpose({
			toggle,
			expanded,
			itemName: name2
		});
		return () => createVNode("div", { "class": [bem$58({ border: index.value && props$1.border })] }, [renderTitle(), renderContent()]);
	}
});

//#endregion
//#region node_modules/vant/es/collapse-item/index.mjs
var CollapseItem = withInstall(stdin_default$72);

//#endregion
//#region node_modules/vant/es/config-provider/index.mjs
var ConfigProvider = withInstall(stdin_default$71);

//#endregion
//#region node_modules/vant/es/contact-card/ContactCard.mjs
var [name$58, bem$57, t$14] = createNamespace("contact-card");
var contactCardProps = {
	tel: String,
	name: String,
	type: makeStringProp("add"),
	addText: String,
	editable: truthProp
};
var stdin_default$70 = defineComponent({
	name: name$58,
	props: contactCardProps,
	emits: ["click"],
	setup(props$1, { emit }) {
		const onClick = (event) => {
			if (props$1.editable) emit("click", event);
		};
		const renderContent = () => {
			if (props$1.type === "add") return props$1.addText || t$14("addContact");
			return [createVNode("div", null, [`${t$14("name")}\uFF1A${props$1.name}`]), createVNode("div", null, [`${t$14("tel")}\uFF1A${props$1.tel}`])];
		};
		return () => createVNode(Cell, {
			"center": true,
			"icon": props$1.type === "edit" ? "contact" : "add-square",
			"class": bem$57([props$1.type]),
			"border": false,
			"isLink": props$1.editable,
			"titleClass": bem$57("title"),
			"onClick": onClick
		}, { title: renderContent });
	}
});

//#endregion
//#region node_modules/vant/es/contact-card/index.mjs
var ContactCard = withInstall(stdin_default$70);

//#endregion
//#region node_modules/vant/es/contact-edit/ContactEdit.mjs
var [name$57, bem$56, t$13] = createNamespace("contact-edit");
var DEFAULT_CONTACT = {
	tel: "",
	name: ""
};
var 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$69 = defineComponent({
	name: name$57,
	props: contactEditProps,
	emits: [
		"save",
		"delete",
		"changeDefault"
	],
	setup(props$1, { emit }) {
		const contact = reactive(extend({}, DEFAULT_CONTACT, props$1.contactInfo));
		const onSave = () => {
			if (!props$1.isSaving) emit("save", contact);
		};
		const onDelete = () => emit("delete", contact);
		const renderButtons = () => createVNode("div", { "class": bem$56("buttons") }, [createVNode(Button, {
			"block": true,
			"round": true,
			"type": "primary",
			"text": t$13("save"),
			"class": bem$56("button"),
			"loading": props$1.isSaving,
			"nativeType": "submit"
		}, null), props$1.isEdit && createVNode(Button, {
			"block": true,
			"round": true,
			"text": t$13("delete"),
			"class": bem$56("button"),
			"loading": props$1.isDeleting,
			"onClick": onDelete
		}, null)]);
		const renderSwitch = () => createVNode(Switch, {
			"modelValue": contact.isDefault,
			"onUpdate:modelValue": ($event) => contact.isDefault = $event,
			"onChange": (checked) => emit("changeDefault", checked)
		}, null);
		const renderSetDefault = () => {
			if (props$1.showSetDefault) return createVNode(Cell, {
				"title": props$1.setDefaultLabel,
				"class": bem$56("switch-cell"),
				"border": false
			}, { "right-icon": renderSwitch });
		};
		watch(() => props$1.contactInfo, (value) => extend(contact, DEFAULT_CONTACT, value));
		return () => createVNode(Form, {
			"class": bem$56(),
			"onSubmit": onSave
		}, { default: () => [
			createVNode("div", { "class": bem$56("fields") }, [createVNode(Field, {
				"modelValue": contact.name,
				"onUpdate:modelValue": ($event) => contact.name = $event,
				"clearable": true,
				"label": t$13("name"),
				"rules": [{
					required: true,
					message: t$13("nameEmpty")
				}],
				"maxlength": "30",
				"placeholder": t$13("name")
			}, null), createVNode(Field, {
				"modelValue": contact.tel,
				"onUpdate:modelValue": ($event) => contact.tel = $event,
				"clearable": true,
				"type": "tel",
				"label": t$13("tel"),
				"rules": [{
					validator: props$1.telValidator,
					message: t$13("telInvalid")
				}],
				"placeholder": t$13("tel")
			}, null)]),
			renderSetDefault(),
			renderButtons()
		] });
	}
});

//#endregion
//#region node_modules/vant/es/contact-edit/index.mjs
var ContactEdit = withInstall(stdin_default$69);

//#endregion
//#region node_modules/vant/es/contact-list/ContactList.mjs
var [name$56, bem$55, t$12] = createNamespace("contact-list");
var contactListProps = {
	list: Array,
	addText: String,
	modelValue: unknownProp,
	defaultTagText: String
};
var stdin_default$68 = defineComponent({
	name: name$56,
	props: contactListProps,
	emits: [
		"add",
		"edit",
		"select",
		"update:modelValue"
	],
	setup(props$1, { emit }) {
		const renderItem = (item, index) => {
			const onClick = () => {
				emit("update:modelValue", item.id);
				emit("select", item, index);
			};
			const renderRightIcon = () => createVNode(Radio, {
				"class": bem$55("radio"),
				"name": item.id,
				"iconSize": 18
			}, null);
			const renderEditIcon = () => createVNode(Icon, {
				"name": "edit",
				"class": bem$55("edit"),
				"onClick": (event) => {
					event.stopPropagation();
					emit("edit", item, index);
				}
			}, null);
			const renderContent = () => {
				const nodes = [`${item.name}\uFF0C${item.tel}`];
				if (item.isDefault && props$1.defaultTagText) nodes.push(createVNode(Tag, {
					"type": "primary",
					"round": true,
					"class": bem$55("item-tag")
				}, { default: () => [props$1.defaultTagText] }));
				return nodes;
			};
			return createVNode(Cell, {
				"key": item.id,
				"isLink": true,
				"center": true,
				"class": bem$55("item"),
				"titleClass": bem$55("item-title"),
				"onClick": onClick
			}, {
				icon: renderEditIcon,
				title: renderContent,
				"right-icon": renderRightIcon
			});
		};
		return () => createVNode("div", { "class": bem$55() }, [createVNode(RadioGroup, {
			"modelValue": props$1.modelValue,
			"class": bem$55("group")
		}, { default: () => [props$1.list && props$1.list.map(renderItem)] }), createVNode("div", { "class": [bem$55("bottom"), "van-safe-area-bottom"] }, [createVNode(Button, {
			"round": true,
			"block": true,
			"type": "primary",
			"class": bem$55("add"),
			"text": props$1.addText || t$12("addContact"),
			"onClick": () => emit("add")
		}, null)])]);
	}
});

//#endregion
//#region node_modules/vant/es/contact-list/index.mjs
var ContactList = withInstall(stdin_default$68);

//#endregion
//#region node_modules/vant/es/count-down/utils.mjs
function parseFormat(format$2, currentTime) {
	const { days } = currentTime;
	let { hours, minutes, seconds, milliseconds } = currentTime;
	if (format$2.includes("DD")) format$2 = format$2.replace("DD", padZero(days));
	else hours += days * 24;
	if (format$2.includes("HH")) format$2 = format$2.replace("HH", padZero(hours));
	else minutes += hours * 60;
	if (format$2.includes("mm")) format$2 = format$2.replace("mm", padZero(minutes));
	else seconds += minutes * 60;
	if (format$2.includes("ss")) format$2 = format$2.replace("ss", padZero(seconds));
	else milliseconds += seconds * 1e3;
	if (format$2.includes("S")) {
		const ms = padZero(milliseconds, 3);
		if (format$2.includes("SSS")) format$2 = format$2.replace("SSS", ms);
		else if (format$2.includes("SS")) format$2 = format$2.replace("SS", ms.slice(0, 2));
		else format$2 = format$2.replace("S", ms.charAt(0));
	}
	return format$2;
}

//#endregion
//#region node_modules/vant/es/count-down/CountDown.mjs
var [name$55, bem$54] = createNamespace("count-down");
var countDownProps = {
	time: makeNumericProp(0),
	format: makeStringProp("HH:mm:ss"),
	autoStart: truthProp,
	millisecond: Boolean
};
var stdin_default$67 = defineComponent({
	name: name$55,
	props: countDownProps,
	emits: ["change", "finish"],
	setup(props$1, { emit, slots }) {
		const { start: start$1, pause, reset, current: current$1 } = useCountDown({
			time: +props$1.time,
			millisecond: props$1.millisecond,
			onChange: (current2) => emit("change", current2),
			onFinish: () => emit("finish")
		});
		const timeText = computed(() => parseFormat(props$1.format, current$1.value));
		const resetTime = () => {
			reset(+props$1.time);
			if (props$1.autoStart) start$1();
		};
		watch(() => props$1.time, resetTime, { immediate: true });
		useExpose({
			start: start$1,
			pause,
			reset: resetTime
		});
		return () => createVNode("div", {
			"role": "timer",
			"class": bem$54()
		}, [slots.default ? slots.default(current$1.value) : timeText.value]);
	}
});

//#endregion
//#region node_modules/vant/es/count-down/index.mjs
var CountDown = withInstall(stdin_default$67);

//#endregion
//#region node_modules/vant/es/coupon/utils.mjs
function getDate(timeStamp) {
	const date = /* @__PURE__ */ new Date(timeStamp * 1e3);
	return `${date.getFullYear()}.${padZero(date.getMonth() + 1)}.${padZero(date.getDate())}`;
}
var formatDiscount = (discount) => (discount / 10).toFixed(discount % 10 === 0 ? 0 : 1);
var formatAmount = (amount) => (amount / 100).toFixed(amount % 100 === 0 ? 0 : amount % 10 === 0 ? 1 : 2);

//#endregion
//#region node_modules/vant/es/coupon/Coupon.mjs
var [name$54, bem$53, t$11] = createNamespace("coupon");
var stdin_default$66 = defineComponent({
	name: name$54,
	props: {
		chosen: Boolean,
		coupon: makeRequiredProp(Object),
		disabled: Boolean,
		currency: makeStringProp("¥")
	},
	setup(props$1) {
		const validPeriod = computed(() => {
			const { startAt, endAt } = props$1.coupon;
			return `${getDate(startAt)} - ${getDate(endAt)}`;
		});
		const faceAmount = computed(() => {
			const { coupon, currency } = props$1;
			if (coupon.valueDesc) return [coupon.valueDesc, createVNode("span", null, [coupon.unitDesc || ""])];
			if (coupon.denominations) {
				const denominations = formatAmount(coupon.denominations);
				return [createVNode("span", null, [currency]), ` ${denominations}`];
			}
			if (coupon.discount) return t$11("discount", formatDiscount(coupon.discount));
			return "";
		});
		const conditionMessage = computed(() => {
			const condition = formatAmount(props$1.coupon.originCondition || 0);
			return condition === "0" ? t$11("unlimited") : t$11("condition", condition);
		});
		return () => {
			const { chosen, coupon, disabled } = props$1;
			const description = disabled && coupon.reason || coupon.description;
			return createVNode("div", { "class": bem$53({ disabled }) }, [createVNode("div", { "class": bem$53("content") }, [createVNode("div", { "class": bem$53("head") }, [createVNode("h2", { "class": bem$53("amount") }, [faceAmount.value]), createVNode("p", { "class": bem$53("condition") }, [coupon.condition || conditionMessage.value])]), createVNode("div", { "class": bem$53("body") }, [
				createVNode("p", { "class": bem$53("name") }, [coupon.name]),
				createVNode("p", { "class": bem$53("valid") }, [validPeriod.value]),
				!disabled && createVNode(Checkbox, {
					"class": bem$53("corner"),
					"modelValue": chosen
				}, null)
			])]), description && createVNode("p", { "class": bem$53("description") }, [description])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/coupon/index.mjs
var Coupon = withInstall(stdin_default$66);

//#endregion
//#region node_modules/vant/es/coupon-cell/CouponCell.mjs
var [name$53, bem$52, t$10] = createNamespace("coupon-cell");
var couponCellProps = {
	title: String,
	border: truthProp,
	editable: truthProp,
	coupons: makeArrayProp(),
	currency: makeStringProp("¥"),
	chosenCoupon: {
		type: [Number, Array],
		default: -1
	}
};
var getValue = (coupon) => {
	const { value, denominations } = coupon;
	if (isDef(value)) return value;
	if (isDef(denominations)) return denominations;
	return 0;
};
function formatValue({ coupons, chosenCoupon, currency }) {
	let value = 0;
	let isExist = false;
	(Array.isArray(chosenCoupon) ? chosenCoupon : [chosenCoupon]).forEach((i) => {
		const coupon = coupons[+i];
		if (coupon) {
			isExist = true;
			value += getValue(coupon);
		}
	});
	if (isExist) return `-${currency} ${(value / 100).toFixed(2)}`;
	return coupons.length === 0 ? t$10("noCoupon") : t$10("count", coupons.length);
}
var stdin_default$65 = defineComponent({
	name: name$53,
	props: couponCellProps,
	setup(props$1) {
		return () => {
			const selected = Array.isArray(props$1.chosenCoupon) ? props$1.chosenCoupon.length : props$1.coupons[+props$1.chosenCoupon];
			return createVNode(Cell, {
				"class": bem$52(),
				"value": formatValue(props$1),
				"title": props$1.title || t$10("title"),
				"border": props$1.border,
				"isLink": props$1.editable,
				"valueClass": bem$52("value", { selected })
			}, null);
		};
	}
});

//#endregion
//#region node_modules/vant/es/coupon-cell/index.mjs
var CouponCell = withInstall(stdin_default$65);

//#endregion
//#region node_modules/vant/es/empty/Empty.mjs
var [name$52, bem$51] = createNamespace("empty");
var emptyProps = {
	image: makeStringProp("default"),
	imageSize: [
		Number,
		String,
		Array
	],
	description: String
};
var stdin_default$64 = defineComponent({
	name: name$52,
	props: emptyProps,
	setup(props$1, { slots }) {
		const renderDescription = () => {
			const description = slots.description ? slots.description() : props$1.description;
			if (description) return createVNode("p", { "class": bem$51("description") }, [description]);
		};
		const renderBottom = () => {
			if (slots.default) return createVNode("div", { "class": bem$51("bottom") }, [slots.default()]);
		};
		const baseId = useId();
		const getId = (num) => `${baseId}-${num}`;
		const getUrlById = (num) => `url(#${getId(num)})`;
		const renderStop = (color, offset$1, opacity) => createVNode("stop", {
			"stop-color": color,
			"offset": `${offset$1}%`,
			"stop-opacity": opacity
		}, null);
		const renderStops = (fromColor, toColor) => [renderStop(fromColor, 0), renderStop(toColor, 100)];
		const renderShadow = (id) => [createVNode("defs", null, [createVNode("radialGradient", {
			"id": getId(id),
			"cx": "50%",
			"cy": "54%",
			"fx": "50%",
			"fy": "54%",
			"r": "297%",
			"gradientTransform": "matrix(-.16 0 0 -.33 .58 .72)",
			"data-allow-mismatch": "attribute"
		}, [renderStop("#EBEDF0", 0), renderStop("#F2F3F5", 100, .3)])]), createVNode("ellipse", {
			"fill": getUrlById(id),
			"opacity": ".8",
			"cx": "80",
			"cy": "140",
			"rx": "46",
			"ry": "8",
			"data-allow-mismatch": "attribute"
		}, null)];
		const renderBuilding = () => [createVNode("defs", null, [createVNode("linearGradient", {
			"id": getId("a"),
			"x1": "64%",
			"y1": "100%",
			"x2": "64%",
			"data-allow-mismatch": "attribute"
		}, [renderStop("#FFF", 0, .5), renderStop("#F2F3F5", 100)])]), createVNode("g", {
			"opacity": ".8",
			"data-allow-mismatch": "children"
		}, [createVNode("path", {
			"d": "M36 131V53H16v20H2v58h34z",
			"fill": getUrlById("a")
		}, null), createVNode("path", {
			"d": "M123 15h22v14h9v77h-31V15z",
			"fill": getUrlById("a")
		}, null)])];
		const renderCloud = () => [createVNode("defs", null, [createVNode("linearGradient", {
			"id": getId("b"),
			"x1": "64%",
			"y1": "97%",
			"x2": "64%",
			"y2": "0%",
			"data-allow-mismatch": "attribute"
		}, [renderStop("#F2F3F5", 0, .3), renderStop("#F2F3F5", 100)])]), createVNode("g", {
			"opacity": ".8",
			"data-allow-mismatch": "children"
		}, [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), 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 = () => createVNode("svg", { "viewBox": "0 0 160 160" }, [createVNode("defs", { "data-allow-mismatch": "children" }, [
			createVNode("linearGradient", {
				"id": getId(1),
				"x1": "64%",
				"y1": "100%",
				"x2": "64%"
			}, [renderStop("#FFF", 0, .5), renderStop("#F2F3F5", 100)]),
			createVNode("linearGradient", {
				"id": getId(2),
				"x1": "50%",
				"x2": "50%",
				"y2": "84%"
			}, [renderStop("#EBEDF0", 0), renderStop("#DCDEE0", 100, 0)]),
			createVNode("linearGradient", {
				"id": getId(3),
				"x1": "100%",
				"x2": "100%",
				"y2": "100%"
			}, [renderStops("#EAEDF0", "#DCDEE0")]),
			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)])
		]), createVNode("g", { "fill": "none" }, [
			renderBuilding(),
			createVNode("path", {
				"fill": getUrlById(4),
				"d": "M0 139h160v21H0z",
				"data-allow-mismatch": "attribute"
			}, null),
			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),
				"data-allow-mismatch": "attribute"
			}, null),
			createVNode("g", {
				"opacity": ".6",
				"stroke-linecap": "round",
				"stroke-width": "7",
				"data-allow-mismatch": "children"
			}, [
				createVNode("path", {
					"d": "M64 47a19 19 0 0 0-5 13c0 5 2 10 5 13",
					"stroke": getUrlById(3)
				}, null),
				createVNode("path", {
					"d": "M53 36a34 34 0 0 0 0 48",
					"stroke": getUrlById(3)
				}, null),
				createVNode("path", {
					"d": "M95 73a19 19 0 0 0 6-13c0-5-2-9-6-13",
					"stroke": getUrlById(3)
				}, null),
				createVNode("path", {
					"d": "M106 84a34 34 0 0 0 0-48",
					"stroke": getUrlById(3)
				}, null)
			]),
			createVNode("g", { "transform": "translate(31 105)" }, [
				createVNode("rect", {
					"fill": "#EBEDF0",
					"width": "98",
					"height": "34",
					"rx": "2"
				}, null),
				createVNode("rect", {
					"fill": "#FFF",
					"x": "9",
					"y": "8",
					"width": "80",
					"height": "18",
					"rx": "1.1"
				}, null),
				createVNode("rect", {
					"fill": "#EBEDF0",
					"x": "15",
					"y": "12",
					"width": "18",
					"height": "6",
					"rx": "1.1"
				}, null)
			])
		])]);
		const renderMaterial = () => createVNode("svg", { "viewBox": "0 0 160 160" }, [
			createVNode("defs", { "data-allow-mismatch": "children" }, [
				createVNode("linearGradient", {
					"x1": "50%",
					"x2": "50%",
					"y2": "100%",
					"id": getId(5)
				}, [renderStops("#F2F3F5", "#DCDEE0")]),
				createVNode("linearGradient", {
					"x1": "95%",
					"y1": "48%",
					"x2": "5.5%",
					"y2": "51%",
					"id": getId(6)
				}, [renderStops("#EAEDF1", "#DCDEE0")]),
				createVNode("linearGradient", {
					"y1": "45%",
					"x2": "100%",
					"y2": "54%",
					"id": getId(7)
				}, [renderStops("#EAEDF1", "#DCDEE0")])
			]),
			renderBuilding(),
			renderCloud(),
			createVNode("g", {
				"transform": "translate(36 50)",
				"fill": "none"
			}, [
				createVNode("g", { "transform": "translate(8)" }, [
					createVNode("rect", {
						"fill": "#EBEDF0",
						"opacity": ".6",
						"x": "38",
						"y": "13",
						"width": "36",
						"height": "53",
						"rx": "2"
					}, null),
					createVNode("rect", {
						"fill": getUrlById(5),
						"width": "64",
						"height": "66",
						"rx": "2",
						"data-allow-mismatch": "attribute"
					}, null),
					createVNode("rect", {
						"fill": "#FFF",
						"x": "6",
						"y": "6",
						"width": "52",
						"height": "55",
						"rx": "1"
					}, null),
					createVNode("g", {
						"transform": "translate(15 17)",
						"fill": getUrlById(6),
						"data-allow-mismatch": "attribute"
					}, [
						createVNode("rect", {
							"width": "34",
							"height": "6",
							"rx": "1"
						}, null),
						createVNode("path", { "d": "M0 14h34v6H0z" }, null),
						createVNode("rect", {
							"y": "28",
							"width": "34",
							"height": "6",
							"rx": "1"
						}, null)
					])
				]),
				createVNode("rect", {
					"fill": getUrlById(7),
					"y": "61",
					"width": "88",
					"height": "28",
					"rx": "1",
					"data-allow-mismatch": "attribute"
				}, null),
				createVNode("rect", {
					"fill": "#F7F8FA",
					"x": "29",
					"y": "72",
					"width": "30",
					"height": "6",
					"rx": "1"
				}, null)
			])
		]);
		const renderError = () => createVNode("svg", { "viewBox": "0 0 160 160" }, [
			createVNode("defs", null, [createVNode("linearGradient", {
				"x1": "50%",
				"x2": "50%",
				"y2": "100%",
				"id": getId(8),
				"data-allow-mismatch": "attribute"
			}, [renderStops("#EAEDF1", "#DCDEE0")])]),
			renderBuilding(),
			renderCloud(),
			renderShadow("c"),
			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),
				"data-allow-mismatch": "attribute"
			}, null)
		]);
		const renderSearch = () => createVNode("svg", { "viewBox": "0 0 160 160" }, [
			createVNode("defs", { "data-allow-mismatch": "children" }, [
				createVNode("linearGradient", {
					"x1": "50%",
					"y1": "100%",
					"x2": "50%",
					"id": getId(9)
				}, [renderStops("#EEE", "#D8D8D8")]),
				createVNode("linearGradient", {
					"x1": "100%",
					"y1": "50%",
					"y2": "50%",
					"id": getId(10)
				}, [renderStops("#F2F3F5", "#DCDEE0")]),
				createVNode("linearGradient", {
					"x1": "50%",
					"x2": "50%",
					"y2": "100%",
					"id": getId(11)
				}, [renderStops("#F2F3F5", "#DCDEE0")]),
				createVNode("linearGradient", {
					"x1": "50%",
					"x2": "50%",
					"y2": "100%",
					"id": getId(12)
				}, [renderStops("#FFF", "#F7F8FA")])
			]),
			renderBuilding(),
			renderCloud(),
			renderShadow("d"),
			createVNode("g", {
				"transform": "rotate(-45 113 -4)",
				"fill": "none",
				"data-allow-mismatch": "children"
			}, [
				createVNode("rect", {
					"fill": getUrlById(9),
					"x": "24",
					"y": "52.8",
					"width": "5.8",
					"height": "19",
					"rx": "1"
				}, null),
				createVNode("rect", {
					"fill": getUrlById(10),
					"x": "22.1",
					"y": "67.3",
					"width": "9.9",
					"height": "28",
					"rx": "1"
				}, null),
				createVNode("circle", {
					"stroke": getUrlById(11),
					"stroke-width": "8",
					"cx": "27",
					"cy": "27",
					"r": "27"
				}, null),
				createVNode("circle", {
					"fill": getUrlById(12),
					"cx": "27",
					"cy": "27",
					"r": "16"
				}, null),
				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$1.image]) == null ? void 0 : _a.call(PRESET_IMAGES)) || createVNode("img", { "src": props$1.image }, null);
		};
		return () => createVNode("div", { "class": bem$51() }, [
			createVNode("div", {
				"class": bem$51("image"),
				"style": getSizeStyle(props$1.imageSize)
			}, [renderImage()]),
			renderDescription(),
			renderBottom()
		]);
	}
});

//#endregion
//#region node_modules/vant/es/empty/index.mjs
var Empty = withInstall(stdin_default$64);

//#endregion
//#region node_modules/vant/es/coupon-list/CouponList.mjs
var [name$51, bem$50, t$9] = createNamespace("coupon-list");
var couponListProps = {
	code: makeStringProp(""),
	coupons: makeArrayProp(),
	currency: makeStringProp("¥"),
	showCount: truthProp,
	emptyImage: String,
	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,
	chosenCoupon: {
		type: [Number, Array],
		default: -1
	}
};
var stdin_default$63 = defineComponent({
	name: name$51,
	props: couponListProps,
	emits: [
		"change",
		"exchange",
		"update:code"
	],
	setup(props$1, { emit, slots }) {
		const [couponRefs, setCouponRefs] = useRefs();
		const root = ref();
		const barRef = ref();
		const activeTab = ref(0);
		const listHeight = ref(0);
		const currentCode = ref(props$1.code);
		const buttonDisabled = computed(() => !props$1.exchangeButtonLoading && (props$1.exchangeButtonDisabled || !currentCode.value || currentCode.value.length < props$1.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$1.code) currentCode.value = "";
		};
		const scrollToCoupon = (index) => {
			nextTick(() => {
				var _a;
				return (_a = couponRefs.value[index]) == null ? void 0 : _a.scrollIntoView();
			});
		};
		const renderEmpty = () => createVNode(Empty, { "image": props$1.emptyImage }, { default: () => [createVNode("p", { "class": bem$50("empty-tip") }, [t$9("noCoupon")])] });
		const renderExchangeBar = () => {
			if (props$1.showExchangeBar) return createVNode("div", {
				"ref": barRef,
				"class": bem$50("exchange-bar")
			}, [createVNode(Field, {
				"modelValue": currentCode.value,
				"onUpdate:modelValue": ($event) => currentCode.value = $event,
				"clearable": true,
				"border": false,
				"class": bem$50("field"),
				"placeholder": props$1.inputPlaceholder || t$9("placeholder"),
				"maxlength": "20"
			}, null), createVNode(Button, {
				"plain": true,
				"type": "primary",
				"class": bem$50("exchange"),
				"text": props$1.exchangeButtonText || t$9("exchange"),
				"loading": props$1.exchangeButtonLoading,
				"disabled": buttonDisabled.value,
				"onClick": onExchange
			}, null)]);
		};
		const renderCouponTab = () => {
			const { coupons, chosenCoupon } = props$1;
			const count = props$1.showCount ? ` (${coupons.length})` : "";
			const title = (props$1.enabledTitle || t$9("enable")) + count;
			const updateChosenCoupon = (currentValues = [], value = 0) => {
				if (currentValues.includes(value)) return currentValues.filter((item) => item !== value);
				return [...currentValues, value];
			};
			return createVNode(Tab, { "title": title }, { default: () => {
				var _a;
				return [createVNode("div", {
					"class": bem$50("list", { "with-bottom": props$1.showCloseButton }),
					"style": { height: `${listHeight.value}px` }
				}, [
					coupons.map((coupon, index) => createVNode(Coupon, {
						"key": coupon.id,
						"ref": setCouponRefs(index),
						"coupon": coupon,
						"chosen": Array.isArray(chosenCoupon) ? chosenCoupon.includes(index) : index === chosenCoupon,
						"currency": props$1.currency,
						"onClick": () => emit("change", Array.isArray(chosenCoupon) ? updateChosenCoupon(chosenCoupon, index) : index)
					}, null)),
					!coupons.length && renderEmpty(),
					(_a = slots["list-footer"]) == null ? void 0 : _a.call(slots)
				])];
			} });
		};
		const renderDisabledTab = () => {
			const { disabledCoupons } = props$1;
			const count = props$1.showCount ? ` (${disabledCoupons.length})` : "";
			const title = (props$1.disabledTitle || t$9("disabled")) + count;
			return createVNode(Tab, { "title": title }, { default: () => {
				var _a;
				return [createVNode("div", {
					"class": bem$50("list", { "with-bottom": props$1.showCloseButton }),
					"style": { height: `${listHeight.value}px` }
				}, [
					disabledCoupons.map((coupon) => createVNode(Coupon, {
						"disabled": true,
						"key": coupon.id,
						"coupon": coupon,
						"currency": props$1.currency
					}, null)),
					!disabledCoupons.length && renderEmpty(),
					(_a = slots["disabled-list-footer"]) == null ? void 0 : _a.call(slots)
				])];
			} });
		};
		watch(() => props$1.code, (value) => {
			currentCode.value = value;
		});
		watch(windowHeight, updateListHeight);
		watch(currentCode, (value) => emit("update:code", value));
		watch(() => props$1.displayedCouponIndex, scrollToCoupon);
		onMounted(() => {
			updateListHeight();
			scrollToCoupon(props$1.displayedCouponIndex);
		});
		return () => createVNode("div", {
			"ref": root,
			"class": bem$50()
		}, [
			renderExchangeBar(),
			createVNode(Tabs, {
				"active": activeTab.value,
				"onUpdate:active": ($event) => activeTab.value = $event,
				"class": bem$50("tab")
			}, { default: () => [renderCouponTab(), renderDisabledTab()] }),
			createVNode("div", { "class": bem$50("bottom") }, [slots["list-button"] ? slots["list-button"]() : withDirectives(createVNode(Button, {
				"round": true,
				"block": true,
				"type": "primary",
				"class": bem$50("close"),
				"text": props$1.closeButtonText || t$9("close"),
				"onClick": () => emit("change", Array.isArray(props$1.chosenCoupon) ? [] : -1)
			}, null), [[vShow, props$1.showCloseButton]])])
		]);
	}
});

//#endregion
//#region node_modules/vant/es/coupon-list/index.mjs
var CouponList = withInstall(stdin_default$63);

//#endregion
//#region node_modules/vant/es/date-picker/DatePicker.mjs
var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
var [name$50] = createNamespace("date-picker");
var 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$62 = defineComponent({
	name: name$50,
	props: datePickerProps,
	emits: [
		"confirm",
		"cancel",
		"change",
		"update:modelValue"
	],
	setup(props$1, { emit, slots }) {
		const currentValues = ref(props$1.modelValue);
		const updatedByExternalSources = ref(false);
		const pickerRef = ref();
		const computedValues = computed(() => updatedByExternalSources.value ? props$1.modelValue : currentValues.value);
		const isMinYear = (year) => year === props$1.minDate.getFullYear();
		const isMaxYear = (year) => year === props$1.maxDate.getFullYear();
		const isMinMonth = (month) => month === props$1.minDate.getMonth() + 1;
		const isMaxMonth = (month) => month === props$1.maxDate.getMonth() + 1;
		const getValue$1 = (type) => {
			const { minDate, columnsType } = props$1;
			const index = columnsType.indexOf(type);
			const value = computedValues.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 genYearOptions = () => {
			return genOptions(props$1.minDate.getFullYear(), props$1.maxDate.getFullYear(), "year", props$1.formatter, props$1.filter, computedValues.value);
		};
		const genMonthOptions = () => {
			const year = getValue$1("year");
			return genOptions(isMinYear(year) ? props$1.minDate.getMonth() + 1 : 1, isMaxYear(year) ? props$1.maxDate.getMonth() + 1 : 12, "month", props$1.formatter, props$1.filter, computedValues.value);
		};
		const genDayOptions = () => {
			const year = getValue$1("year");
			const month = getValue$1("month");
			return genOptions(isMinYear(year) && isMinMonth(month) ? props$1.minDate.getDate() : 1, isMaxYear(year) && isMaxMonth(month) ? props$1.maxDate.getDate() : getMonthEndDay(year, month), "day", props$1.formatter, props$1.filter, computedValues.value);
		};
		const confirm = () => {
			var _a;
			return (_a = pickerRef.value) == null ? void 0 : _a.confirm();
		};
		const getSelectedDate = () => currentValues.value;
		const columns = computed(() => props$1.columnsType.map((type) => {
			switch (type) {
				case "year": return genYearOptions();
				case "month": return genMonthOptions();
				case "day": return genDayOptions();
				default: throw new Error(`[Vant] DatePicker: unsupported columns type: ${type}`);
			}
		}));
		watch(currentValues, (newValues) => {
			if (!isSameValue(newValues, props$1.modelValue)) emit("update:modelValue", newValues);
		});
		watch(() => props$1.modelValue, (newValues, oldValues) => {
			updatedByExternalSources.value = isSameValue(oldValues, currentValues.value);
			newValues = formatValueRange(newValues, columns.value);
			if (!isSameValue(newValues, currentValues.value)) currentValues.value = newValues;
			updatedByExternalSources.value = false;
		}, { immediate: true });
		const onChange = (...args) => emit("change", ...args);
		const onCancel = (...args) => emit("cancel", ...args);
		const onConfirm = (...args) => emit("confirm", ...args);
		useExpose({
			confirm,
			getSelectedDate
		});
		return () => createVNode(Picker, mergeProps({
			"ref": pickerRef,
			"modelValue": currentValues.value,
			"onUpdate:modelValue": ($event) => currentValues.value = $event,
			"columns": columns.value,
			"onChange": onChange,
			"onCancel": onCancel,
			"onConfirm": onConfirm
		}, pick(props$1, pickerInheritKeys)), slots);
	}
});

//#endregion
//#region node_modules/vant/es/date-picker/index.mjs
var DatePicker = withInstall(stdin_default$62);

//#endregion
//#region node_modules/vant/es/dialog/Dialog.mjs
var [name$49, bem$49, t$8] = createNamespace("dialog");
var 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,
	keyboardEnabled: truthProp,
	destroyOnClose: Boolean
});
var popupInheritKeys$1 = [
	...popupSharedPropKeys,
	"transition",
	"closeOnPopstate",
	"destroyOnClose"
];
var stdin_default$61 = defineComponent({
	name: name$49,
	props: dialogProps,
	emits: [
		"confirm",
		"cancel",
		"keydown",
		"update:show"
	],
	setup(props$1, { emit, slots }) {
		const root = ref();
		const loading = reactive({
			confirm: false,
			cancel: false
		});
		const updateShow = (value) => emit("update:show", value);
		const close = (action) => {
			var _a;
			updateShow(false);
			(_a = props$1.callback) == null || _a.call(props$1, action);
		};
		const getActionHandler = (action) => () => {
			if (!props$1.show) return;
			emit(action);
			if (props$1.beforeClose) {
				loading[action] = true;
				callInterceptor(props$1.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 = withKeys((event) => {
			var _a, _b;
			if (!props$1.keyboardEnabled) return;
			if (event.target !== ((_b = (_a = root.value) == null ? void 0 : _a.popupRef) == null ? void 0 : _b.value)) return;
			({
				Enter: props$1.showConfirmButton ? onConfirm : noop,
				Escape: props$1.showCancelButton ? onCancel : noop
			})[event.key]();
			emit("keydown", event);
		}, ["enter", "esc"]);
		const renderTitle = () => {
			const title = slots.title ? slots.title() : props$1.title;
			if (title) return createVNode("div", { "class": bem$49("header", { isolated: !props$1.message && !slots.default }) }, [title]);
		};
		const renderMessage = (hasTitle) => {
			const { message, allowHtml, messageAlign } = props$1;
			const classNames = bem$49("message", {
				"has-title": hasTitle,
				[messageAlign]: messageAlign
			});
			const content = isFunction(message) ? message() : message;
			if (allowHtml && typeof content === "string") return createVNode("div", {
				"class": classNames,
				"innerHTML": content
			}, null);
			return createVNode("div", { "class": classNames }, [content]);
		};
		const renderContent = () => {
			if (slots.default) return createVNode("div", { "class": bem$49("content") }, [slots.default()]);
			const { title, message, allowHtml } = props$1;
			if (message) {
				const hasTitle = !!(title || slots.title);
				return createVNode("div", {
					"key": allowHtml ? 1 : 0,
					"class": bem$49("content", { isolated: !hasTitle })
				}, [renderMessage(hasTitle)]);
			}
		};
		const renderButtons = () => createVNode("div", { "class": [BORDER_TOP, bem$49("footer")] }, [props$1.showCancelButton && createVNode(Button, {
			"size": "large",
			"text": props$1.cancelButtonText || t$8("cancel"),
			"class": bem$49("cancel"),
			"style": { color: props$1.cancelButtonColor },
			"loading": loading.cancel,
			"disabled": props$1.cancelButtonDisabled,
			"onClick": onCancel
		}, null), props$1.showConfirmButton && createVNode(Button, {
			"size": "large",
			"text": props$1.confirmButtonText || t$8("confirm"),
			"class": [bem$49("confirm"), { [BORDER_LEFT]: props$1.showCancelButton }],
			"style": { color: props$1.confirmButtonColor },
			"loading": loading.confirm,
			"disabled": props$1.confirmButtonDisabled,
			"onClick": onConfirm
		}, null)]);
		const renderRoundButtons = () => createVNode(ActionBar, { "class": bem$49("footer") }, { default: () => [props$1.showCancelButton && createVNode(ActionBarButton, {
			"type": "warning",
			"text": props$1.cancelButtonText || t$8("cancel"),
			"class": bem$49("cancel"),
			"color": props$1.cancelButtonColor,
			"loading": loading.cancel,
			"disabled": props$1.cancelButtonDisabled,
			"onClick": onCancel
		}, null), props$1.showConfirmButton && createVNode(ActionBarButton, {
			"type": "danger",
			"text": props$1.confirmButtonText || t$8("confirm"),
			"class": bem$49("confirm"),
			"color": props$1.confirmButtonColor,
			"loading": loading.confirm,
			"disabled": props$1.confirmButtonDisabled,
			"onClick": onConfirm
		}, null)] });
		const renderFooter = () => {
			if (slots.footer) return slots.footer();
			return props$1.theme === "round-button" ? renderRoundButtons() : renderButtons();
		};
		return () => {
			const { width: width$1, title, theme, message, className } = props$1;
			return createVNode(Popup, mergeProps({
				"ref": root,
				"role": "dialog",
				"class": [bem$49([theme]), className],
				"style": { width: addUnit(width$1) },
				"tabindex": 0,
				"aria-labelledby": title || message,
				"onKeydown": onKeydown,
				"onUpdate:show": updateShow
			}, pick(props$1, popupInheritKeys$1)), { default: () => [
				renderTitle(),
				renderContent(),
				renderFooter()
			] });
		};
	}
});

//#endregion
//#region node_modules/vant/es/dialog/function-call.mjs
var instance$2;
var 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,
	destroyOnClose: false
};
var currentOptions$1 = extend({}, DEFAULT_OPTIONS$1);
function initInstance$2() {
	const Wrapper = { setup() {
		const { state, toggle } = usePopupState();
		return () => createVNode(stdin_default$61, mergeProps(state, { "onUpdate:show": toggle }), null);
	} };
	({instance: instance$2} = mountComponent(Wrapper));
}
function showDialog(options) {
	if (!inBrowser$1) return Promise.resolve(void 0);
	return new Promise((resolve, reject) => {
		if (!instance$2) initInstance$2();
		instance$2.open(extend({}, currentOptions$1, options, { callback: (action) => {
			(action === "confirm" ? resolve : reject)(action);
		} }));
	});
}
var setDialogDefaultOptions = (options) => {
	extend(currentOptions$1, options);
};
var resetDialogDefaultOptions = () => {
	currentOptions$1 = extend({}, DEFAULT_OPTIONS$1);
};
var showConfirmDialog = (options) => showDialog(extend({ showCancelButton: true }, options));
var closeDialog = () => {
	if (instance$2) instance$2.toggle(false);
};

//#endregion
//#region node_modules/vant/es/dialog/index.mjs
var Dialog = withInstall(stdin_default$61);

//#endregion
//#region node_modules/vant/es/divider/Divider.mjs
var [name$48, bem$48] = createNamespace("divider");
var dividerProps = {
	dashed: Boolean,
	hairline: truthProp,
	vertical: Boolean,
	contentPosition: makeStringProp("center")
};
var stdin_default$60 = defineComponent({
	name: name$48,
	props: dividerProps,
	setup(props$1, { slots }) {
		return () => {
			var _a;
			return createVNode("div", {
				"role": "separator",
				"class": bem$48({
					dashed: props$1.dashed,
					hairline: props$1.hairline,
					vertical: props$1.vertical,
					[`content-${props$1.contentPosition}`]: !!slots.default && !props$1.vertical
				})
			}, [!props$1.vertical && ((_a = slots.default) == null ? void 0 : _a.call(slots))]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/divider/index.mjs
var Divider = withInstall(stdin_default$60);

//#endregion
//#region node_modules/vant/es/dropdown-menu/DropdownMenu.mjs
var [name$47, bem$47] = createNamespace("dropdown-menu");
var dropdownMenuProps = {
	overlay: truthProp,
	zIndex: numericProp,
	duration: makeNumericProp(.2),
	direction: makeStringProp("down"),
	activeColor: String,
	autoLocate: Boolean,
	closeOnClickOutside: truthProp,
	closeOnClickOverlay: truthProp,
	swipeThreshold: numericProp
};
var DROPDOWN_KEY = Symbol(name$47);
var stdin_default$58 = defineComponent({
	name: name$47,
	props: dropdownMenuProps,
	setup(props$1, { slots }) {
		const id = useId();
		const root = ref();
		const barRef = ref();
		const offset$1 = ref(0);
		const { children, linkChildren } = useChildren(DROPDOWN_KEY);
		const scrollParent = useScrollParent(root);
		const opened = computed(() => children.some((item) => item.state.showWrapper));
		const scrollable = computed(() => props$1.swipeThreshold && children.length > +props$1.swipeThreshold);
		const barStyle = computed(() => {
			if (opened.value && isDef(props$1.zIndex)) return { zIndex: +props$1.zIndex + 1 };
		});
		const close = () => {
			children.forEach((item) => {
				item.toggle(false);
			});
		};
		const onClickAway = () => {
			if (props$1.closeOnClickOutside) close();
		};
		const updateOffset = () => {
			if (barRef.value) {
				const rect = useRect(barRef);
				if (props$1.direction === "down") offset$1.value = rect.bottom;
				else offset$1.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 createVNode("div", {
				"id": `${id}-${index}`,
				"role": "button",
				"tabindex": disabled ? void 0 : 0,
				"data-allow-mismatch": "attribute",
				"class": [bem$47("item", {
					disabled,
					grow: scrollable.value
				}), { [HAPTICS_FEEDBACK]: !disabled }],
				"onClick": () => {
					if (!disabled) toggleItem(index);
				}
			}, [createVNode("span", {
				"class": [bem$47("title", {
					down: showPopup === (props$1.direction === "down"),
					active: showPopup
				}), titleClass],
				"style": { color: showPopup ? props$1.activeColor : "" }
			}, [createVNode("div", { "class": "van-ellipsis" }, [item.renderTitle()])])]);
		};
		useExpose({
			close,
			opened
		});
		linkChildren({
			id,
			props: props$1,
			offset: offset$1,
			opened,
			updateOffset
		});
		useClickAway(root, onClickAway);
		useEventListener("scroll", onScroll, {
			target: scrollParent,
			passive: true
		});
		return () => {
			var _a;
			return createVNode("div", {
				"ref": root,
				"class": bem$47()
			}, [createVNode("div", {
				"ref": barRef,
				"style": barStyle.value,
				"class": bem$47("bar", {
					opened: opened.value,
					scrollable: scrollable.value
				})
			}, [children.map(renderTitle)]), (_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/dropdown-item/DropdownItem.mjs
var [name$46, bem$46] = createNamespace("dropdown-item");
var dropdownItemProps = {
	title: String,
	options: makeArrayProp(),
	disabled: Boolean,
	teleport: [String, Object],
	lazyRender: truthProp,
	modelValue: unknownProp,
	titleClass: unknownProp
};
var stdin_default$59 = defineComponent({
	name: name$46,
	inheritAttrs: false,
	props: dropdownItemProps,
	emits: [
		"open",
		"opened",
		"close",
		"closed",
		"change",
		"update:modelValue"
	],
	setup(props$1, { emit, slots, attrs }) {
		const state = reactive({
			showPopup: false,
			transition: true,
			showWrapper: false
		});
		const wrapperRef = ref();
		const { parent, index } = useParent(DROPDOWN_KEY);
		if (!parent) {
			console.error("[Vant] <DropdownItem> must be a child component of <DropdownMenu>.");
			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$1.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$1.title) return props$1.title;
			const match = props$1.options.find((option) => option.value === props$1.modelValue);
			return match ? match.text : "";
		};
		const renderOption = (option) => {
			const { activeColor } = parent.props;
			const { disabled } = option;
			const active = option.value === props$1.modelValue;
			const onClick = () => {
				if (disabled) return;
				state.showPopup = false;
				if (option.value !== props$1.modelValue) {
					emit("update:modelValue", option.value);
					emit("change", option.value);
				}
			};
			const renderIcon = () => {
				if (active) return createVNode(Icon, {
					"class": bem$46("icon"),
					"color": disabled ? void 0 : activeColor,
					"name": "success"
				}, null);
			};
			return createVNode(Cell, {
				"role": "menuitem",
				"key": String(option.value),
				"icon": option.icon,
				"title": option.text,
				"class": bem$46("option", {
					active,
					disabled
				}),
				"style": { color: active ? activeColor : "" },
				"tabindex": active ? 0 : -1,
				"clickable": !disabled,
				"onClick": onClick
			}, { value: renderIcon });
		};
		const renderContent = () => {
			const { offset: offset$1 } = parent;
			const { autoLocate, zIndex, overlay, duration, direction, closeOnClickOverlay } = parent.props;
			const style = getZIndexStyle(zIndex);
			let offsetValue = offset$1.value;
			if (autoLocate && wrapperRef.value) {
				const offsetParent = getContainingBlock$1(wrapperRef.value);
				if (offsetParent) offsetValue -= useRect(offsetParent).top;
			}
			if (direction === "down") style.top = `${offsetValue}px`;
			else style.bottom = `${offsetValue}px`;
			return withDirectives(createVNode("div", mergeProps({
				"ref": wrapperRef,
				"style": style,
				"class": bem$46([direction]),
				"onClick": onClickWrapper
			}, attrs), [createVNode(Popup, {
				"show": state.showPopup,
				"onUpdate:show": ($event) => state.showPopup = $event,
				"role": "menu",
				"class": bem$46("content"),
				"overlay": overlay,
				"overlayProps": { duration: state.transition && !parent.opened.value ? duration : 0 },
				"position": direction === "down" ? "top" : "bottom",
				"duration": state.transition ? duration : 0,
				"lazyRender": props$1.lazyRender,
				"overlayStyle": { position: "absolute" },
				"aria-labelledby": `${parent.id}-${index.value}`,
				"data-allow-mismatch": "attribute",
				"closeOnClickOverlay": closeOnClickOverlay,
				"onOpen": onOpen,
				"onClose": onClose,
				"onOpened": onOpened,
				"onClosed": onClosed
			}, { default: () => {
				var _a;
				return [props$1.options.map(renderOption), (_a = slots.default) == null ? void 0 : _a.call(slots)];
			} })]), [[vShow, state.showWrapper]]);
		};
		useExpose({
			state,
			toggle,
			renderTitle
		});
		return () => {
			if (props$1.teleport) return createVNode(Teleport, { "to": props$1.teleport }, { default: () => [renderContent()] });
			return renderContent();
		};
	}
});

//#endregion
//#region node_modules/vant/es/dropdown-item/index.mjs
var DropdownItem = withInstall(stdin_default$59);

//#endregion
//#region node_modules/vant/es/dropdown-menu/index.mjs
var DropdownMenu = withInstall(stdin_default$58);

//#endregion
//#region node_modules/vant/es/floating-bubble/FloatingBubble.mjs
var floatingBubbleProps = {
	gap: {
		type: [Number, Object],
		default: 24
	},
	icon: String,
	axis: makeStringProp("y"),
	magnetic: String,
	offset: Object,
	teleport: {
		type: [String, Object],
		default: "body"
	}
};
var [name$45, bem$45] = createNamespace("floating-bubble");
var stdin_default$56 = defineComponent({
	name: name$45,
	inheritAttrs: false,
	props: floatingBubbleProps,
	emits: [
		"click",
		"update:offset",
		"offsetChange"
	],
	setup(props$1, { slots, emit, attrs }) {
		const rootRef = ref();
		const state = ref({
			x: 0,
			y: 0,
			width: 0,
			height: 0
		});
		const gapX = computed(() => isObject(props$1.gap) ? props$1.gap.x : props$1.gap);
		const gapY = computed(() => isObject(props$1.gap) ? props$1.gap.y : props$1.gap);
		const boundary = computed(() => ({
			top: gapY.value,
			right: windowWidth.value - state.value.width - gapX.value,
			bottom: windowHeight.value - state.value.height - gapY.value,
			left: gapX.value
		}));
		const dragging = ref(false);
		let initialized = false;
		const rootStyle = computed(() => {
			const style = {};
			style.transform = `translate3d(${addUnit(state.value.x)}, ${addUnit(state.value.y)}, 0)`;
			if (dragging.value || !initialized) style.transition = "none";
			return style;
		});
		const updateState = () => {
			if (!show.value) return;
			const { width: width$1, height: height$1 } = useRect(rootRef.value);
			const { offset: offset$1 } = props$1;
			state.value = {
				x: offset$1 ? offset$1.x : windowWidth.value - width$1 - gapX.value,
				y: offset$1 ? offset$1.y : windowHeight.value - height$1 - gapY.value,
				width: width$1,
				height: height$1
			};
		};
		const touch = useTouch();
		let prevX = 0;
		let prevY = 0;
		const onTouchStart = (e) => {
			touch.start(e);
			dragging.value = true;
			prevX = state.value.x;
			prevY = state.value.y;
		};
		const onTouchMove = (e) => {
			e.preventDefault();
			touch.move(e);
			if (props$1.axis === "lock") return;
			if (!touch.isTap.value) {
				if (props$1.axis === "x" || props$1.axis === "xy") {
					let nextX = prevX + touch.deltaX.value;
					if (nextX < boundary.value.left) nextX = boundary.value.left;
					if (nextX > boundary.value.right) nextX = boundary.value.right;
					state.value.x = nextX;
				}
				if (props$1.axis === "y" || props$1.axis === "xy") {
					let nextY = prevY + touch.deltaY.value;
					if (nextY < boundary.value.top) nextY = boundary.value.top;
					if (nextY > boundary.value.bottom) nextY = boundary.value.bottom;
					state.value.y = nextY;
				}
				emit("update:offset", pick(state.value, ["x", "y"]));
			}
		};
		useEventListener("touchmove", onTouchMove, { target: rootRef });
		const onTouchEnd = () => {
			dragging.value = false;
			nextTick(() => {
				if (props$1.magnetic === "x") {
					const nextX = closest([boundary.value.left, boundary.value.right], state.value.x);
					state.value.x = nextX;
				}
				if (props$1.magnetic === "y") {
					const nextY = closest([boundary.value.top, boundary.value.bottom], state.value.y);
					state.value.y = nextY;
				}
				if (!touch.isTap.value) {
					const offset$1 = pick(state.value, ["x", "y"]);
					emit("update:offset", offset$1);
					if (prevX !== offset$1.x || prevY !== offset$1.y) emit("offsetChange", offset$1);
				}
			});
		};
		const onClick = (e) => {
			if (touch.isTap.value) emit("click", e);
			else e.stopPropagation();
		};
		onMounted(() => {
			updateState();
			nextTick(() => {
				initialized = true;
			});
		});
		watch([
			windowWidth,
			windowHeight,
			gapX,
			gapY,
			() => props$1.offset
		], updateState, { deep: true });
		const show = ref(true);
		onActivated(() => {
			show.value = true;
		});
		onDeactivated(() => {
			if (props$1.teleport) show.value = false;
		});
		return () => {
			const Content = withDirectives(createVNode("div", mergeProps({
				"class": bem$45(),
				"ref": rootRef,
				"onTouchstartPassive": onTouchStart,
				"onTouchend": onTouchEnd,
				"onTouchcancel": onTouchEnd,
				"onClickCapture": onClick,
				"style": rootStyle.value
			}, attrs), [slots.default ? slots.default() : createVNode(stdin_default$57, {
				"name": props$1.icon,
				"class": bem$45("icon")
			}, null)]), [[vShow, show.value]]);
			return props$1.teleport ? createVNode(Teleport, { "to": props$1.teleport }, { default: () => [Content] }) : Content;
		};
	}
});

//#endregion
//#region node_modules/vant/es/floating-bubble/index.mjs
var FloatingBubble = withInstall(stdin_default$56);

//#endregion
//#region node_modules/vant/es/floating-panel/FloatingPanel.mjs
var floatingPanelProps = {
	height: makeNumericProp(0),
	anchors: makeArrayProp(),
	duration: makeNumericProp(.3),
	contentDraggable: truthProp,
	lockScroll: Boolean,
	safeAreaInsetBottom: truthProp
};
var [name$44, bem$44] = createNamespace("floating-panel");
var stdin_default$55 = defineComponent({
	name: name$44,
	props: floatingPanelProps,
	emits: ["heightChange", "update:height"],
	setup(props$1, { emit, slots }) {
		const DAMP = .2;
		const rootRef = ref();
		const contentRef = ref();
		const height$1 = useSyncPropRef(() => +props$1.height, (value) => emit("update:height", value));
		const boundary = computed(() => {
			var _a, _b;
			return {
				min: (_a = props$1.anchors[0]) != null ? _a : 100,
				max: (_b = props$1.anchors[props$1.anchors.length - 1]) != null ? _b : Math.round(windowHeight.value * .6)
			};
		});
		const anchors = computed(() => props$1.anchors.length >= 2 ? props$1.anchors : [boundary.value.min, boundary.value.max]);
		const dragging = ref(false);
		const rootStyle = computed(() => ({
			height: addUnit(boundary.value.max),
			transform: `translateY(calc(100% + ${addUnit(-height$1.value)}))`,
			transition: !dragging.value ? `transform ${props$1.duration}s cubic-bezier(0.18, 0.89, 0.32, 1.28)` : "none"
		}));
		const ease = (moveY) => {
			const absDistance = Math.abs(moveY);
			const { min, max } = boundary.value;
			if (absDistance > max) return -(max + (absDistance - max) * DAMP);
			if (absDistance < min) return -(min - (min - absDistance) * DAMP);
			return moveY;
		};
		let startY;
		let maxScroll = -1;
		const touch = useTouch();
		const onTouchstart = (e) => {
			touch.start(e);
			dragging.value = true;
			startY = -height$1.value;
			maxScroll = -1;
		};
		const onTouchmove = (e) => {
			var _a;
			touch.move(e);
			const target = e.target;
			if (contentRef.value === target || ((_a = contentRef.value) == null ? void 0 : _a.contains(target))) {
				const { scrollTop } = contentRef.value;
				maxScroll = Math.max(maxScroll, scrollTop);
				if (!props$1.contentDraggable) return;
				if (-startY < boundary.value.max) preventDefault(e, true);
				else if (!(scrollTop <= 0 && touch.deltaY.value > 0) || maxScroll > 0) return;
			}
			height$1.value = -ease(touch.deltaY.value + startY);
		};
		const onTouchend = () => {
			maxScroll = -1;
			dragging.value = false;
			height$1.value = closest(anchors.value, height$1.value);
			if (height$1.value !== -startY) emit("heightChange", { height: height$1.value });
		};
		watch(boundary, () => {
			height$1.value = closest(anchors.value, height$1.value);
		}, { immediate: true });
		useLockScroll(rootRef, () => props$1.lockScroll || dragging.value);
		useEventListener("touchmove", onTouchmove, { target: rootRef });
		const renderHeader = () => {
			if (slots.header) return slots.header();
			return createVNode("div", { "class": bem$44("header") }, [createVNode("div", { "class": bem$44("header-bar") }, null)]);
		};
		return () => {
			var _a;
			return createVNode("div", {
				"class": [bem$44(), { "van-safe-area-bottom": props$1.safeAreaInsetBottom }],
				"ref": rootRef,
				"style": rootStyle.value,
				"onTouchstartPassive": onTouchstart,
				"onTouchend": onTouchend,
				"onTouchcancel": onTouchend
			}, [renderHeader(), createVNode("div", {
				"class": bem$44("content"),
				"ref": contentRef
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/floating-panel/index.mjs
var FloatingPanel = withInstall(stdin_default$55);

//#endregion
//#region node_modules/vant/es/grid/Grid.mjs
var [name$43, bem$43] = createNamespace("grid");
var gridProps = {
	square: Boolean,
	center: truthProp,
	border: truthProp,
	gutter: numericProp,
	reverse: Boolean,
	iconSize: numericProp,
	direction: String,
	clickable: Boolean,
	columnNum: makeNumericProp(4)
};
var GRID_KEY = Symbol(name$43);
var stdin_default$54 = defineComponent({
	name: name$43,
	props: gridProps,
	setup(props$1, { slots }) {
		const { linkChildren } = useChildren(GRID_KEY);
		linkChildren({ props: props$1 });
		return () => {
			var _a;
			return createVNode("div", {
				"style": { paddingLeft: addUnit(props$1.gutter) },
				"class": [bem$43(), { [BORDER_TOP]: props$1.border && !props$1.gutter }]
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/grid/index.mjs
var Grid = withInstall(stdin_default$54);

//#endregion
//#region node_modules/vant/es/grid-item/GridItem.mjs
var [name$42, bem$42] = createNamespace("grid-item");
var gridItemProps = extend({}, routeProps, {
	dot: Boolean,
	text: String,
	icon: String,
	badge: numericProp,
	iconColor: String,
	iconPrefix: String,
	badgeProps: Object
});
var stdin_default$53 = defineComponent({
	name: name$42,
	props: gridItemProps,
	setup(props$1, { slots }) {
		const { parent, index } = useParent(GRID_KEY);
		const route$1 = useRoute();
		if (!parent) {
			console.error("[Vant] <GridItem> must be a child component of <Grid>.");
			return;
		}
		const rootStyle = 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 = 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 createVNode(Badge, mergeProps({
				"dot": props$1.dot,
				"content": props$1.badge
			}, props$1.badgeProps), { default: slots.icon });
			if (props$1.icon) return createVNode(Icon, {
				"dot": props$1.dot,
				"name": props$1.icon,
				"size": parent.props.iconSize,
				"badge": props$1.badge,
				"class": bem$42("icon"),
				"color": props$1.iconColor,
				"badgeProps": props$1.badgeProps,
				"classPrefix": props$1.iconPrefix
			}, null);
		};
		const renderText = () => {
			if (slots.text) return slots.text();
			if (props$1.text) return createVNode("span", { "class": bem$42("text") }, [props$1.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$42("content", [direction, {
				center,
				square,
				reverse,
				clickable,
				surround: border && gutter
			}]), { [BORDER]: border }];
			return createVNode("div", {
				"class": [bem$42({ square })],
				"style": rootStyle.value
			}, [createVNode("div", {
				"role": clickable ? "button" : void 0,
				"class": classes,
				"style": contentStyle.value,
				"tabindex": clickable ? 0 : void 0,
				"onClick": route$1
			}, [renderContent()])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/grid-item/index.mjs
var GridItem = withInstall(stdin_default$53);

//#endregion
//#region node_modules/vant/es/highlight/Highlight.mjs
var [name$41, bem$41] = createNamespace("highlight");
var highlightProps = {
	autoEscape: truthProp,
	caseSensitive: Boolean,
	highlightClass: String,
	highlightTag: makeStringProp("span"),
	keywords: makeRequiredProp([String, Array]),
	sourceString: makeStringProp(""),
	tag: makeStringProp("div"),
	unhighlightClass: String,
	unhighlightTag: makeStringProp("span")
};
var stdin_default$52 = defineComponent({
	name: name$41,
	props: highlightProps,
	setup(props$1) {
		const highlightChunks = computed(() => {
			const { autoEscape, caseSensitive, keywords, sourceString } = props$1;
			const flags = caseSensitive ? "g" : "gi";
			let chunks = (Array.isArray(keywords) ? keywords : [keywords]).filter((keyword) => keyword).reduce((chunks2, keyword) => {
				if (autoEscape) keyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
				const regex = new RegExp(keyword, flags);
				let match;
				while (match = regex.exec(sourceString)) {
					const start$1 = match.index;
					const end$1 = regex.lastIndex;
					if (start$1 >= end$1) {
						regex.lastIndex++;
						continue;
					}
					chunks2.push({
						start: start$1,
						end: end$1,
						highlight: true
					});
				}
				return chunks2;
			}, []);
			chunks = chunks.sort((a, b) => a.start - b.start).reduce((chunks2, currentChunk) => {
				const prevChunk = chunks2[chunks2.length - 1];
				if (!prevChunk || currentChunk.start > prevChunk.end) {
					const unhighlightStart = prevChunk ? prevChunk.end : 0;
					const unhighlightEnd = currentChunk.start;
					if (unhighlightStart !== unhighlightEnd) chunks2.push({
						start: unhighlightStart,
						end: unhighlightEnd,
						highlight: false
					});
					chunks2.push(currentChunk);
				} else prevChunk.end = Math.max(prevChunk.end, currentChunk.end);
				return chunks2;
			}, []);
			const lastChunk = chunks[chunks.length - 1];
			if (!lastChunk) chunks.push({
				start: 0,
				end: sourceString.length,
				highlight: false
			});
			if (lastChunk && lastChunk.end < sourceString.length) chunks.push({
				start: lastChunk.end,
				end: sourceString.length,
				highlight: false
			});
			return chunks;
		});
		const renderContent = () => {
			const { sourceString, highlightClass, unhighlightClass, highlightTag, unhighlightTag } = props$1;
			return highlightChunks.value.map((chunk) => {
				const { start: start$1, end: end$1, highlight } = chunk;
				const text = sourceString.slice(start$1, end$1);
				if (highlight) return createVNode(highlightTag, { "class": [bem$41("tag"), highlightClass] }, { default: () => [text] });
				return createVNode(unhighlightTag, { "class": unhighlightClass }, { default: () => [text] });
			});
		};
		return () => {
			const { tag } = props$1;
			return createVNode(tag, { "class": bem$41() }, { default: () => [renderContent()] });
		};
	}
});

//#endregion
//#region node_modules/vant/es/highlight/index.mjs
var Highlight = withInstall(stdin_default$52);

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

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

//#endregion
//#region node_modules/vant/es/image-preview/function-call.mjs
var instance$1;
var defaultConfig = {
	loop: true,
	images: [],
	maxZoom: 3,
	minZoom: 1 / 3,
	onScale: void 0,
	onClose: void 0,
	onChange: void 0,
	vertical: false,
	teleport: "body",
	className: "",
	showIndex: true,
	closeable: false,
	closeIcon: "clear",
	transition: void 0,
	beforeClose: void 0,
	doubleScale: true,
	overlayStyle: void 0,
	overlayClass: void 0,
	startPosition: 0,
	swipeDuration: 300,
	showIndicators: false,
	closeOnPopstate: true,
	closeOnClickOverlay: true,
	closeIconPosition: "top-right"
};
function initInstance$1() {
	({instance: instance$1} = mountComponent({ setup() {
		const { state, toggle } = usePopupState();
		const onClosed = () => {
			state.images = [];
		};
		return () => createVNode(stdin_default$50, mergeProps(state, {
			"onClosed": onClosed,
			"onUpdate:show": toggle
		}), null);
	} }));
}
var 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;
};

//#endregion
//#region node_modules/vant/es/image-preview/index.mjs
var ImagePreview = withInstall(stdin_default$50);

//#endregion
//#region node_modules/vant/es/index-bar/IndexBar.mjs
function genAlphabet() {
	const charCodeOfA = "A".charCodeAt(0);
	return Array(26).fill("").map((_, i) => String.fromCharCode(charCodeOfA + i));
}
var [name$39, bem$38] = createNamespace("index-bar");
var indexBarProps = {
	sticky: truthProp,
	zIndex: numericProp,
	teleport: [String, Object],
	highlightColor: String,
	stickyOffsetTop: makeNumberProp(0),
	indexList: {
		type: Array,
		default: genAlphabet
	}
};
var INDEX_BAR_KEY = Symbol(name$39);
var stdin_default$48 = defineComponent({
	name: name$39,
	props: indexBarProps,
	emits: ["select", "change"],
	setup(props$1, { emit, slots }) {
		const root = ref();
		const sidebar = ref();
		const activeAnchor = ref("");
		const touch = useTouch();
		const scrollParent = useScrollParent(root);
		const { children, linkChildren } = useChildren(INDEX_BAR_KEY);
		let selectActiveIndex;
		linkChildren({ props: props$1 });
		const sidebarStyle = computed(() => {
			if (isDef(props$1.zIndex)) return { zIndex: +props$1.zIndex + 1 };
		});
		const highlightStyle = computed(() => {
			if (props$1.highlightColor) return { color: props$1.highlightColor };
		});
		const getActiveAnchor = (scrollTop, rects) => {
			for (let i = children.length - 1; i >= 0; i--) {
				const prevHeight = i > 0 ? rects[i - 1].height : 0;
				if (scrollTop + (props$1.sticky ? prevHeight + props$1.stickyOffsetTop : 0) >= 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$1;
			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);
					if (props$1.sticky && props$1.stickyOffsetTop) active = getActiveAnchor(rect.top - props$1.stickyOffsetTop, rects);
					else 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$1.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 = () => {
			nextTick(onScroll);
		};
		useEventListener("scroll", onScroll, {
			target: scrollParent,
			passive: true
		});
		onMounted(init);
		watch(() => props$1.indexList, init);
		watch(activeAnchor, (value) => {
			if (value) emit("change", value);
		});
		const renderIndexes = () => props$1.indexList.map((index) => {
			const active = index === activeAnchor.value;
			return createVNode("span", {
				"class": bem$38("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$1.sticky && props$1.stickyOffsetTop) if (getRootScrollTop() === offsetHeight - scrollParentRect.height) setRootScrollTop(getRootScrollTop());
				else setRootScrollTop(getRootScrollTop() - props$1.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 = () => createVNode("div", {
			"ref": sidebar,
			"class": bem$38("sidebar"),
			"style": sidebarStyle.value,
			"onClick": onClickSidebar,
			"onTouchstartPassive": touch.start
		}, [renderIndexes()]);
		useExpose({ scrollTo });
		useEventListener("touchmove", onTouchMove, { target: sidebar });
		return () => {
			var _a;
			return createVNode("div", {
				"ref": root,
				"class": bem$38()
			}, [props$1.teleport ? createVNode(Teleport, { "to": props$1.teleport }, { default: () => [renderSidebar()] }) : renderSidebar(), (_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/index-anchor/IndexAnchor.mjs
var [name$38, bem$37] = createNamespace("index-anchor");
var indexAnchorProps = { index: numericProp };
var stdin_default$49 = defineComponent({
	name: name$38,
	props: indexAnchorProps,
	setup(props$1, { slots }) {
		const state = reactive({
			top: 0,
			left: null,
			rect: {
				top: 0,
				height: 0
			},
			width: null,
			active: false
		});
		const root = ref();
		const { parent } = useParent(INDEX_BAR_KEY);
		if (!parent) {
			console.error("[Vant] <IndexAnchor> must be a child component of <IndexBar>.");
			return;
		}
		const isSticky = () => state.active && parent.props.sticky;
		const anchorStyle = 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 createVNode("div", {
				"ref": root,
				"style": { height: sticky ? `${state.rect.height}px` : void 0 }
			}, [createVNode("div", {
				"style": anchorStyle.value,
				"class": [bem$37({ sticky }), { [BORDER_BOTTOM]: sticky }]
			}, [slots.default ? slots.default() : props$1.index])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/index-anchor/index.mjs
var IndexAnchor = withInstall(stdin_default$49);

//#endregion
//#region node_modules/vant/es/index-bar/index.mjs
var IndexBar = withInstall(stdin_default$48);

//#endregion
//#region node_modules/vant/es/list/List.mjs
var [name$37, bem$36, t$7] = createNamespace("list");
var listProps = {
	error: Boolean,
	offset: makeNumericProp(300),
	loading: Boolean,
	disabled: Boolean,
	finished: Boolean,
	scroller: Object,
	errorText: String,
	direction: makeStringProp("down"),
	loadingText: String,
	finishedText: String,
	immediateCheck: truthProp
};
var stdin_default$47 = defineComponent({
	name: name$37,
	props: listProps,
	emits: [
		"load",
		"update:error",
		"update:loading"
	],
	setup(props$1, { emit, slots }) {
		const loading = ref(props$1.loading);
		const root = ref();
		const placeholder = ref();
		const tabStatus = useAllTabStatus();
		const scrollParent = useScrollParent(root);
		const scroller = computed(() => props$1.scroller || scrollParent.value);
		const check = () => {
			nextTick(() => {
				if (loading.value || props$1.finished || props$1.disabled || props$1.error || (tabStatus == null ? void 0 : tabStatus.value) === false) return;
				const { direction } = props$1;
				const offset$1 = +props$1.offset;
				const scrollParentRect = useRect(scroller);
				if (!scrollParentRect.height || isHidden(root)) return;
				let isReachEdge = false;
				const placeholderRect = useRect(placeholder);
				if (direction === "up") isReachEdge = scrollParentRect.top - placeholderRect.top <= offset$1;
				else isReachEdge = placeholderRect.bottom - scrollParentRect.bottom <= offset$1;
				if (isReachEdge) {
					loading.value = true;
					emit("update:loading", true);
					emit("load");
				}
			});
		};
		const renderFinishedText = () => {
			if (props$1.finished) {
				const text = slots.finished ? slots.finished() : props$1.finishedText;
				if (text) return createVNode("div", { "class": bem$36("finished-text") }, [text]);
			}
		};
		const clickErrorText = () => {
			emit("update:error", false);
			check();
		};
		const renderErrorText = () => {
			if (props$1.error) {
				const text = slots.error ? slots.error() : props$1.errorText;
				if (text) return createVNode("div", {
					"role": "button",
					"class": bem$36("error-text"),
					"tabindex": 0,
					"onClick": clickErrorText
				}, [text]);
			}
		};
		const renderLoading = () => {
			if (loading.value && !props$1.finished && !props$1.disabled) return createVNode("div", { "class": bem$36("loading") }, [slots.loading ? slots.loading() : createVNode(Loading, { "class": bem$36("loading-icon") }, { default: () => [props$1.loadingText || t$7("loading")] })]);
		};
		watch(() => [
			props$1.loading,
			props$1.finished,
			props$1.error
		], check);
		if (tabStatus) watch(tabStatus, (tabActive) => {
			if (tabActive) check();
		});
		onUpdated(() => {
			loading.value = props$1.loading;
		});
		onMounted(() => {
			if (props$1.immediateCheck) check();
		});
		useExpose({ check });
		useEventListener("scroll", check, {
			target: scroller,
			passive: true
		});
		return () => {
			var _a;
			const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
			const Placeholder = createVNode("div", {
				"ref": placeholder,
				"class": bem$36("placeholder")
			}, null);
			return createVNode("div", {
				"ref": root,
				"role": "feed",
				"class": bem$36(),
				"aria-busy": loading.value
			}, [
				props$1.direction === "down" ? Content : Placeholder,
				renderLoading(),
				renderFinishedText(),
				renderErrorText(),
				props$1.direction === "up" ? Content : Placeholder
			]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/list/index.mjs
var List = withInstall(stdin_default$47);

//#endregion
//#region node_modules/vant/es/nav-bar/NavBar.mjs
var [name$36, bem$35] = createNamespace("nav-bar");
var navBarProps = {
	title: String,
	fixed: Boolean,
	zIndex: numericProp,
	border: truthProp,
	leftText: String,
	rightText: String,
	leftDisabled: Boolean,
	rightDisabled: Boolean,
	leftArrow: Boolean,
	placeholder: Boolean,
	safeAreaInsetTop: Boolean,
	clickable: truthProp
};
var stdin_default$46 = defineComponent({
	name: name$36,
	props: navBarProps,
	emits: ["clickLeft", "clickRight"],
	setup(props$1, { emit, slots }) {
		const navBarRef = ref();
		const renderPlaceholder = usePlaceholder(navBarRef, bem$35);
		const onClickLeft = (event) => {
			if (!props$1.leftDisabled) emit("clickLeft", event);
		};
		const onClickRight = (event) => {
			if (!props$1.rightDisabled) emit("clickRight", event);
		};
		const renderLeft = () => {
			if (slots.left) return slots.left();
			return [props$1.leftArrow && createVNode(Icon, {
				"class": bem$35("arrow"),
				"name": "arrow-left"
			}, null), props$1.leftText && createVNode("span", { "class": bem$35("text") }, [props$1.leftText])];
		};
		const renderRight = () => {
			if (slots.right) return slots.right();
			return createVNode("span", { "class": bem$35("text") }, [props$1.rightText]);
		};
		const renderNavBar = () => {
			const { title, fixed, border, zIndex } = props$1;
			const style = getZIndexStyle(zIndex);
			const hasLeft = props$1.leftArrow || props$1.leftText || slots.left;
			const hasRight = props$1.rightText || slots.right;
			return createVNode("div", {
				"ref": navBarRef,
				"style": style,
				"class": [bem$35({ fixed }), {
					[BORDER_BOTTOM]: border,
					"van-safe-area-top": props$1.safeAreaInsetTop
				}]
			}, [createVNode("div", { "class": bem$35("content") }, [
				hasLeft && createVNode("div", {
					"class": [bem$35("left", { disabled: props$1.leftDisabled }), props$1.clickable && !props$1.leftDisabled ? HAPTICS_FEEDBACK : ""],
					"onClick": onClickLeft
				}, [renderLeft()]),
				createVNode("div", { "class": [bem$35("title"), "van-ellipsis"] }, [slots.title ? slots.title() : title]),
				hasRight && createVNode("div", {
					"class": [bem$35("right", { disabled: props$1.rightDisabled }), props$1.clickable && !props$1.rightDisabled ? HAPTICS_FEEDBACK : ""],
					"onClick": onClickRight
				}, [renderRight()])
			])]);
		};
		return () => {
			if (props$1.fixed && props$1.placeholder) return renderPlaceholder(renderNavBar);
			return renderNavBar();
		};
	}
});

//#endregion
//#region node_modules/vant/es/nav-bar/index.mjs
var NavBar = withInstall(stdin_default$46);

//#endregion
//#region node_modules/vant/es/notice-bar/NoticeBar.mjs
var [name$35, bem$34] = createNamespace("notice-bar");
var 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$45 = defineComponent({
	name: name$35,
	props: noticeBarProps,
	emits: ["close", "replay"],
	setup(props$1, { emit, slots }) {
		let wrapWidth = 0;
		let contentWidth = 0;
		let startTimer;
		const wrapRef = ref();
		const contentRef = ref();
		const state = reactive({
			show: true,
			offset: 0,
			duration: 0
		});
		const renderLeftIcon = () => {
			if (slots["left-icon"]) return slots["left-icon"]();
			if (props$1.leftIcon) return createVNode(Icon, {
				"class": bem$34("left-icon"),
				"name": props$1.leftIcon
			}, null);
		};
		const getRightIconName = () => {
			if (props$1.mode === "closeable") return "cross";
			if (props$1.mode === "link") return "arrow";
		};
		const onClickRightIcon = (event) => {
			if (props$1.mode === "closeable") {
				state.show = false;
				emit("close", event);
			}
		};
		const renderRightIcon = () => {
			if (slots["right-icon"]) return slots["right-icon"]();
			const name2 = getRightIconName();
			if (name2) return createVNode(Icon, {
				"name": name2,
				"class": bem$34("right-icon"),
				"onClick": onClickRightIcon
			}, null);
		};
		const onTransitionEnd = () => {
			state.offset = wrapWidth;
			state.duration = 0;
			raf(() => {
				doubleRaf(() => {
					state.offset = -contentWidth;
					state.duration = (contentWidth + wrapWidth) / +props$1.speed;
					emit("replay");
				});
			});
		};
		const renderMarquee = () => {
			const ellipsis = props$1.scrollable === false && !props$1.wrapable;
			const style = {
				transform: state.offset ? `translateX(${state.offset}px)` : "",
				transitionDuration: `${state.duration}s`
			};
			return createVNode("div", {
				"ref": wrapRef,
				"role": "marquee",
				"class": bem$34("wrap")
			}, [createVNode("div", {
				"ref": contentRef,
				"style": style,
				"class": [bem$34("content"), { "van-ellipsis": ellipsis }],
				"onTransitionend": onTransitionEnd
			}, [slots.default ? slots.default() : props$1.text])]);
		};
		const reset = () => {
			const { delay, speed, scrollable } = props$1;
			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 });
		watch(() => [props$1.text, props$1.scrollable], reset);
		return () => {
			const { color, wrapable, background } = props$1;
			return withDirectives(createVNode("div", {
				"role": "alert",
				"class": bem$34({ wrapable }),
				"style": {
					color,
					background
				}
			}, [
				renderLeftIcon(),
				renderMarquee(),
				renderRightIcon()
			]), [[vShow, state.show]]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/notice-bar/index.mjs
var NoticeBar = withInstall(stdin_default$45);

//#endregion
//#region node_modules/vant/es/notify/Notify.mjs
var [name$34, bem$33] = createNamespace("notify");
var popupInheritProps = [
	"lockScroll",
	"position",
	"show",
	"teleport",
	"zIndex"
];
var notifyProps = extend({}, popupSharedProps, {
	type: makeStringProp("danger"),
	color: String,
	message: numericProp,
	position: makeStringProp("top"),
	className: unknownProp,
	background: String,
	lockScroll: Boolean
});
var stdin_default$44 = defineComponent({
	name: name$34,
	props: notifyProps,
	emits: ["update:show"],
	setup(props$1, { emit, slots }) {
		const updateShow = (show) => emit("update:show", show);
		return () => createVNode(Popup, mergeProps({
			"class": [bem$33([props$1.type]), props$1.className],
			"style": {
				color: props$1.color,
				background: props$1.background
			},
			"overlay": false,
			"duration": .2,
			"onUpdate:show": updateShow
		}, pick(props$1, popupInheritProps)), { default: () => [slots.default ? slots.default() : props$1.message] });
	}
});

//#endregion
//#region node_modules/vant/es/notify/function-call.mjs
var timer;
var instance;
var parseOptions = (message) => isObject(message) ? message : { message };
function initInstance() {
	({instance} = mountComponent({ setup() {
		const { state, toggle } = usePopupState();
		return () => createVNode(stdin_default$44, mergeProps(state, { "onUpdate:show": toggle }), null);
	} }));
}
var 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
});
var currentOptions = getDefaultOptions();
var 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;
}
var setNotifyDefaultOptions = (options) => extend(currentOptions, options);
var resetNotifyDefaultOptions = () => {
	currentOptions = getDefaultOptions();
};

//#endregion
//#region node_modules/vant/es/notify/index.mjs
var Notify = withInstall(stdin_default$44);

//#endregion
//#region node_modules/vant/es/number-keyboard/NumberKeyboardKey.mjs
var [name$33, bem$32] = createNamespace("key");
var CollapseIcon = createVNode("svg", {
	"class": bem$32("collapse-icon"),
	"viewBox": "0 0 30 24"
}, [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)]);
var DeleteIcon = createVNode("svg", {
	"class": bem$32("delete-icon"),
	"viewBox": "0 0 32 22"
}, [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$43 = defineComponent({
	name: name$33,
	props: {
		type: String,
		text: numericProp,
		color: String,
		wider: Boolean,
		large: Boolean,
		loading: Boolean
	},
	emits: ["press"],
	setup(props$1, { emit, slots }) {
		const active = 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$1.text, props$1.type);
			}
		};
		const renderContent = () => {
			if (props$1.loading) return createVNode(Loading, { "class": bem$32("loading-icon") }, null);
			const text = slots.default ? slots.default() : props$1.text;
			switch (props$1.type) {
				case "delete": return text || DeleteIcon;
				case "extra": return text || CollapseIcon;
				default: return text;
			}
		};
		return () => createVNode("div", {
			"class": bem$32("wrapper", { wider: props$1.wider }),
			"onTouchstartPassive": onTouchStart,
			"onTouchmovePassive": onTouchMove,
			"onTouchend": onTouchEnd,
			"onTouchcancel": onTouchEnd
		}, [createVNode("div", {
			"role": "button",
			"tabindex": 0,
			"class": bem$32([props$1.color, {
				large: props$1.large,
				active: active.value,
				delete: props$1.type === "delete"
			}])
		}, [renderContent()])]);
	}
});

//#endregion
//#region node_modules/vant/es/number-keyboard/NumberKeyboard.mjs
var [name$32, bem$31] = createNamespace("number-keyboard");
var 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$42 = defineComponent({
	name: name$32,
	inheritAttrs: false,
	props: numberKeyboardProps,
	emits: [
		"show",
		"hide",
		"blur",
		"input",
		"close",
		"delete",
		"update:modelValue"
	],
	setup(props$1, { emit, slots, attrs }) {
		const root = ref();
		const genBasicKeys = () => {
			const keys2 = Array(9).fill("").map((_, i) => ({ text: i + 1 }));
			if (props$1.randomKeyOrder) shuffle(keys2);
			return keys2;
		};
		const genDefaultKeys = () => [
			...genBasicKeys(),
			{
				text: props$1.extraKey,
				type: "extra"
			},
			{ text: 0 },
			{
				text: props$1.showDeleteKey ? props$1.deleteButtonText : "",
				type: props$1.showDeleteKey ? "delete" : ""
			}
		];
		const genCustomKeys = () => {
			const keys2 = genBasicKeys();
			const { extraKey } = props$1;
			const extraKeys = Array.isArray(extraKey) ? extraKey : [extraKey];
			if (extraKeys.length === 0) keys2.push({
				text: 0,
				wider: true
			});
			else 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 = computed(() => props$1.theme === "custom" ? genCustomKeys() : genDefaultKeys());
		const onBlur = () => {
			if (props$1.show) emit("blur");
		};
		const onClose = () => {
			emit("close");
			if (props$1.blurOnClose) onBlur();
		};
		const onAnimationEnd = () => emit(props$1.show ? "show" : "hide");
		const onPress = (text, type) => {
			if (text === "") {
				if (type === "extra") onBlur();
				return;
			}
			const value = props$1.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$1.maxlength) {
				emit("input", text);
				emit("update:modelValue", value + text);
			}
		};
		const renderTitle = () => {
			const { title, theme, closeButtonText } = props$1;
			const leftSlot = slots["title-left"];
			const showClose = closeButtonText && theme === "default";
			if (!(title || showClose || leftSlot)) return;
			return createVNode("div", { "class": bem$31("header") }, [
				leftSlot && createVNode("span", { "class": bem$31("title-left") }, [leftSlot()]),
				title && createVNode("h2", { "class": bem$31("title") }, [title]),
				showClose && createVNode("button", {
					"type": "button",
					"class": [bem$31("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 createVNode(stdin_default$43, {
				"key": key.text,
				"text": key.text,
				"type": key.type,
				"wider": key.wider,
				"color": key.color,
				"onPress": onPress
			}, keySlots);
		});
		const renderSidebar = () => {
			if (props$1.theme === "custom") return createVNode("div", { "class": bem$31("sidebar") }, [props$1.showDeleteKey && createVNode(stdin_default$43, {
				"large": true,
				"text": props$1.deleteButtonText,
				"type": "delete",
				"onPress": onPress
			}, { default: slots.delete }), createVNode(stdin_default$43, {
				"large": true,
				"text": props$1.closeButtonText,
				"type": "close",
				"color": "blue",
				"loading": props$1.closeButtonLoading,
				"onPress": onPress
			}, null)]);
		};
		watch(() => props$1.show, (value) => {
			if (!props$1.transition) emit(value ? "show" : "hide");
		});
		if (props$1.hideOnClickOutside) useClickAway(root, onBlur, { eventName: "touchstart" });
		return () => {
			const Title = renderTitle();
			const Content = createVNode(Transition, { "name": props$1.transition ? "van-slide-up" : "" }, { default: () => [withDirectives(createVNode("div", mergeProps({
				"ref": root,
				"style": getZIndexStyle(props$1.zIndex),
				"class": bem$31({
					unfit: !props$1.safeAreaInsetBottom,
					"with-title": !!Title
				}),
				"onAnimationend": onAnimationEnd,
				"onTouchstartPassive": stopPropagation
			}, attrs), [Title, createVNode("div", { "class": bem$31("body") }, [createVNode("div", { "class": bem$31("keys") }, [renderKeys()]), renderSidebar()])]), [[vShow, props$1.show]])] });
			if (props$1.teleport) return createVNode(Teleport, { "to": props$1.teleport }, { default: () => [Content] });
			return Content;
		};
	}
});

//#endregion
//#region node_modules/vant/es/number-keyboard/index.mjs
var NumberKeyboard = withInstall(stdin_default$42);

//#endregion
//#region node_modules/vant/es/pagination/Pagination.mjs
var [name$31, bem$30, t$6] = createNamespace("pagination");
var makePage = (number, text, active) => ({
	number,
	text,
	active
});
var 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,
	showPrevButton: truthProp,
	showNextButton: truthProp
};
var stdin_default$41 = defineComponent({
	name: name$31,
	props: paginationProps,
	emits: ["change", "update:modelValue"],
	setup(props$1, { emit, slots }) {
		const count = computed(() => {
			const { pageCount, totalItems, itemsPerPage } = props$1;
			const count2 = +pageCount || Math.ceil(+totalItems / +itemsPerPage);
			return Math.max(1, count2);
		});
		const pages = computed(() => {
			const items = [];
			const pageCount = count.value;
			const showPageSize = +props$1.showPageSize;
			const { modelValue, forceEllipses } = props$1;
			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$1.modelValue !== value) {
				emit("update:modelValue", value);
				if (emitChange) emit("change", value);
			}
		};
		watchEffect(() => updateModelValue(props$1.modelValue));
		const renderDesc = () => createVNode("li", { "class": bem$30("page-desc") }, [slots.pageDesc ? slots.pageDesc() : `${props$1.modelValue}/${count.value}`]);
		const renderPrevButton = () => {
			const { mode, modelValue, showPrevButton } = props$1;
			if (!showPrevButton) return;
			const slot = slots["prev-text"];
			const disabled = modelValue === 1;
			return createVNode("li", { "class": [bem$30("item", {
				disabled,
				border: mode === "simple",
				prev: true
			}), BORDER_SURROUND] }, [createVNode("button", {
				"type": "button",
				"disabled": disabled,
				"onClick": () => updateModelValue(modelValue - 1, true)
			}, [slot ? slot() : props$1.prevText || t$6("prev")])]);
		};
		const renderNextButton = () => {
			const { mode, modelValue, showNextButton } = props$1;
			if (!showNextButton) return;
			const slot = slots["next-text"];
			const disabled = modelValue === count.value;
			return createVNode("li", { "class": [bem$30("item", {
				disabled,
				border: mode === "simple",
				next: true
			}), BORDER_SURROUND] }, [createVNode("button", {
				"type": "button",
				"disabled": disabled,
				"onClick": () => updateModelValue(modelValue + 1, true)
			}, [slot ? slot() : props$1.nextText || t$6("next")])]);
		};
		const renderPages = () => pages.value.map((page) => createVNode("li", { "class": [bem$30("item", {
			active: page.active,
			page: true
		}), BORDER_SURROUND] }, [createVNode("button", {
			"type": "button",
			"aria-current": page.active || void 0,
			"onClick": () => updateModelValue(page.number, true)
		}, [slots.page ? slots.page(page) : page.text])]));
		return () => createVNode("nav", {
			"role": "navigation",
			"class": bem$30()
		}, [createVNode("ul", { "class": bem$30("items") }, [
			renderPrevButton(),
			props$1.mode === "simple" ? renderDesc() : renderPages(),
			renderNextButton()
		])]);
	}
});

//#endregion
//#region node_modules/vant/es/pagination/index.mjs
var Pagination = withInstall(stdin_default$41);

//#endregion
//#region node_modules/vant/es/password-input/PasswordInput.mjs
var [name$30, bem$29] = createNamespace("password-input");
var passwordInputProps = {
	info: String,
	mask: truthProp,
	value: makeStringProp(""),
	gutter: numericProp,
	length: makeNumericProp(6),
	focused: Boolean,
	errorInfo: String
};
var stdin_default$40 = defineComponent({
	name: name$30,
	props: passwordInputProps,
	emits: ["focus"],
	setup(props$1, { emit }) {
		const onTouchStart = (event) => {
			event.stopPropagation();
			emit("focus", event);
		};
		const renderPoints = () => {
			const Points = [];
			const { mask, value, gutter, focused } = props$1;
			const length = +props$1.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(createVNode("li", {
					"class": [{ [BORDER_LEFT]: showBorder }, bem$29("item", { focus: showCursor })],
					"style": style
				}, [mask ? createVNode("i", { "style": { visibility: char ? "visible" : "hidden" } }, null) : char, showCursor && createVNode("div", { "class": bem$29("cursor") }, null)]));
			}
			return Points;
		};
		return () => {
			const info = props$1.errorInfo || props$1.info;
			return createVNode("div", { "class": bem$29() }, [createVNode("ul", {
				"class": [bem$29("security"), { [BORDER_SURROUND]: !props$1.gutter }],
				"onTouchstartPassive": onTouchStart
			}, [renderPoints()]), info && createVNode("div", { "class": bem$29(props$1.errorInfo ? "error-info" : "info") }, [info])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/password-input/index.mjs
var PasswordInput = withInstall(stdin_default$40);

//#endregion
//#region node_modules/vant/es/picker-group/index.mjs
var PickerGroup = withInstall(stdin_default$39);

//#endregion
//#region node_modules/@vant/popperjs/dist/index.esm.mjs
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) {
	return node instanceof getWindow(node).Element || node instanceof Element;
}
function isHTMLElement(node) {
	return node instanceof getWindow(node).HTMLElement || node instanceof HTMLElement;
}
function isShadowRoot(node) {
	if (typeof ShadowRoot === "undefined") return false;
	return node instanceof getWindow(node).ShadowRoot || 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 visualViewport = (isElement(element) ? getWindow(element) : window).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 width$1 = clientRect.width / scaleX;
	var height$1 = clientRect.height / scaleY;
	return {
		width: width$1,
		height: height$1,
		top: y,
		right: x + width$1,
		bottom: y + height$1,
		left: x,
		x,
		y
	};
}
function getWindowScroll(node) {
	var win = getWindow(node);
	return {
		scrollLeft: win.pageXOffset,
		scrollTop: win.pageYOffset
	};
}
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 : 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" || 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 width$1 = element.offsetWidth;
	var height$1 = element.offsetHeight;
	if (Math.abs(clientRect.width - width$1) <= 1) width$1 = clientRect.width;
	if (Math.abs(clientRect.height - height$1) <= 1) height$1 = clientRect.height;
	return {
		x: element.offsetLeft,
		y: element.offsetTop,
		width: width$1,
		height: height$1
	};
}
function getParentNode(element) {
	if (getNodeName(element) === "html") return element;
	return element.assignedSlot || element.parentNode || (isShadowRoot(element) ? element.host : null) || getDocumentElement(element);
}
function getScrollParent$1(node) {
	if ([
		"html",
		"body",
		"#document"
	].indexOf(getNodeName(node)) >= 0) return node.ownerDocument.body;
	if (isHTMLElement(node) && isScrollParent(node)) return node;
	return getScrollParent$1(getParentNode(node));
}
function listScrollParents(element, list) {
	var _element$ownerDocumen;
	if (list === void 0) list = [];
	var scrollParent = getScrollParent$1(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 : updatedList.concat(listScrollParents(getParentNode(target)));
}
function isTableElement(element) {
	return [
		"table",
		"td",
		"th"
	].indexOf(getNodeName(element)) >= 0;
}
function getTrueOffsetParent(element) {
	if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") return null;
	return element.offsetParent;
}
function getContainingBlock(element) {
	var isFirefox = /firefox/i.test(getUAString());
	if (/Trident/i.test(getUAString()) && isHTMLElement(element)) {
		if (getComputedStyle(element).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 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);
		[].concat(modifier.requires || [], modifier.requiresIfExists || []).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, self) {
			return self.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, current$1) {
		var existing = merged2[current$1.name];
		merged2[current$1.name] = existing ? Object.assign({}, existing, current$1, {
			options: Object.assign({}, existing.options, current$1.options),
			data: Object.assign({}, existing.data, current$1.data)
		}) : current$1;
		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;
			default:
		}
	}
	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, defaultOptions$2 = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
	return function createPopper2(reference, popper, options) {
		if (options === void 0) options = defaultOptions$2;
		var state = {
			placement: "bottom",
			orderedModifiers: [],
			options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions$2),
			modifiersData: {},
			elements: {
				reference,
				popper
			},
			attributes: {},
			styles: {}
		};
		var effectCleanupFns = [];
		var isDestroyed = false;
		var instance$3 = {
			state,
			setOptions: function setOptions(setOptionsAction) {
				var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
				cleanupModifierEffects();
				state.options = Object.assign({}, defaultOptions$2, 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;
				});
				validateModifiers(uniqueBy([].concat(orderedModifiers, state.options.modifiers), function(_ref) {
					return _ref.name;
				}));
				if (getBasePlacement(state.options.placement) === auto) {
					if (!state.orderedModifiers.find(function(_ref2) {
						return _ref2.name === "flip";
					})) console.error(["Popper: \"auto\" placements require the \"flip\" modifier be", "present and enabled to work."].join(" "));
				}
				var _getComputedStyle = getComputedStyle(popper);
				if ([
					_getComputedStyle.marginTop,
					_getComputedStyle.marginRight,
					_getComputedStyle.marginBottom,
					_getComputedStyle.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 instance$3.update();
			},
			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, name$111 = _state$orderedModifie.name;
					if (typeof fn2 === "function") state = fn2({
						state,
						options: _options,
						name: name$111,
						instance: instance$3
					}) || state;
				}
			},
			update: debounce(function() {
				return new Promise(function(resolve) {
					instance$3.forceUpdate();
					resolve(state);
				});
			}),
			destroy: function destroy() {
				cleanupModifierEffects();
				isDestroyed = true;
			}
		};
		if (!areValidElements(reference, popper)) {
			console.error(INVALID_ELEMENT_ERROR);
			return instance$3;
		}
		instance$3.setOptions(options).then(function(state2) {
			if (!isDestroyed && options.onFirstUpdate) options.onFirstUpdate(state2);
		});
		function runModifierEffects() {
			state.orderedModifiers.forEach(function(_ref3) {
				var name$111 = _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: name$111,
						instance: instance$3,
						options: options2
					});
					effectCleanupFns.push(cleanupFn || function noopFn2() {});
				}
			});
		}
		function cleanupModifierEffects() {
			effectCleanupFns.forEach(function(fn2) {
				return fn2();
			});
			effectCleanupFns = [];
		}
		return instance$3;
	};
}
var passive = { passive: true };
function effect(_ref) {
	var state = _ref.state, instance$3 = _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", instance$3.update, passive);
	});
	if (resize) window2.addEventListener("resize", instance$3.update, passive);
	return function() {
		if (scroll) scrollParents.forEach(function(scrollParent) {
			scrollParent.removeEventListener("scroll", instance$3.update, passive);
		});
		if (resize) window2.removeEventListener("resize", instance$3.update, passive);
	};
}
var eventListeners_default = {
	name: "eventListeners",
	enabled: true,
	phase: "write",
	fn: function fn() {},
	effect,
	data: {}
};
function popperOffsets(_ref) {
	var state = _ref.state, name$111 = _ref.name;
	state.modifiersData[name$111] = 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 dpr = window.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 : 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 : 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(name$111) {
		var style = state.styles[name$111] || {};
		var attributes = state.attributes[name$111] || {};
		var element = state.elements[name$111];
		if (!isHTMLElement(element) || !getNodeName(element)) return;
		Object.assign(element.style, style);
		Object.keys(attributes).forEach(function(name2) {
			var value = attributes[name2];
			if (value === false) element.removeAttribute(name2);
			else element.setAttribute(name2, 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(name$111) {
			var element = state.elements[name$111];
			var attributes = state.attributes[name$111] || {};
			var style = Object.keys(state.styles.hasOwnProperty(name$111) ? state.styles[name$111] : initialStyles[name$111]).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 createPopper = /* @__PURE__ */ popperGenerator({ defaultModifiers: [
	eventListeners_default,
	popperOffsets_default,
	computeStyles_default,
	{
		name: "applyStyles",
		enabled: true,
		phase: "write",
		fn: applyStyles,
		effect: effect2,
		requires: ["computeStyles"]
	}
] });
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, name$111 = _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[name$111] = data;
}
var offset_default = {
	name: "offset",
	enabled: true,
	phase: "main",
	requires: ["popperOffsets"],
	fn: offset
};

//#endregion
//#region node_modules/vant/es/popover/Popover.mjs
var [name$29, bem$28] = createNamespace("popover");
var popupProps = [
	"overlay",
	"duration",
	"teleport",
	"overlayStyle",
	"overlayClass",
	"closeOnClickOverlay"
];
var popoverProps = {
	show: Boolean,
	theme: makeStringProp("light"),
	overlay: Boolean,
	actions: makeArrayProp(),
	actionsDirection: makeStringProp("vertical"),
	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$38 = defineComponent({
	name: name$29,
	props: popoverProps,
	emits: [
		"select",
		"touchstart",
		"update:show"
	],
	setup(props$1, { emit, slots, attrs }) {
		let popper;
		const popupRef = ref();
		const wrapperRef = ref();
		const popoverRef = ref();
		const show = useSyncPropRef(() => props$1.show, (value) => emit("update:show", value));
		const getPopoverOptions = () => ({
			placement: props$1.placement,
			modifiers: [{
				name: "computeStyles",
				options: {
					adaptive: false,
					gpuAcceleration: false
				}
			}, extend({}, offset_default, { options: { offset: props$1.offset } })]
		});
		const createPopperInstance = () => {
			if (wrapperRef.value && popoverRef.value) return createPopper(wrapperRef.value, popoverRef.value.popupRef.value, getPopoverOptions());
			return null;
		};
		const updateLocation = () => {
			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$1.trigger === "click") show.value = !show.value;
		};
		const onClickAction = (action, index) => {
			if (action.disabled) return;
			emit("select", action, index);
			if (props$1.closeOnClickAction) show.value = false;
		};
		const onClickAway = () => {
			if (show.value && props$1.closeOnClickOutside && (!props$1.overlay || props$1.closeOnClickOverlay)) show.value = false;
		};
		const renderActionContent = (action, index) => {
			if (slots.action) return slots.action({
				action,
				index
			});
			return [action.icon && createVNode(Icon, {
				"name": action.icon,
				"classPrefix": props$1.iconPrefix,
				"class": bem$28("action-icon")
			}, null), createVNode("div", { "class": [bem$28("action-text"), { [BORDER_BOTTOM]: props$1.actionsDirection === "vertical" }] }, [action.text])];
		};
		const renderAction = (action, index) => {
			const { icon, color, disabled, className } = action;
			return createVNode("div", {
				"role": "menuitem",
				"class": [
					bem$28("action", {
						disabled,
						"with-icon": icon
					}),
					{ [BORDER_RIGHT]: props$1.actionsDirection === "horizontal" },
					className
				],
				"style": { color },
				"tabindex": disabled ? void 0 : 0,
				"aria-disabled": disabled || void 0,
				"onClick": () => onClickAction(action, index)
			}, [renderActionContent(action, index)]);
		};
		onMounted(() => {
			updateLocation();
			watchEffect(() => {
				var _a;
				popupRef.value = (_a = popoverRef.value) == null ? void 0 : _a.popupRef.value;
			});
		});
		onBeforeUnmount(() => {
			if (popper) {
				if (inBrowser$1) {
					window.removeEventListener("animationend", updateLocation);
					window.removeEventListener("transitionend", updateLocation);
				}
				popper.destroy();
				popper = null;
			}
		});
		watch(() => [
			show.value,
			props$1.offset,
			props$1.placement
		], updateLocation);
		useClickAway([wrapperRef, popupRef], onClickAway, { eventName: "touchstart" });
		return () => {
			var _a;
			return createVNode(Fragment, null, [createVNode("span", {
				"ref": wrapperRef,
				"class": bem$28("wrapper"),
				"onClick": onClickWrapper
			}, [(_a = slots.reference) == null ? void 0 : _a.call(slots)]), createVNode(Popup, mergeProps({
				"ref": popoverRef,
				"show": show.value,
				"class": bem$28([props$1.theme]),
				"position": "",
				"transition": "van-popover-zoom",
				"lockScroll": false,
				"onUpdate:show": updateShow
			}, attrs, useScopeId(), pick(props$1, popupProps)), { default: () => [props$1.showArrow && createVNode("div", { "class": bem$28("arrow") }, null), createVNode("div", {
				"role": "menu",
				"class": bem$28("content", props$1.actionsDirection)
			}, [slots.default ? slots.default() : props$1.actions.map(renderAction)])] })]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/popover/index.mjs
var Popover = withInstall(stdin_default$38);

//#endregion
//#region node_modules/vant/es/progress/Progress.mjs
var [name$28, bem$27] = createNamespace("progress");
var 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$37 = defineComponent({
	name: name$28,
	props: progressProps,
	setup(props$1) {
		const background = computed(() => props$1.inactive ? void 0 : props$1.color);
		const format$2 = (rate) => Math.min(Math.max(+rate, 0), 100);
		const renderPivot = () => {
			const { textColor, pivotText, pivotColor, percentage } = props$1;
			const safePercentage = format$2(percentage);
			const text = pivotText != null ? pivotText : `${percentage}%`;
			if (props$1.showPivot && text) {
				const style = {
					color: textColor,
					left: `${safePercentage}%`,
					transform: `translate(-${safePercentage}%,-50%)`,
					background: pivotColor || background.value
				};
				return createVNode("span", {
					"style": style,
					"class": bem$27("pivot", { inactive: props$1.inactive })
				}, [text]);
			}
		};
		return () => {
			const { trackColor, percentage, strokeWidth } = props$1;
			const safePercentage = format$2(percentage);
			const rootStyle = {
				background: trackColor,
				height: addUnit(strokeWidth)
			};
			const portionStyle = {
				width: `${safePercentage}%`,
				background: background.value
			};
			return createVNode("div", {
				"class": bem$27(),
				"style": rootStyle
			}, [createVNode("span", {
				"class": bem$27("portion", { inactive: props$1.inactive }),
				"style": portionStyle
			}, null), renderPivot()]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/progress/index.mjs
var Progress = withInstall(stdin_default$37);

//#endregion
//#region node_modules/vant/es/pull-refresh/PullRefresh.mjs
var [name$27, bem$26, t$5] = createNamespace("pull-refresh");
var DEFAULT_HEAD_HEIGHT = 50;
var TEXT_STATUS = [
	"pulling",
	"loosing",
	"success"
];
var 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$36 = defineComponent({
	name: name$27,
	props: pullRefreshProps,
	emits: [
		"change",
		"refresh",
		"update:modelValue"
	],
	setup(props$1, { emit, slots }) {
		let reachTop;
		const root = ref();
		const track = ref();
		const scrollParent = useScrollParent(root);
		const state = reactive({
			status: "normal",
			distance: 0,
			duration: 0
		});
		const touch = useTouch();
		const getHeadStyle = () => {
			if (props$1.headHeight !== DEFAULT_HEAD_HEIGHT) return { height: `${props$1.headHeight}px` };
		};
		const isTouchable = () => state.status !== "loading" && state.status !== "success" && !props$1.disabled;
		const ease = (distance) => {
			const pullDistance = +(props$1.pullDistance || props$1.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$1.pullDistance || props$1.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$1[`${status}Text`] || t$5(status);
		};
		const renderStatus = () => {
			const { status, distance } = state;
			if (slots[status]) return slots[status]({ distance });
			const nodes = [];
			if (TEXT_STATUS.includes(status)) nodes.push(createVNode("div", { "class": bem$26("text") }, [getStatusText()]));
			if (status === "loading") nodes.push(createVNode(Loading, { "class": bem$26("loading") }, { default: getStatusText }));
			return nodes;
		};
		const showSuccessTip = () => {
			state.status = "success";
			setTimeout(() => {
				setStatus(0);
			}, +props$1.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$1.animationDuration;
				if (state.status === "loosing") {
					setStatus(+props$1.headHeight, true);
					emit("update:modelValue", true);
					nextTick(() => emit("refresh"));
				} else setStatus(0);
			}
		};
		watch(() => props$1.modelValue, (value) => {
			state.duration = +props$1.animationDuration;
			if (value) setStatus(+props$1.headHeight, true);
			else if (slots.success || props$1.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 createVNode("div", {
				"ref": root,
				"class": bem$26()
			}, [createVNode("div", {
				"ref": track,
				"class": bem$26("track"),
				"style": trackStyle,
				"onTouchstartPassive": onTouchStart,
				"onTouchend": onTouchEnd,
				"onTouchcancel": onTouchEnd
			}, [createVNode("div", {
				"class": bem$26("head"),
				"style": getHeadStyle()
			}, [renderStatus()]), (_a = slots.default) == null ? void 0 : _a.call(slots)])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/pull-refresh/index.mjs
var PullRefresh = withInstall(stdin_default$36);

//#endregion
//#region node_modules/vant/es/rate/Rate.mjs
var [name$26, bem$25] = createNamespace("rate");
function getRateStatus(value, index, allowHalf, readonly) {
	if (value >= index) return {
		status: "full",
		value: 1
	};
	if (value + .5 >= index && allowHalf && !readonly) return {
		status: "half",
		value: .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
	};
}
var rateProps = {
	size: numericProp,
	icon: makeStringProp("star"),
	color: String,
	count: makeNumericProp(5),
	gutter: numericProp,
	clearable: Boolean,
	readonly: Boolean,
	disabled: Boolean,
	voidIcon: makeStringProp("star-o"),
	allowHalf: Boolean,
	voidColor: String,
	touchable: truthProp,
	iconPrefix: String,
	modelValue: makeNumberProp(0),
	disabledColor: String
};
var stdin_default$35 = defineComponent({
	name: name$26,
	props: rateProps,
	emits: ["change", "update:modelValue"],
	setup(props$1, { emit }) {
		const touch = useTouch();
		const [itemRefs, setItemRefs] = useRefs();
		const groupRef = ref();
		const unselectable = computed(() => props$1.readonly || props$1.disabled);
		const untouchable = computed(() => unselectable.value || !props$1.touchable);
		const list = computed(() => Array(+props$1.count).fill("").map((_, i) => getRateStatus(props$1.modelValue, i + 1, props$1.allowHalf, props$1.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$1.allowHalf) ranges.push({
					score: index + .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$1.allowHalf ? .5 : 1;
		};
		const select = (value) => {
			if (unselectable.value || value === props$1.modelValue) return;
			emit("update:modelValue", value);
			emit("change", value);
		};
		const onTouchStart = (event) => {
			if (untouchable.value) return;
			touch.start(event);
			updateRanges();
		};
		const onTouchMove = (event) => {
			if (untouchable.value) return;
			touch.move(event);
			if (touch.isHorizontal() && !touch.isTap.value) {
				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$1;
			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();
				let value = allowHalf ? getScoreByPosition(event.clientX, event.clientY) : score;
				if (props$1.clearable && touch.isTap.value && value === props$1.modelValue) value = 0;
				select(value);
			};
			return createVNode("div", {
				"key": index,
				"ref": setItemRefs(index),
				"role": "radio",
				"style": style,
				"class": bem$25("item"),
				"tabindex": disabled ? void 0 : 0,
				"aria-setsize": count,
				"aria-posinset": score,
				"aria-checked": !isVoid,
				"onClick": onClickItem
			}, [createVNode(Icon, {
				"size": size,
				"name": isFull ? icon : voidIcon,
				"class": bem$25("icon", {
					disabled,
					full: isFull
				}),
				"color": disabled ? disabledColor : isFull ? color : voidColor,
				"classPrefix": iconPrefix
			}, null), renderHalf && createVNode(Icon, {
				"size": size,
				"style": { width: item.value + "em" },
				"name": isVoid ? voidIcon : icon,
				"class": bem$25("icon", ["half", {
					disabled,
					full: !isVoid
				}]),
				"color": disabled ? disabledColor : isVoid ? voidColor : color,
				"classPrefix": iconPrefix
			}, null)]);
		};
		useCustomFieldValue(() => props$1.modelValue);
		useEventListener("touchmove", onTouchMove, { target: groupRef });
		return () => createVNode("div", {
			"ref": groupRef,
			"role": "radiogroup",
			"class": bem$25({
				readonly: props$1.readonly,
				disabled: props$1.disabled
			}),
			"tabindex": props$1.disabled ? void 0 : 0,
			"aria-disabled": props$1.disabled,
			"aria-readonly": props$1.readonly,
			"onTouchstartPassive": onTouchStart
		}, [list.value.map(renderStar)]);
	}
});

//#endregion
//#region node_modules/vant/es/rate/index.mjs
var Rate = withInstall(stdin_default$35);

//#endregion
//#region node_modules/vant/es/rolling-text/RollingTextItem.mjs
var props = {
	figureArr: makeArrayProp(),
	delay: Number,
	duration: makeNumberProp(2),
	isStart: Boolean,
	direction: makeStringProp("down"),
	height: makeNumberProp(40)
};
var [name$25, bem$24] = createNamespace("rolling-text-item");
var stdin_default$34 = defineComponent({
	name: name$25,
	props,
	setup(props2) {
		const newFigureArr = computed(() => props2.direction === "down" ? props2.figureArr.slice().reverse() : props2.figureArr);
		const translatePx = computed(() => {
			return `-${props2.height * (props2.figureArr.length - 1)}px`;
		});
		const itemStyle = computed(() => ({ lineHeight: addUnit(props2.height) }));
		const rootStyle = computed(() => ({
			height: addUnit(props2.height),
			"--van-translate": translatePx.value,
			"--van-duration": props2.duration + "s",
			"--van-delay": props2.delay + "s"
		}));
		return () => createVNode("div", {
			"class": bem$24([props2.direction]),
			"style": rootStyle.value
		}, [createVNode("div", { "class": bem$24("box", { animate: props2.isStart }) }, [Array.isArray(newFigureArr.value) && newFigureArr.value.map((figure) => createVNode("div", {
			"class": bem$24("item"),
			"style": itemStyle.value
		}, [figure]))])]);
	}
});

//#endregion
//#region node_modules/vant/es/rolling-text/RollingText.mjs
var [name$24, bem$23] = createNamespace("rolling-text");
var rollingTextProps = {
	startNum: makeNumberProp(0),
	targetNum: Number,
	textList: makeArrayProp(),
	duration: makeNumberProp(2),
	autoStart: truthProp,
	direction: makeStringProp("down"),
	stopOrder: makeStringProp("ltr"),
	height: makeNumberProp(40)
};
var CIRCLE_NUM = 2;
var stdin_default$33 = defineComponent({
	name: name$24,
	props: rollingTextProps,
	setup(props$1) {
		const isCustomType = computed(() => Array.isArray(props$1.textList) && props$1.textList.length);
		const itemLength = computed(() => {
			if (isCustomType.value) return props$1.textList[0].length;
			return `${Math.max(props$1.startNum, props$1.targetNum)}`.length;
		});
		const getTextArrByIdx = (idx) => {
			const result = [];
			for (let i = 0; i < props$1.textList.length; i++) result.push(props$1.textList[i][idx]);
			return result;
		};
		const targetNumArr = computed(() => {
			if (isCustomType.value) return new Array(itemLength.value).fill("");
			return padZero(props$1.targetNum, itemLength.value).split("");
		});
		const startNumArr = computed(() => padZero(props$1.startNum, itemLength.value).split(""));
		const getFigureArr = (i) => {
			const start2 = +startNumArr.value[i];
			const target = +targetNumArr.value[i];
			const result = [];
			for (let i2 = start2; i2 <= 9; i2++) result.push(i2);
			for (let i2 = 0; i2 <= CIRCLE_NUM; i2++) for (let j = 0; j <= 9; j++) result.push(j);
			for (let i2 = 0; i2 <= target; i2++) result.push(i2);
			return result;
		};
		const getDelay = (i, len) => {
			if (props$1.stopOrder === "ltr") return .2 * i;
			return .2 * (len - 1 - i);
		};
		const rolling = ref(props$1.autoStart);
		const start$1 = () => {
			rolling.value = true;
		};
		const reset = () => {
			rolling.value = false;
			if (props$1.autoStart) raf(() => start$1());
		};
		watch(() => props$1.autoStart, (value) => {
			if (value) start$1();
		});
		useExpose({
			start: start$1,
			reset
		});
		return () => createVNode("div", { "class": bem$23() }, [targetNumArr.value.map((_, i) => createVNode(stdin_default$34, {
			"figureArr": isCustomType.value ? getTextArrByIdx(i) : getFigureArr(i),
			"duration": props$1.duration,
			"direction": props$1.direction,
			"isStart": rolling.value,
			"height": props$1.height,
			"delay": getDelay(i, itemLength.value)
		}, null))]);
	}
});

//#endregion
//#region node_modules/vant/es/rolling-text/index.mjs
var RollingText = withInstall(stdin_default$33);

//#endregion
//#region node_modules/vant/es/row/index.mjs
var Row = withInstall(stdin_default$32);

//#endregion
//#region node_modules/vant/es/search/Search.mjs
var [name$23, bem$22, t$4] = createNamespace("search");
var searchProps = extend({}, fieldSharedProps, {
	label: String,
	shape: makeStringProp("square"),
	leftIcon: makeStringProp("search"),
	clearable: truthProp,
	actionText: String,
	background: String,
	showAction: Boolean
});
var stdin_default$31 = defineComponent({
	name: name$23,
	props: searchProps,
	emits: [
		"blur",
		"focus",
		"clear",
		"search",
		"cancel",
		"clickInput",
		"clickLeftIcon",
		"clickRightIcon",
		"update:modelValue"
	],
	setup(props$1, { emit, slots, attrs }) {
		const id = useId();
		const fieldRef = ref();
		const onCancel = () => {
			if (!slots.action) {
				emit("update:modelValue", "");
				emit("cancel");
			}
		};
		const onKeypress = (event) => {
			if (event.keyCode === 13) {
				preventDefault(event);
				emit("search", props$1.modelValue);
			}
		};
		const getInputId = () => props$1.id || `${id}-input`;
		const renderLabel = () => {
			if (slots.label || props$1.label) return createVNode("label", {
				"class": bem$22("label"),
				"for": getInputId(),
				"data-allow-mismatch": "attribute"
			}, [slots.label ? slots.label() : props$1.label]);
		};
		const renderAction = () => {
			if (props$1.showAction) {
				const text = props$1.actionText || t$4("cancel");
				return createVNode("div", {
					"class": bem$22("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$1, fieldPropNames), { id: getInputId() });
			const onInput = (value) => emit("update:modelValue", value);
			return createVNode(Field, mergeProps({
				"ref": fieldRef,
				"type": "search",
				"class": bem$22("field", { "with-message": fieldAttrs.errorMessage }),
				"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 createVNode("div", {
				"class": bem$22({ "show-action": props$1.showAction }),
				"style": { background: props$1.background }
			}, [
				(_a = slots.left) == null ? void 0 : _a.call(slots),
				createVNode("div", { "class": bem$22("content", props$1.shape) }, [renderLabel(), renderField()]),
				renderAction()
			]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/search/index.mjs
var Search = withInstall(stdin_default$31);

//#endregion
//#region node_modules/vant/es/share-sheet/ShareSheet.mjs
var isImage = (name2) => name2 == null ? void 0 : name2.includes("/");
var popupInheritKeys = [
	...popupSharedPropKeys,
	"round",
	"closeOnPopstate",
	"safeAreaInsetBottom"
];
var iconMap = {
	qq: "qq",
	link: "link-o",
	weibo: "weibo",
	qrcode: "qr",
	poster: "photo-o",
	wechat: "wechat",
	"weapp-qrcode": "miniprogram-o",
	"wechat-moments": "wechat-moments"
};
var [name$22, bem$21, t$3] = createNamespace("share-sheet");
var shareSheetProps = extend({}, popupSharedProps, {
	title: String,
	round: truthProp,
	options: makeArrayProp(),
	cancelText: String,
	description: String,
	closeOnPopstate: truthProp,
	safeAreaInsetBottom: truthProp
});
var stdin_default$30 = defineComponent({
	name: name$22,
	props: shareSheetProps,
	emits: [
		"cancel",
		"select",
		"update:show"
	],
	setup(props$1, { 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$1.title;
			const description = slots.description ? slots.description() : props$1.description;
			if (title || description) return createVNode("div", { "class": bem$21("header") }, [title && createVNode("h2", { "class": bem$21("title") }, [title]), description && createVNode("span", { "class": bem$21("description") }, [description])]);
		};
		const renderIcon = (icon) => {
			if (isImage(icon)) return createVNode("img", {
				"src": icon,
				"class": bem$21("image-icon")
			}, null);
			return createVNode("div", { "class": bem$21("icon", [icon]) }, [createVNode(Icon, { "name": iconMap[icon] || icon }, null)]);
		};
		const renderOption = (option, index) => {
			const { name: name2, icon, className, description } = option;
			return createVNode("div", {
				"role": "button",
				"tabindex": 0,
				"class": [
					bem$21("option"),
					className,
					HAPTICS_FEEDBACK
				],
				"onClick": () => onSelect(option, index)
			}, [
				renderIcon(icon),
				name2 && createVNode("span", { "class": bem$21("name") }, [name2]),
				description && createVNode("span", { "class": bem$21("option-description") }, [description])
			]);
		};
		const renderOptions = (options, border) => createVNode("div", { "class": bem$21("options", { border }) }, [options.map(renderOption)]);
		const renderRows = () => {
			const { options } = props$1;
			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$1.cancelText) != null ? _a : t$3("cancel");
			if (slots.cancel || cancelText) return createVNode("button", {
				"type": "button",
				"class": bem$21("cancel"),
				"onClick": onCancel
			}, [slots.cancel ? slots.cancel() : cancelText]);
		};
		return () => createVNode(Popup, mergeProps({
			"class": bem$21(),
			"position": "bottom",
			"onUpdate:show": updateShow
		}, pick(props$1, popupInheritKeys)), { default: () => [
			renderHeader(),
			renderRows(),
			renderCancelButton()
		] });
	}
});

//#endregion
//#region node_modules/vant/es/share-sheet/index.mjs
var ShareSheet = withInstall(stdin_default$30);

//#endregion
//#region node_modules/vant/es/sidebar/Sidebar.mjs
var [name$21, bem$20] = createNamespace("sidebar");
var SIDEBAR_KEY = Symbol(name$21);
var sidebarProps = { modelValue: makeNumericProp(0) };
var stdin_default$29 = defineComponent({
	name: name$21,
	props: sidebarProps,
	emits: ["change", "update:modelValue"],
	setup(props$1, { emit, slots }) {
		const { linkChildren } = useChildren(SIDEBAR_KEY);
		const getActive = () => +props$1.modelValue;
		const setActive = (value) => {
			if (value !== getActive()) {
				emit("update:modelValue", value);
				emit("change", value);
			}
		};
		linkChildren({
			getActive,
			setActive
		});
		return () => {
			var _a;
			return createVNode("div", {
				"role": "tablist",
				"class": bem$20()
			}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/sidebar/index.mjs
var Sidebar = withInstall(stdin_default$29);

//#endregion
//#region node_modules/vant/es/sidebar-item/SidebarItem.mjs
var [name$20, bem$19] = createNamespace("sidebar-item");
var sidebarItemProps = extend({}, routeProps, {
	dot: Boolean,
	title: String,
	badge: numericProp,
	disabled: Boolean,
	badgeProps: Object
});
var stdin_default$28 = defineComponent({
	name: name$20,
	props: sidebarItemProps,
	emits: ["click"],
	setup(props$1, { emit, slots }) {
		const route$1 = useRoute();
		const { parent, index } = useParent(SIDEBAR_KEY);
		if (!parent) {
			console.error("[Vant] <SidebarItem> must be a child component of <Sidebar>.");
			return;
		}
		const onClick = () => {
			if (props$1.disabled) return;
			emit("click", index.value);
			parent.setActive(index.value);
			route$1();
		};
		return () => {
			const { dot, badge, title, disabled } = props$1;
			const selected = index.value === parent.getActive();
			return createVNode("div", {
				"role": "tab",
				"class": bem$19({
					select: selected,
					disabled
				}),
				"tabindex": disabled ? void 0 : 0,
				"aria-selected": selected,
				"onClick": onClick
			}, [createVNode(Badge, mergeProps({
				"dot": dot,
				"class": bem$19("text"),
				"content": badge
			}, props$1.badgeProps), { default: () => [slots.title ? slots.title() : title] })]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/sidebar-item/index.mjs
var SidebarItem = withInstall(stdin_default$28);

//#endregion
//#region node_modules/vant/es/signature/Signature.mjs
var [name$19, bem$18, t$2] = createNamespace("signature");
var signatureProps = {
	tips: String,
	type: makeStringProp("png"),
	penColor: makeStringProp("#000"),
	lineWidth: makeNumberProp(3),
	clearButtonText: String,
	backgroundColor: makeStringProp(""),
	confirmButtonText: String
};
var hasCanvasSupport = () => {
	var _a;
	const canvas = document.createElement("canvas");
	return !!((_a = canvas.getContext) == null ? void 0 : _a.call(canvas, "2d"));
};
var stdin_default$27 = defineComponent({
	name: name$19,
	props: signatureProps,
	emits: [
		"submit",
		"clear",
		"start",
		"end",
		"signing"
	],
	setup(props$1, { emit, slots }) {
		const canvasRef = ref();
		const wrapRef = ref();
		const ctx = computed(() => {
			if (!canvasRef.value) return null;
			return canvasRef.value.getContext("2d");
		});
		const isRenderCanvas = inBrowser$1 ? hasCanvasSupport() : true;
		let canvasWidth = 0;
		let canvasHeight = 0;
		let canvasRect;
		const touchStart = () => {
			if (!ctx.value) return false;
			ctx.value.beginPath();
			ctx.value.lineWidth = props$1.lineWidth;
			ctx.value.strokeStyle = props$1.penColor;
			canvasRect = useRect(canvasRef);
			emit("start");
		};
		const touchMove = (event) => {
			if (!ctx.value) return false;
			preventDefault(event);
			const touch = event.touches[0];
			const mouseX = touch.clientX - ((canvasRect == null ? void 0 : canvasRect.left) || 0);
			const mouseY = touch.clientY - ((canvasRect == null ? void 0 : canvasRect.top) || 0);
			ctx.value.lineCap = "round";
			ctx.value.lineJoin = "round";
			ctx.value.lineTo(mouseX, mouseY);
			ctx.value.stroke();
			emit("signing", event);
		};
		const touchEnd = (event) => {
			preventDefault(event);
			emit("end");
		};
		const isCanvasEmpty = (canvas) => {
			const empty = document.createElement("canvas");
			empty.width = canvas.width;
			empty.height = canvas.height;
			if (props$1.backgroundColor) setCanvasBgColor(empty.getContext("2d"));
			return canvas.toDataURL() === empty.toDataURL();
		};
		const setCanvasBgColor = (ctx2) => {
			if (ctx2 && props$1.backgroundColor) {
				ctx2.fillStyle = props$1.backgroundColor;
				ctx2.fillRect(0, 0, canvasWidth, canvasHeight);
			}
		};
		const submit = () => {
			var _a, _b;
			const canvas = canvasRef.value;
			if (!canvas) return;
			emit("submit", {
				image: isCanvasEmpty(canvas) ? "" : ((_b = (_a = {
					jpg: () => canvas.toDataURL("image/jpeg", .8),
					jpeg: () => canvas.toDataURL("image/jpeg", .8)
				})[props$1.type]) == null ? void 0 : _b.call(_a)) || canvas.toDataURL(`image/${props$1.type}`),
				canvas
			});
		};
		const clear = () => {
			if (ctx.value) {
				ctx.value.clearRect(0, 0, canvasWidth, canvasHeight);
				ctx.value.closePath();
				setCanvasBgColor(ctx.value);
			}
			emit("clear");
		};
		const initialize = () => {
			var _a, _b, _c;
			if (isRenderCanvas && canvasRef.value) {
				const canvas = canvasRef.value;
				const dpr = inBrowser$1 ? window.devicePixelRatio : 1;
				canvasWidth = canvas.width = (((_a = wrapRef.value) == null ? void 0 : _a.offsetWidth) || 0) * dpr;
				canvasHeight = canvas.height = (((_b = wrapRef.value) == null ? void 0 : _b.offsetHeight) || 0) * dpr;
				(_c = ctx.value) == null || _c.scale(dpr, dpr);
				setCanvasBgColor(ctx.value);
			}
		};
		const resize = () => {
			if (ctx.value) {
				const data = ctx.value.getImageData(0, 0, canvasWidth, canvasHeight);
				initialize();
				ctx.value.putImageData(data, 0, 0);
			}
		};
		watch(windowWidth, resize);
		onMounted(initialize);
		useExpose({
			resize,
			clear,
			submit
		});
		return () => createVNode("div", { "class": bem$18() }, [createVNode("div", {
			"class": bem$18("content"),
			"ref": wrapRef
		}, [isRenderCanvas ? createVNode("canvas", {
			"ref": canvasRef,
			"onTouchstartPassive": touchStart,
			"onTouchmove": touchMove,
			"onTouchend": touchEnd
		}, null) : slots.tips ? slots.tips() : createVNode("p", null, [props$1.tips])]), createVNode("div", { "class": bem$18("footer") }, [createVNode(Button, {
			"size": "small",
			"onClick": clear
		}, { default: () => [props$1.clearButtonText || t$2("clear")] }), createVNode(Button, {
			"type": "primary",
			"size": "small",
			"onClick": submit
		}, { default: () => [props$1.confirmButtonText || t$2("confirm")] })])]);
	}
});

//#endregion
//#region node_modules/vant/es/signature/index.mjs
var Signature = withInstall(stdin_default$27);

//#endregion
//#region node_modules/vant/es/skeleton-title/SkeletonTitle.mjs
var [name$18, bem$17] = createNamespace("skeleton-title");
var skeletonTitleProps = {
	round: Boolean,
	titleWidth: numericProp
};
var stdin_default$26 = defineComponent({
	name: name$18,
	props: skeletonTitleProps,
	setup(props$1) {
		return () => createVNode("h3", {
			"class": bem$17([{ round: props$1.round }]),
			"style": { width: addUnit(props$1.titleWidth) }
		}, null);
	}
});

//#endregion
//#region node_modules/vant/es/skeleton-title/index.mjs
var SkeletonTitle = withInstall(stdin_default$26);
var stdin_default$21 = SkeletonTitle;

//#endregion
//#region node_modules/vant/es/skeleton-avatar/SkeletonAvatar.mjs
var [name$17, bem$16] = createNamespace("skeleton-avatar");
var skeletonAvatarProps = {
	avatarSize: numericProp,
	avatarShape: makeStringProp("round")
};
var stdin_default$25 = defineComponent({
	name: name$17,
	props: skeletonAvatarProps,
	setup(props$1) {
		return () => createVNode("div", {
			"class": bem$16([props$1.avatarShape]),
			"style": getSizeStyle(props$1.avatarSize)
		}, null);
	}
});

//#endregion
//#region node_modules/vant/es/skeleton-avatar/index.mjs
var SkeletonAvatar = withInstall(stdin_default$25);
var stdin_default$22 = SkeletonAvatar;

//#endregion
//#region node_modules/vant/es/skeleton-paragraph/SkeletonParagraph.mjs
var DEFAULT_ROW_WIDTH = "100%";
var skeletonParagraphProps = {
	round: Boolean,
	rowWidth: {
		type: numericProp,
		default: DEFAULT_ROW_WIDTH
	}
};
var [name$16, bem$15] = createNamespace("skeleton-paragraph");
var stdin_default$24 = defineComponent({
	name: name$16,
	props: skeletonParagraphProps,
	setup(props$1) {
		return () => createVNode("div", {
			"class": bem$15([{ round: props$1.round }]),
			"style": { width: props$1.rowWidth }
		}, null);
	}
});

//#endregion
//#region node_modules/vant/es/skeleton-paragraph/index.mjs
var SkeletonParagraph = withInstall(stdin_default$24);
var stdin_default$23 = SkeletonParagraph;

//#endregion
//#region node_modules/vant/es/skeleton/Skeleton.mjs
var [name$15, bem$14] = createNamespace("skeleton");
var DEFAULT_LAST_ROW_WIDTH = "60%";
var 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$20 = defineComponent({
	name: name$15,
	inheritAttrs: false,
	props: skeletonProps,
	setup(props$1, { slots, attrs }) {
		const renderAvatar = () => {
			if (props$1.avatar) return createVNode(stdin_default$22, {
				"avatarShape": props$1.avatarShape,
				"avatarSize": props$1.avatarSize
			}, null);
		};
		const renderTitle = () => {
			if (props$1.title) return createVNode(stdin_default$21, {
				"round": props$1.round,
				"titleWidth": props$1.titleWidth
			}, null);
		};
		const getRowWidth = (index) => {
			const { rowWidth } = props$1;
			if (rowWidth === DEFAULT_ROW_WIDTH && index === +props$1.row - 1) return DEFAULT_LAST_ROW_WIDTH;
			if (Array.isArray(rowWidth)) return rowWidth[index];
			return rowWidth;
		};
		const renderRows = () => Array(+props$1.row).fill("").map((_, i) => createVNode(stdin_default$23, {
			"key": i,
			"round": props$1.round,
			"rowWidth": addUnit(getRowWidth(i))
		}, null));
		const renderContents = () => {
			if (slots.template) return slots.template();
			return createVNode(Fragment, null, [renderAvatar(), createVNode("div", { "class": bem$14("content") }, [renderTitle(), renderRows()])]);
		};
		return () => {
			var _a;
			if (!props$1.loading) return (_a = slots.default) == null ? void 0 : _a.call(slots);
			return createVNode("div", mergeProps({ "class": bem$14({
				animate: props$1.animate,
				round: props$1.round
			}) }, attrs), [renderContents()]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/skeleton/index.mjs
var Skeleton = withInstall(stdin_default$20);

//#endregion
//#region node_modules/vant/es/skeleton-image/SkeletonImage.mjs
var [name$14, bem$13] = createNamespace("skeleton-image");
var skeletonImageProps = {
	imageSize: numericProp,
	imageShape: makeStringProp("square")
};
var stdin_default$19 = defineComponent({
	name: name$14,
	props: skeletonImageProps,
	setup(props$1) {
		return () => createVNode("div", {
			"class": bem$13([props$1.imageShape]),
			"style": getSizeStyle(props$1.imageSize)
		}, [createVNode(Icon, {
			"name": "photo",
			"class": bem$13("icon")
		}, null)]);
	}
});

//#endregion
//#region node_modules/vant/es/skeleton-image/index.mjs
var SkeletonImage = withInstall(stdin_default$19);

//#endregion
//#region node_modules/vant/es/slider/Slider.mjs
var [name$13, bem$12] = createNamespace("slider");
var 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$18 = defineComponent({
	name: name$13,
	props: sliderProps,
	emits: [
		"change",
		"dragEnd",
		"dragStart",
		"update:modelValue"
	],
	setup(props$1, { emit, slots }) {
		let buttonIndex;
		let current$1;
		let startValue;
		const root = ref();
		const slider = [ref(), ref()];
		const dragStatus = ref();
		const touch = useTouch();
		const scope = computed(() => Number(props$1.max) - Number(props$1.min));
		const wrapperStyle = computed(() => {
			const crossAxis = props$1.vertical ? "width" : "height";
			return {
				background: props$1.inactiveColor,
				[crossAxis]: addUnit(props$1.barHeight)
			};
		});
		const isRange = (val) => props$1.range && Array.isArray(val);
		const calcMainAxis = () => {
			const { modelValue, min } = props$1;
			if (isRange(modelValue)) return `${(modelValue[1] - modelValue[0]) * 100 / scope.value}%`;
			return `${(modelValue - Number(min)) * 100 / scope.value}%`;
		};
		const calcOffset = () => {
			const { modelValue, min } = props$1;
			if (isRange(modelValue)) return `${(modelValue[0] - Number(min)) * 100 / scope.value}%`;
			return "0%";
		};
		const barStyle = computed(() => {
			const style = {
				[props$1.vertical ? "height" : "width"]: calcMainAxis(),
				background: props$1.activeColor
			};
			if (dragStatus.value) style.transition = "none";
			const getPositionKey = () => {
				if (props$1.vertical) return props$1.reverse ? "bottom" : "top";
				return props$1.reverse ? "right" : "left";
			};
			style[getPositionKey()] = calcOffset();
			return style;
		});
		const format$2 = (value) => {
			const min = +props$1.min;
			const max = +props$1.max;
			const step = +props$1.step;
			value = clamp(value, min, max);
			return addNumber(min, Math.round((value - min) / step) * step);
		};
		const updateStartValue = () => {
			const current2 = props$1.modelValue;
			if (isRange(current2)) startValue = current2.map(format$2);
			else startValue = format$2(current2);
		};
		const handleRangeValue = (value) => {
			var _a, _b;
			const left$1 = (_a = value[0]) != null ? _a : Number(props$1.min);
			const right$1 = (_b = value[1]) != null ? _b : Number(props$1.max);
			return left$1 > right$1 ? [right$1, left$1] : [left$1, right$1];
		};
		const updateValue = (value, end$1) => {
			if (isRange(value)) value = handleRangeValue(value).map(format$2);
			else value = format$2(value);
			if (!isSameValue(value, props$1.modelValue)) emit("update:modelValue", value);
			if (end$1 && !isSameValue(value, startValue)) emit("change", value);
		};
		const onClick = (event) => {
			event.stopPropagation();
			if (props$1.disabled || props$1.readonly) return;
			updateStartValue();
			const { min, reverse, vertical, modelValue } = props$1;
			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 [left$1, right$1] = modelValue;
				if (value <= (left$1 + right$1) / 2) updateValue([value, right$1], true);
				else updateValue([left$1, value], true);
			} else updateValue(value, true);
		};
		const onTouchStart = (event) => {
			if (props$1.disabled || props$1.readonly) return;
			touch.start(event);
			current$1 = props$1.modelValue;
			updateStartValue();
			dragStatus.value = "start";
		};
		const onTouchMove = (event) => {
			if (props$1.disabled || props$1.readonly) return;
			if (dragStatus.value === "start") emit("dragStart", event);
			preventDefault(event, true);
			touch.move(event);
			dragStatus.value = "dragging";
			const rect = useRect(root);
			let diff = (props$1.vertical ? touch.deltaY.value : touch.deltaX.value) / (props$1.vertical ? rect.height : rect.width) * scope.value;
			if (props$1.reverse) diff = -diff;
			if (isRange(startValue)) {
				const index = props$1.reverse ? 1 - buttonIndex : buttonIndex;
				current$1[index] = startValue[index] + diff;
			} else current$1 = startValue + diff;
			updateValue(current$1);
		};
		const onTouchEnd = (event) => {
			if (props$1.disabled || props$1.readonly) return;
			if (dragStatus.value === "dragging") {
				updateValue(current$1, true);
				emit("dragEnd", event);
			}
			dragStatus.value = "";
		};
		const getButtonClassName = (index) => {
			if (typeof index === "number") return bem$12(`button-wrapper`, ["left", "right"][index]);
			return bem$12("button-wrapper", props$1.reverse ? "left" : "right");
		};
		const renderButtonContent = (value, index) => {
			const dragging = dragStatus.value === "dragging";
			if (typeof index === "number") {
				const slot = slots[index === 0 ? "left-button" : "right-button"];
				let dragIndex;
				if (dragging && Array.isArray(current$1)) dragIndex = current$1[0] > current$1[1] ? buttonIndex ^ 1 : buttonIndex;
				if (slot) return slot({
					value,
					dragging,
					dragIndex
				});
			}
			if (slots.button) return slots.button({
				value,
				dragging
			});
			return createVNode("div", {
				"class": bem$12("button"),
				"style": getSizeStyle(props$1.buttonSize)
			}, null);
		};
		const renderButton = (index) => {
			const current2 = typeof index === "number" ? props$1.modelValue[index] : props$1.modelValue;
			return createVNode("div", {
				"ref": slider[index != null ? index : 0],
				"role": "slider",
				"class": getButtonClassName(index),
				"tabindex": props$1.disabled ? void 0 : 0,
				"aria-valuemin": props$1.min,
				"aria-valuenow": current2,
				"aria-valuemax": props$1.max,
				"aria-disabled": props$1.disabled || void 0,
				"aria-readonly": props$1.readonly || void 0,
				"aria-orientation": props$1.vertical ? "vertical" : "horizontal",
				"onTouchstartPassive": (event) => {
					if (typeof index === "number") buttonIndex = index;
					onTouchStart(event);
				},
				"onTouchend": onTouchEnd,
				"onTouchcancel": onTouchEnd,
				"onClick": stopPropagation
			}, [renderButtonContent(current2, index)]);
		};
		updateValue(props$1.modelValue);
		useCustomFieldValue(() => props$1.modelValue);
		slider.forEach((item) => {
			useEventListener("touchmove", onTouchMove, { target: item });
		});
		return () => createVNode("div", {
			"ref": root,
			"style": wrapperStyle.value,
			"class": bem$12({
				vertical: props$1.vertical,
				disabled: props$1.disabled
			}),
			"onClick": onClick
		}, [createVNode("div", {
			"class": bem$12("bar"),
			"style": barStyle.value
		}, [props$1.range ? [renderButton(0), renderButton(1)] : renderButton()])]);
	}
});

//#endregion
//#region node_modules/vant/es/slider/index.mjs
var Slider = withInstall(stdin_default$18);

//#endregion
//#region node_modules/vant/es/space/Space.mjs
var [name$12, bem$11] = createNamespace("space");
var 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 === Fragment) nodes.push(...filterEmpty(child.children));
		else nodes.push(child);
	});
	return nodes.filter((c) => {
		var _a;
		return !(c && (c.type === Comment || c.type === Fragment && ((_a = c.children) == null ? void 0 : _a.length) === 0 || c.type === Text && c.children.trim() === ""));
	});
}
var stdin_default$17 = defineComponent({
	name: name$12,
	props: spaceProps,
	setup(props$1, { slots }) {
		const mergedAlign = computed(() => {
			var _a;
			return (_a = props$1.align) != null ? _a : props$1.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$1.size) ? props$1.size[0] : props$1.size)}`;
			const marginBottom = `${getMargin(Array.isArray(props$1.size) ? props$1.size[1] : props$1.size)}`;
			if (isLast) return props$1.wrap ? { marginBottom } : {};
			if (props$1.direction === "horizontal") style.marginRight = marginRight;
			if (props$1.direction === "vertical" || props$1.wrap) style.marginBottom = marginBottom;
			return style;
		};
		return () => {
			var _a;
			const children = filterEmpty((_a = slots.default) == null ? void 0 : _a.call(slots));
			return createVNode("div", { "class": [bem$11({
				[props$1.direction]: props$1.direction,
				[`align-${mergedAlign.value}`]: mergedAlign.value,
				wrap: props$1.wrap,
				fill: props$1.fill
			})] }, [children.map((c, i) => createVNode("div", {
				"key": `item-${i}`,
				"class": `${name$12}-item`,
				"style": getMarginStyle(i === children.length - 1)
			}, [c]))]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/space/index.mjs
var Space = withInstall(stdin_default$17);

//#endregion
//#region node_modules/vant/es/steps/Steps.mjs
var [name$11, bem$10] = createNamespace("steps");
var stepsProps = {
	active: makeNumericProp(0),
	direction: makeStringProp("horizontal"),
	activeIcon: makeStringProp("checked"),
	iconPrefix: String,
	finishIcon: String,
	activeColor: String,
	inactiveIcon: String,
	inactiveColor: String
};
var STEPS_KEY = Symbol(name$11);
var stdin_default$14 = defineComponent({
	name: name$11,
	props: stepsProps,
	emits: ["clickStep"],
	setup(props$1, { emit, slots }) {
		const { linkChildren } = useChildren(STEPS_KEY);
		const onClickStep = (index) => emit("clickStep", index);
		linkChildren({
			props: props$1,
			onClickStep
		});
		return () => {
			var _a;
			return createVNode("div", { "class": bem$10([props$1.direction]) }, [createVNode("div", { "class": bem$10("items") }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/step/Step.mjs
var [name$10, bem$9] = createNamespace("step");
var stdin_default$16 = defineComponent({
	name: name$10,
	setup(props$1, { slots }) {
		const { parent, index } = useParent(STEPS_KEY);
		if (!parent) {
			console.error("[Vant] <Step> must be a child component of <Steps>.");
			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 = computed(() => ({ background: getStatus() === "finish" ? parentProps.activeColor : parentProps.inactiveColor }));
		const titleStyle = 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 createVNode(Icon, {
					"class": bem$9("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 createVNode(Icon, {
					"class": bem$9("icon", "finish"),
					"name": finishIcon,
					"color": activeColor,
					"classPrefix": iconPrefix
				}, null);
			}
			if (slots["inactive-icon"]) return slots["inactive-icon"]();
			if (inactiveIcon) return createVNode(Icon, {
				"class": bem$9("icon"),
				"name": inactiveIcon,
				"classPrefix": iconPrefix
			}, null);
			return createVNode("i", {
				"class": bem$9("circle"),
				"style": lineStyle.value
			}, null);
		};
		return () => {
			var _a;
			const status = getStatus();
			return createVNode("div", { "class": [BORDER, bem$9([parentProps.direction, { [status]: status }])] }, [
				createVNode("div", {
					"class": bem$9("title", { active: isActive() }),
					"style": titleStyle.value,
					"onClick": onClickStep
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]),
				createVNode("div", {
					"class": bem$9("circle-container"),
					"onClick": onClickStep
				}, [renderCircle()]),
				createVNode("div", {
					"class": bem$9("line"),
					"style": lineStyle.value
				}, null)
			]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/step/index.mjs
var Step = withInstall(stdin_default$16);

//#endregion
//#region node_modules/vant/es/stepper/Stepper.mjs
var [name$9, bem$8] = createNamespace("stepper");
var LONG_PRESS_INTERVAL = 200;
var isEqual = (value1, value2) => String(value1) === String(value2);
var 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$15 = defineComponent({
	name: name$9,
	props: stepperProps,
	emits: [
		"plus",
		"blur",
		"minus",
		"focus",
		"change",
		"overlimit",
		"update:modelValue"
	],
	setup(props$1, { emit }) {
		const format$2 = (value, autoFixed = true) => {
			const { min, max, allowEmpty, decimalLength } = props$1;
			if (allowEmpty && value === "") return value;
			value = formatNumber(String(value), !props$1.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 value = format$2((_a = props$1.modelValue) != null ? _a : props$1.defaultValue);
			if (!isEqual(value, props$1.modelValue)) emit("update:modelValue", value);
			return value;
		};
		let actionType;
		const inputRef = ref();
		const current$1 = ref(getInitialValue());
		const minusDisabled = computed(() => props$1.disabled || props$1.disableMinus || +current$1.value <= +props$1.min);
		const plusDisabled = computed(() => props$1.disabled || props$1.disablePlus || +current$1.value >= +props$1.max);
		const inputStyle = computed(() => ({
			width: addUnit(props$1.inputWidth),
			height: addUnit(props$1.buttonSize)
		}));
		const buttonStyle = computed(() => getSizeStyle(props$1.buttonSize));
		const check = () => {
			const value = format$2(current$1.value);
			if (!isEqual(value, current$1.value)) current$1.value = value;
		};
		const setValue = (value) => {
			if (props$1.beforeChange) callInterceptor(props$1.beforeChange, {
				args: [value],
				done() {
					current$1.value = value;
				}
			});
			else current$1.value = value;
		};
		const onChange = () => {
			if (actionType === "plus" && plusDisabled.value || actionType === "minus" && minusDisabled.value) {
				emit("overlimit", actionType);
				return;
			}
			const diff = actionType === "minus" ? -props$1.step : +props$1.step;
			setValue(format$2(addNumber(+current$1.value, diff)));
			emit(actionType);
		};
		const onInput = (event) => {
			const input = event.target;
			const { value } = input;
			const { decimalLength } = props$1;
			let formatted = formatNumber(String(value), !props$1.integer);
			if (isDef(decimalLength) && formatted.includes(".")) {
				const pair = formatted.split(".");
				formatted = `${pair[0]}.${pair[1].slice(0, +decimalLength)}`;
			}
			if (props$1.beforeChange) input.value = String(current$1.value);
			else if (!isEqual(value, formatted)) input.value = formatted;
			setValue(formatted === String(+formatted) ? +formatted : formatted);
		};
		const onFocus = (event) => {
			var _a;
			if (props$1.disableInput) (_a = inputRef.value) == null || _a.blur();
			else emit("focus", event);
		};
		const onBlur = (event) => {
			const input = event.target;
			const value = format$2(input.value, props$1.autoFixed);
			input.value = String(value);
			current$1.value = value;
			nextTick(() => {
				emit("blur", event);
				resetScroll();
			});
		};
		let isLongPress;
		let longPressTimer;
		const longPressStep = () => {
			longPressTimer = setTimeout(() => {
				onChange();
				longPressStep();
			}, LONG_PRESS_INTERVAL);
		};
		const onTouchStart = () => {
			if (props$1.longPress) {
				isLongPress = false;
				clearTimeout(longPressTimer);
				longPressTimer = setTimeout(() => {
					isLongPress = true;
					onChange();
					longPressStep();
				}, LONG_PRESS_START_TIME);
			}
		};
		const onTouchEnd = (event) => {
			if (props$1.longPress) {
				clearTimeout(longPressTimer);
				if (isLongPress) preventDefault(event);
			}
		};
		const onMousedown = (event) => {
			if (props$1.disableInput) preventDefault(event);
		};
		const createListeners = (type) => ({
			onClick: (event) => {
				preventDefault(event);
				actionType = type;
				onChange();
			},
			onTouchstartPassive: () => {
				actionType = type;
				onTouchStart();
			},
			onTouchend: onTouchEnd,
			onTouchcancel: onTouchEnd
		});
		watch(() => [
			props$1.max,
			props$1.min,
			props$1.integer,
			props$1.decimalLength
		], check);
		watch(() => props$1.modelValue, (value) => {
			if (!isEqual(value, current$1.value)) current$1.value = format$2(value);
		});
		watch(current$1, (value) => {
			emit("update:modelValue", value);
			emit("change", value, { name: props$1.name });
		});
		useCustomFieldValue(() => props$1.modelValue);
		return () => createVNode("div", {
			"role": "group",
			"class": bem$8([props$1.theme])
		}, [
			withDirectives(createVNode("button", mergeProps({
				"type": "button",
				"style": buttonStyle.value,
				"class": [bem$8("minus", { disabled: minusDisabled.value }), { [HAPTICS_FEEDBACK]: !minusDisabled.value }],
				"aria-disabled": minusDisabled.value || void 0
			}, createListeners("minus")), null), [[vShow, props$1.showMinus]]),
			withDirectives(createVNode("input", {
				"ref": inputRef,
				"type": props$1.integer ? "tel" : "text",
				"role": "spinbutton",
				"class": bem$8("input"),
				"value": current$1.value,
				"style": inputStyle.value,
				"disabled": props$1.disabled,
				"readonly": props$1.disableInput,
				"inputmode": props$1.integer ? "numeric" : "decimal",
				"placeholder": props$1.placeholder,
				"autocomplete": "off",
				"aria-valuemax": props$1.max,
				"aria-valuemin": props$1.min,
				"aria-valuenow": current$1.value,
				"onBlur": onBlur,
				"onInput": onInput,
				"onFocus": onFocus,
				"onMousedown": onMousedown
			}, null), [[vShow, props$1.showInput]]),
			withDirectives(createVNode("button", mergeProps({
				"type": "button",
				"style": buttonStyle.value,
				"class": [bem$8("plus", { disabled: plusDisabled.value }), { [HAPTICS_FEEDBACK]: !plusDisabled.value }],
				"aria-disabled": plusDisabled.value || void 0
			}, createListeners("plus")), null), [[vShow, props$1.showPlus]])
		]);
	}
});

//#endregion
//#region node_modules/vant/es/stepper/index.mjs
var Stepper = withInstall(stdin_default$15);

//#endregion
//#region node_modules/vant/es/steps/index.mjs
var Steps = withInstall(stdin_default$14);

//#endregion
//#region node_modules/vant/es/submit-bar/SubmitBar.mjs
var [name$8, bem$7, t$1] = createNamespace("submit-bar");
var 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$13 = defineComponent({
	name: name$8,
	props: submitBarProps,
	emits: ["submit"],
	setup(props$1, { emit, slots }) {
		const root = ref();
		const renderPlaceholder = usePlaceholder(root, bem$7);
		const renderText = () => {
			const { price, label, currency, textAlign, suffixLabel, decimalLength } = props$1;
			if (typeof price === "number") {
				const pricePair = (price / 100).toFixed(+decimalLength).split(".");
				const decimal = decimalLength ? `.${pricePair[1]}` : "";
				return createVNode("div", {
					"class": bem$7("text"),
					"style": { textAlign }
				}, [
					createVNode("span", null, [label || t$1("label")]),
					createVNode("span", { "class": bem$7("price") }, [
						currency,
						createVNode("span", { "class": bem$7("price-integer") }, [pricePair[0]]),
						decimal
					]),
					suffixLabel && createVNode("span", { "class": bem$7("suffix-label") }, [suffixLabel])
				]);
			}
		};
		const renderTip = () => {
			var _a;
			const { tip, tipIcon } = props$1;
			if (slots.tip || tip) return createVNode("div", { "class": bem$7("tip") }, [
				tipIcon && createVNode(Icon, {
					"class": bem$7("tip-icon"),
					"name": tipIcon
				}, null),
				tip && createVNode("span", { "class": bem$7("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 createVNode(Button, {
				"round": true,
				"type": props$1.buttonType,
				"text": props$1.buttonText,
				"class": bem$7("button", props$1.buttonType),
				"color": props$1.buttonColor,
				"loading": props$1.loading,
				"disabled": props$1.disabled,
				"onClick": onClickButton
			}, null);
		};
		const renderSubmitBar = () => {
			var _a, _b;
			return createVNode("div", {
				"ref": root,
				"class": [bem$7(), { "van-safe-area-bottom": props$1.safeAreaInsetBottom }]
			}, [
				(_a = slots.top) == null ? void 0 : _a.call(slots),
				renderTip(),
				createVNode("div", { "class": bem$7("bar") }, [
					(_b = slots.default) == null ? void 0 : _b.call(slots),
					renderText(),
					renderButton()
				])
			]);
		};
		return () => {
			if (props$1.placeholder) return renderPlaceholder(renderSubmitBar);
			return renderSubmitBar();
		};
	}
});

//#endregion
//#region node_modules/vant/es/submit-bar/index.mjs
var SubmitBar = withInstall(stdin_default$13);

//#endregion
//#region node_modules/vant/es/swipe-cell/SwipeCell.mjs
var [name$7, bem$6] = createNamespace("swipe-cell");
var swipeCellProps = {
	name: makeNumericProp(""),
	disabled: Boolean,
	leftWidth: numericProp,
	rightWidth: numericProp,
	beforeClose: Function,
	stopPropagation: Boolean
};
var stdin_default$12 = defineComponent({
	name: name$7,
	props: swipeCellProps,
	emits: [
		"open",
		"close",
		"click"
	],
	setup(props$1, { emit, slots }) {
		let opened;
		let lockClick$1;
		let startOffset;
		let isInBeforeClosing;
		const root = ref();
		const leftRef = ref();
		const rightRef = ref();
		const state = reactive({
			offset: 0,
			dragging: false
		});
		const touch = useTouch();
		const getWidthByRef = (ref2) => ref2.value ? useRect(ref2).width : 0;
		const leftWidth = computed(() => isDef(props$1.leftWidth) ? +props$1.leftWidth : getWidthByRef(leftRef));
		const rightWidth = computed(() => isDef(props$1.rightWidth) ? +props$1.rightWidth : getWidthByRef(rightRef));
		const open = (side) => {
			state.offset = side === "left" ? leftWidth.value : -rightWidth.value;
			if (!opened) {
				opened = true;
				emit("open", {
					name: props$1.name,
					position: side
				});
			}
		};
		const close = (position) => {
			state.offset = 0;
			if (opened) {
				opened = false;
				emit("close", {
					name: props$1.name,
					position
				});
			}
		};
		const toggle = (side) => {
			const offset$1 = Math.abs(state.offset);
			const THRESHOLD = .15;
			const threshold = opened ? 1 - THRESHOLD : THRESHOLD;
			const width$1 = side === "left" ? leftWidth.value : rightWidth.value;
			if (width$1 && offset$1 > width$1 * threshold) open(side);
			else close(side);
		};
		const onTouchStart = (event) => {
			if (!props$1.disabled) {
				startOffset = state.offset;
				touch.start(event);
			}
		};
		const onTouchMove = (event) => {
			if (props$1.disabled) return;
			const { deltaX } = touch;
			touch.move(event);
			if (touch.isHorizontal()) {
				lockClick$1 = true;
				state.dragging = true;
				if (!opened || deltaX.value * startOffset < 0) preventDefault(event, props$1.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(() => {
					lockClick$1 = false;
				}, 0);
			}
		};
		const onClick = (position = "outside", event) => {
			if (isInBeforeClosing) return;
			emit("click", position);
			if (opened && !lockClick$1) {
				isInBeforeClosing = true;
				callInterceptor(props$1.beforeClose, {
					args: [{
						event,
						name: props$1.name,
						position
					}],
					done: () => {
						isInBeforeClosing = false;
						close(position);
					},
					canceled: () => isInBeforeClosing = false,
					error: () => isInBeforeClosing = false
				});
			}
		};
		const getClickHandler = (position) => (event) => {
			if (lockClick$1 || opened) event.stopPropagation();
			if (lockClick$1) return;
			onClick(position, event);
		};
		const renderSideContent = (side, ref2) => {
			const contentSlot = slots[side];
			if (contentSlot) return createVNode("div", {
				"ref": ref2,
				"class": bem$6(side),
				"onClick": getClickHandler(side)
			}, [contentSlot()]);
		};
		useExpose({
			open,
			close
		});
		useClickAway(root, (event) => onClick("outside", event), { 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 createVNode("div", {
				"ref": root,
				"class": bem$6(),
				"onClick": getClickHandler("cell"),
				"onTouchstartPassive": onTouchStart,
				"onTouchend": onTouchEnd,
				"onTouchcancel": onTouchEnd
			}, [createVNode("div", {
				"class": bem$6("wrapper"),
				"style": wrapperStyle
			}, [
				renderSideContent("left", leftRef),
				(_a = slots.default) == null ? void 0 : _a.call(slots),
				renderSideContent("right", rightRef)
			])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/swipe-cell/index.mjs
var SwipeCell = withInstall(stdin_default$12);

//#endregion
//#region node_modules/vant/es/tabbar/Tabbar.mjs
var [name$6, bem$5] = createNamespace("tabbar");
var 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
	}
};
var TABBAR_KEY = Symbol(name$6);
var stdin_default$11 = defineComponent({
	name: name$6,
	props: tabbarProps,
	emits: ["change", "update:modelValue"],
	setup(props$1, { emit, slots }) {
		const root = ref();
		const { linkChildren } = useChildren(TABBAR_KEY);
		const renderPlaceholder = usePlaceholder(root, bem$5);
		const enableSafeArea = () => {
			var _a;
			return (_a = props$1.safeAreaInsetBottom) != null ? _a : props$1.fixed;
		};
		const renderTabbar = () => {
			var _a;
			const { fixed, zIndex, border } = props$1;
			return createVNode("div", {
				"ref": root,
				"role": "tablist",
				"style": getZIndexStyle(zIndex),
				"class": [bem$5({ 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$1.beforeChange, {
				args: [active],
				done() {
					emit("update:modelValue", active);
					emit("change", active);
					afterChange();
				}
			});
		};
		linkChildren({
			props: props$1,
			setActive
		});
		return () => {
			if (props$1.fixed && props$1.placeholder) return renderPlaceholder(renderTabbar);
			return renderTabbar();
		};
	}
});

//#endregion
//#region node_modules/vant/es/tabbar/index.mjs
var Tabbar = withInstall(stdin_default$11);

//#endregion
//#region node_modules/vant/es/tabbar-item/TabbarItem.mjs
var [name$5, bem$4] = createNamespace("tabbar-item");
var tabbarItemProps = extend({}, routeProps, {
	dot: Boolean,
	icon: String,
	name: numericProp,
	badge: numericProp,
	badgeProps: Object,
	iconPrefix: String
});
var stdin_default$10 = defineComponent({
	name: name$5,
	props: tabbarItemProps,
	emits: ["click"],
	setup(props$1, { emit, slots }) {
		const route$1 = useRoute();
		const vm = getCurrentInstance().proxy;
		const { parent, index } = useParent(TABBAR_KEY);
		if (!parent) {
			console.error("[Vant] <TabbarItem> must be a child component of <Tabbar>.");
			return;
		}
		const active = computed(() => {
			var _a;
			const { route: route2, modelValue } = parent.props;
			if (route2 && "$route" in vm) {
				const { $route } = vm;
				const { to } = props$1;
				const config = isObject(to) ? to : { path: to };
				return $route.matched.some((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$1.name) != null ? _a : index.value) === modelValue;
		});
		const onClick = (event) => {
			var _a;
			if (!active.value) parent.setActive((_a = props$1.name) != null ? _a : index.value, route$1);
			emit("click", event);
		};
		const renderIcon = () => {
			if (slots.icon) return slots.icon({ active: active.value });
			if (props$1.icon) return createVNode(Icon, {
				"name": props$1.icon,
				"classPrefix": props$1.iconPrefix
			}, null);
		};
		return () => {
			var _a;
			const { dot, badge } = props$1;
			const { activeColor, inactiveColor } = parent.props;
			const color = active.value ? activeColor : inactiveColor;
			return createVNode("div", {
				"role": "tab",
				"class": bem$4({ active: active.value }),
				"style": { color },
				"tabindex": 0,
				"aria-selected": active.value,
				"onClick": onClick
			}, [createVNode(Badge, mergeProps({
				"dot": dot,
				"class": bem$4("icon"),
				"content": badge
			}, props$1.badgeProps), { default: renderIcon }), createVNode("div", { "class": bem$4("text") }, [(_a = slots.default) == null ? void 0 : _a.call(slots, { active: active.value })])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/tabbar-item/index.mjs
var TabbarItem = withInstall(stdin_default$10);

//#endregion
//#region node_modules/vant/es/text-ellipsis/TextEllipsis.mjs
var [name$4, bem$3] = createNamespace("text-ellipsis");
var textEllipsisProps = {
	rows: makeNumericProp(1),
	dots: makeStringProp("..."),
	content: makeStringProp(""),
	expandText: makeStringProp(""),
	collapseText: makeStringProp(""),
	position: makeStringProp("end")
};
var stdin_default$9 = defineComponent({
	name: name$4,
	props: textEllipsisProps,
	emits: ["clickAction"],
	setup(props$1, { emit, slots }) {
		const text = ref(props$1.content);
		const expanded = ref(false);
		const hasAction = ref(false);
		const root = ref();
		const actionRef = ref();
		let needRecalculate = false;
		const actionText = computed(() => expanded.value ? props$1.collapseText : props$1.expandText);
		const pxToNum = (value) => {
			if (!value) return 0;
			const match = value.match(/^\d*(\.\d*)?/);
			return match ? Number(match[0]) : 0;
		};
		const cloneContainer = () => {
			if (!root.value || !root.value.isConnected) return;
			const originStyle = window.getComputedStyle(root.value);
			const container = document.createElement("div");
			Array.prototype.slice.apply(originStyle).forEach((name2) => {
				container.style.setProperty(name2, originStyle.getPropertyValue(name2));
			});
			container.style.position = "fixed";
			container.style.zIndex = "-9999";
			container.style.top = "-9999px";
			container.style.height = "auto";
			container.style.minHeight = "auto";
			container.style.maxHeight = "auto";
			container.innerText = props$1.content;
			document.body.appendChild(container);
			return container;
		};
		const calcEllipsisText = (container, maxHeight) => {
			var _a, _b;
			const { content, position, dots } = props$1;
			const end$1 = content.length;
			const middle = 0 + end$1 >> 1;
			const actionHTML = slots.action ? (_b = (_a = actionRef.value) == null ? void 0 : _a.outerHTML) != null ? _b : "" : props$1.expandText;
			const calcEllipse = () => {
				const tail = (left$1, right$1) => {
					if (right$1 - left$1 <= 1) {
						if (position === "end") return content.slice(0, left$1) + dots;
						return dots + content.slice(right$1, end$1);
					}
					const middle2 = Math.round((left$1 + right$1) / 2);
					if (position === "end") container.innerText = content.slice(0, middle2) + dots;
					else container.innerText = dots + content.slice(middle2, end$1);
					container.innerHTML += actionHTML;
					if (container.offsetHeight > maxHeight) {
						if (position === "end") return tail(left$1, middle2);
						return tail(middle2, right$1);
					}
					if (position === "end") return tail(middle2, right$1);
					return tail(left$1, middle2);
				};
				return tail(0, end$1);
			};
			const middleTail = (leftPart, rightPart) => {
				if (leftPart[1] - leftPart[0] <= 1 && rightPart[1] - rightPart[0] <= 1) return content.slice(0, leftPart[0]) + dots + content.slice(rightPart[1], end$1);
				const leftMiddle = Math.floor((leftPart[0] + leftPart[1]) / 2);
				const rightMiddle = Math.ceil((rightPart[0] + rightPart[1]) / 2);
				container.innerText = props$1.content.slice(0, leftMiddle) + props$1.dots + props$1.content.slice(rightMiddle, end$1);
				container.innerHTML += actionHTML;
				if (container.offsetHeight >= maxHeight) return middleTail([leftPart[0], leftMiddle], [rightMiddle, rightPart[1]]);
				return middleTail([leftMiddle, leftPart[1]], [rightPart[0], rightMiddle]);
			};
			return props$1.position === "middle" ? middleTail([0, middle], [middle, end$1]) : calcEllipse();
		};
		const calcEllipsised = () => {
			const container = cloneContainer();
			if (!container) {
				needRecalculate = true;
				return;
			}
			const { paddingBottom, paddingTop, lineHeight } = container.style;
			const maxHeight = Math.ceil((Number(props$1.rows) + .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$1.content;
			}
			document.body.removeChild(container);
		};
		const toggle = (isExpanded = !expanded.value) => {
			expanded.value = isExpanded;
		};
		const onClickAction = (event) => {
			toggle();
			emit("clickAction", event);
		};
		const renderAction = () => {
			const action = slots.action ? slots.action({ expanded: expanded.value }) : actionText.value;
			return createVNode("span", {
				"ref": actionRef,
				"class": bem$3("action"),
				"onClick": onClickAction
			}, [action]);
		};
		onMounted(() => {
			calcEllipsised();
			if (slots.action) nextTick(calcEllipsised);
		});
		onActivated(() => {
			if (needRecalculate) {
				needRecalculate = false;
				calcEllipsised();
			}
		});
		watch([windowWidth, () => [
			props$1.content,
			props$1.rows,
			props$1.position
		]], calcEllipsised);
		useExpose({ toggle });
		return () => createVNode("div", {
			"ref": root,
			"class": bem$3()
		}, [expanded.value ? props$1.content : text.value, hasAction.value ? renderAction() : null]);
	}
});

//#endregion
//#region node_modules/vant/es/text-ellipsis/index.mjs
var TextEllipsis = withInstall(stdin_default$9);

//#endregion
//#region node_modules/vant/es/time-picker/TimePicker.mjs
var [name$3] = createNamespace("time-picker");
var validateTime = (val) => /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/.test(val);
var fullColumns = [
	"hour",
	"minute",
	"second"
];
var timePickerProps = extend({}, sharedProps, {
	minHour: makeNumericProp(0),
	maxHour: makeNumericProp(23),
	minMinute: makeNumericProp(0),
	maxMinute: makeNumericProp(59),
	minSecond: makeNumericProp(0),
	maxSecond: makeNumericProp(59),
	minTime: {
		type: String,
		validator: validateTime
	},
	maxTime: {
		type: String,
		validator: validateTime
	},
	columnsType: {
		type: Array,
		default: () => ["hour", "minute"]
	}
});
var stdin_default$8 = defineComponent({
	name: name$3,
	props: timePickerProps,
	emits: [
		"confirm",
		"cancel",
		"change",
		"update:modelValue"
	],
	setup(props$1, { emit, slots }) {
		const currentValues = ref(props$1.modelValue);
		const pickerRef = ref();
		const getValidTime = (time) => {
			const timeLimitArr = time.split(":");
			return fullColumns.map((col, i) => props$1.columnsType.includes(col) ? timeLimitArr[i] : "00");
		};
		const confirm = () => {
			var _a;
			return (_a = pickerRef.value) == null ? void 0 : _a.confirm();
		};
		const getSelectedTime = () => currentValues.value;
		const columns = computed(() => {
			let { minHour, maxHour, minMinute, maxMinute, minSecond, maxSecond } = props$1;
			if (props$1.minTime || props$1.maxTime) {
				const fullTime = {
					hour: 0,
					minute: 0,
					second: 0
				};
				props$1.columnsType.forEach((col, i) => {
					var _a;
					fullTime[col] = (_a = currentValues.value[i]) != null ? _a : 0;
				});
				const { hour, minute } = fullTime;
				if (props$1.minTime) {
					const [minH, minM, minS] = getValidTime(props$1.minTime);
					minHour = minH;
					minMinute = +hour <= +minHour ? minM : "00";
					minSecond = +hour <= +minHour && +minute <= +minMinute ? minS : "00";
				}
				if (props$1.maxTime) {
					const [maxH, maxM, maxS] = getValidTime(props$1.maxTime);
					maxHour = maxH;
					maxMinute = +hour >= +maxHour ? maxM : "59";
					maxSecond = +hour >= +maxHour && +minute >= +maxMinute ? maxS : "59";
				}
			}
			return props$1.columnsType.map((type) => {
				const { filter, formatter } = props$1;
				switch (type) {
					case "hour": return genOptions(+minHour, +maxHour, type, formatter, filter, currentValues.value);
					case "minute": return genOptions(+minMinute, +maxMinute, type, formatter, filter, currentValues.value);
					case "second": return genOptions(+minSecond, +maxSecond, type, formatter, filter, currentValues.value);
					default: throw new Error(`[Vant] DatePicker: unsupported columns type: ${type}`);
				}
			});
		});
		watch(currentValues, (newValues) => {
			if (!isSameValue(newValues, props$1.modelValue)) emit("update:modelValue", newValues);
		});
		watch(() => props$1.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);
		useExpose({
			confirm,
			getSelectedTime
		});
		return () => createVNode(Picker, mergeProps({
			"ref": pickerRef,
			"modelValue": currentValues.value,
			"onUpdate:modelValue": ($event) => currentValues.value = $event,
			"columns": columns.value,
			"onChange": onChange,
			"onCancel": onCancel,
			"onConfirm": onConfirm
		}, pick(props$1, pickerInheritKeys)), slots);
	}
});

//#endregion
//#region node_modules/vant/es/time-picker/index.mjs
var TimePicker = withInstall(stdin_default$8);

//#endregion
//#region node_modules/vant/es/tree-select/TreeSelect.mjs
var [name$2, bem$2] = createNamespace("tree-select");
var 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$7 = defineComponent({
	name: name$2,
	props: treeSelectProps,
	emits: [
		"clickNav",
		"clickItem",
		"update:activeId",
		"update:mainActiveIndex"
	],
	setup(props$1, { emit, slots }) {
		const isActiveItem = (id) => Array.isArray(props$1.activeId) ? props$1.activeId.includes(id) : props$1.activeId === id;
		const renderSubItem = (item) => {
			const onClick = () => {
				if (item.disabled) return;
				let activeId;
				if (Array.isArray(props$1.activeId)) {
					activeId = props$1.activeId.slice();
					const index = activeId.indexOf(item.id);
					if (index !== -1) activeId.splice(index, 1);
					else if (activeId.length < +props$1.max) activeId.push(item.id);
				} else activeId = item.id;
				emit("update:activeId", activeId);
				emit("clickItem", item);
			};
			return createVNode("div", {
				"key": item.id,
				"class": ["van-ellipsis", bem$2("item", {
					active: isActiveItem(item.id),
					disabled: item.disabled
				})],
				"onClick": onClick
			}, [item.text, isActiveItem(item.id) && createVNode(Icon, {
				"name": props$1.selectedIcon,
				"class": bem$2("selected")
			}, null)]);
		};
		const onSidebarChange = (index) => {
			emit("update:mainActiveIndex", index);
		};
		const onClickSidebarItem = (index) => emit("clickNav", index);
		const renderSidebar = () => {
			const Items = props$1.items.map((item) => createVNode(SidebarItem, {
				"dot": item.dot,
				"badge": item.badge,
				"class": [bem$2("nav-item"), item.className],
				"disabled": item.disabled,
				"onClick": onClickSidebarItem
			}, { title: () => slots["nav-text"] ? slots["nav-text"](item) : item.text }));
			return createVNode(Sidebar, {
				"class": bem$2("nav"),
				"modelValue": props$1.mainActiveIndex,
				"onChange": onSidebarChange
			}, { default: () => [Items] });
		};
		const renderContent = () => {
			if (slots.content) return slots.content();
			const selected = props$1.items[+props$1.mainActiveIndex] || {};
			if (selected.children) return selected.children.map(renderSubItem);
		};
		return () => createVNode("div", {
			"class": bem$2(),
			"style": { height: addUnit(props$1.height) }
		}, [renderSidebar(), createVNode("div", { "class": bem$2("content") }, [renderContent()])]);
	}
});

//#endregion
//#region node_modules/vant/es/tree-select/index.mjs
var TreeSelect = withInstall(stdin_default$7);

//#endregion
//#region node_modules/vant/es/uploader/utils.mjs
var [name$1, bem$1, 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
	};
}
var IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg|avif)/i;
var 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;
}

//#endregion
//#region node_modules/vant/es/uploader/UploaderPreviewItem.mjs
var stdin_default$6 = defineComponent({
	props: {
		name: numericProp,
		item: makeRequiredProp(Object),
		index: Number,
		imageFit: String,
		lazyLoad: Boolean,
		deletable: Boolean,
		reupload: Boolean,
		previewSize: [
			Number,
			String,
			Array
		],
		beforeDelete: Function
	},
	emits: [
		"delete",
		"preview",
		"reupload"
	],
	setup(props$1, { emit, slots }) {
		const renderMask = () => {
			const { status, message } = props$1.item;
			if (status === "uploading" || status === "failed") {
				const MaskIcon = status === "failed" ? createVNode(Icon, {
					"name": "close",
					"class": bem$1("mask-icon")
				}, null) : createVNode(Loading, { "class": bem$1("loading") }, null);
				const showMessage = isDef(message) && message !== "";
				return createVNode("div", { "class": bem$1("mask") }, [MaskIcon, showMessage && createVNode("div", { "class": bem$1("mask-message") }, [message])]);
			}
		};
		const onDelete = (event) => {
			const { name: name$111, item, index, beforeDelete } = props$1;
			event.stopPropagation();
			callInterceptor(beforeDelete, {
				args: [item, {
					name: name$111,
					index
				}],
				done: () => emit("delete")
			});
		};
		const onPreview = () => emit("preview");
		const onReupload = () => emit("reupload");
		const renderDeleteIcon = () => {
			if (props$1.deletable && props$1.item.status !== "uploading") {
				const slot = slots["preview-delete"];
				return createVNode("div", {
					"role": "button",
					"class": bem$1("preview-delete", { shadow: !slot }),
					"tabindex": 0,
					"aria-label": t("delete"),
					"onClick": onDelete
				}, [slot ? slot() : createVNode(Icon, {
					"name": "cross",
					"class": bem$1("preview-delete-icon")
				}, null)]);
			}
		};
		const renderCover = () => {
			if (slots["preview-cover"]) {
				const { index, item } = props$1;
				return createVNode("div", { "class": bem$1("preview-cover") }, [slots["preview-cover"](extend({ index }, item))]);
			}
		};
		const renderPreview = () => {
			const { item, lazyLoad, imageFit, previewSize, reupload } = props$1;
			if (isImageFile(item)) return createVNode(Image$1, {
				"fit": imageFit,
				"src": item.objectUrl || item.content || item.url,
				"class": bem$1("preview-image"),
				"width": Array.isArray(previewSize) ? previewSize[0] : previewSize,
				"height": Array.isArray(previewSize) ? previewSize[1] : previewSize,
				"lazyLoad": lazyLoad,
				"onClick": reupload ? onReupload : onPreview
			}, { default: renderCover });
			return createVNode("div", {
				"class": bem$1("file"),
				"style": getSizeStyle(props$1.previewSize)
			}, [
				createVNode(Icon, {
					"class": bem$1("file-icon"),
					"name": "description"
				}, null),
				createVNode("div", { "class": [bem$1("file-name"), "van-ellipsis"] }, [item.file ? item.file.name : item.url]),
				renderCover()
			]);
		};
		return () => createVNode("div", { "class": bem$1("preview") }, [
			renderPreview(),
			renderMask(),
			renderDeleteIcon()
		]);
	}
});

//#endregion
//#region node_modules/vant/es/uploader/Uploader.mjs
var 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,
	reupload: Boolean,
	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$5 = defineComponent({
	name: name$1,
	props: uploaderProps,
	emits: [
		"delete",
		"oversize",
		"clickUpload",
		"closePreview",
		"clickPreview",
		"clickReupload",
		"update:modelValue"
	],
	setup(props$1, { emit, slots }) {
		const inputRef = ref();
		const urls = [];
		const reuploadIndex = ref(-1);
		const isReuploading = ref(false);
		const getDetail = (index = props$1.modelValue.length) => ({
			name: props$1.name,
			index
		});
		const resetInput = () => {
			if (inputRef.value) inputRef.value.value = "";
		};
		const onAfterRead = (items) => {
			resetInput();
			if (isOversize(items, props$1.maxSize)) if (Array.isArray(items)) {
				const result = filterFiles(items, props$1.maxSize);
				items = result.valid;
				emit("oversize", result.invalid, getDetail());
				if (!items.length) return;
			} else {
				emit("oversize", items, getDetail());
				return;
			}
			items = reactive(items);
			if (reuploadIndex.value > -1) {
				const arr = [...props$1.modelValue];
				arr.splice(reuploadIndex.value, 1, items);
				emit("update:modelValue", arr);
				reuploadIndex.value = -1;
			} else emit("update:modelValue", [...props$1.modelValue, ...toArray(items)]);
			if (props$1.afterRead) props$1.afterRead(items, getDetail());
		};
		const readFile = (files) => {
			const { maxCount, modelValue, resultType } = props$1;
			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) => {
					onAfterRead(files.map((file, index) => {
						const result = {
							file,
							status: "",
							message: "",
							objectUrl: URL.createObjectURL(file)
						};
						if (contents[index]) result.content = contents[index];
						return result;
					}));
				});
			} else readFileContent(files, resultType).then((content) => {
				const result = {
					file: files,
					status: "",
					message: "",
					objectUrl: URL.createObjectURL(files)
				};
				if (content) result.content = content;
				onAfterRead(result);
			});
		};
		const onChange = (event) => {
			const { files } = event.target;
			if (props$1.disabled || !files || !files.length) return;
			const file = files.length === 1 ? files[0] : [].slice.call(files);
			if (props$1.beforeRead) {
				const response = props$1.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$1.previewFullImage) {
				const imageFiles = props$1.modelValue.filter(isImageFile);
				imagePreview = showImagePreview(extend({
					images: imageFiles.map((item2) => {
						if (item2.objectUrl && !item2.url && item2.status !== "failed") {
							item2.url = item2.objectUrl;
							urls.push(item2.url);
						}
						return item2.url;
					}).filter(Boolean),
					startPosition: imageFiles.indexOf(item),
					onClose: onClosePreview
				}, props$1.previewOptions));
			}
		};
		const closeImagePreview = () => {
			if (imagePreview) imagePreview.close();
		};
		const deleteFile = (item, index) => {
			const fileList = props$1.modelValue.slice(0);
			fileList.splice(index, 1);
			emit("update:modelValue", fileList);
			emit("delete", item, getDetail(index));
		};
		const reuploadFile = (index) => {
			isReuploading.value = true;
			reuploadIndex.value = index;
			nextTick(() => chooseFile());
		};
		const onInputClick = () => {
			if (!isReuploading.value) reuploadIndex.value = -1;
			isReuploading.value = false;
		};
		const renderPreviewItem = (item, index) => {
			const needPickData = [
				"imageFit",
				"deletable",
				"reupload",
				"previewSize",
				"beforeDelete"
			];
			const previewData = extend(pick(props$1, needPickData), pick(item, needPickData, true));
			return createVNode(stdin_default$6, mergeProps({
				"item": item,
				"index": index,
				"onClick": () => emit(props$1.reupload ? "clickReupload" : "clickPreview", item, getDetail(index)),
				"onDelete": () => deleteFile(item, index),
				"onPreview": () => previewImage(item),
				"onReupload": () => reuploadFile(index)
			}, pick(props$1, ["name", "lazyLoad"]), previewData), pick(slots, ["preview-cover", "preview-delete"]));
		};
		const renderPreviewList = () => {
			if (props$1.previewImage) return props$1.modelValue.map(renderPreviewItem);
		};
		const onClickUpload = (event) => emit("clickUpload", event);
		const renderUpload = () => {
			const lessThanMax = props$1.modelValue.length < +props$1.maxCount;
			const Input = props$1.readonly ? null : createVNode("input", {
				"ref": inputRef,
				"type": "file",
				"class": bem$1("input"),
				"accept": props$1.accept,
				"capture": props$1.capture,
				"multiple": props$1.multiple && reuploadIndex.value === -1,
				"disabled": props$1.disabled,
				"onChange": onChange,
				"onClick": onInputClick
			}, null);
			if (slots.default) return withDirectives(createVNode("div", {
				"class": bem$1("input-wrapper"),
				"onClick": onClickUpload
			}, [slots.default(), Input]), [[vShow, lessThanMax]]);
			return withDirectives(createVNode("div", {
				"class": bem$1("upload", { readonly: props$1.readonly }),
				"style": getSizeStyle(props$1.previewSize),
				"onClick": onClickUpload
			}, [
				createVNode(Icon, {
					"name": props$1.uploadIcon,
					"class": bem$1("upload-icon")
				}, null),
				props$1.uploadText && createVNode("span", { "class": bem$1("upload-text") }, [props$1.uploadText]),
				Input
			]), [[vShow, props$1.showUpload && lessThanMax]]);
		};
		const chooseFile = () => {
			if (inputRef.value && !props$1.disabled) inputRef.value.click();
		};
		onBeforeUnmount(() => {
			urls.forEach((url) => URL.revokeObjectURL(url));
		});
		useExpose({
			chooseFile,
			reuploadFile,
			closeImagePreview
		});
		useCustomFieldValue(() => props$1.modelValue);
		return () => createVNode("div", { "class": bem$1() }, [createVNode("div", { "class": bem$1("wrapper", { disabled: props$1.disabled }) }, [renderPreviewList(), renderUpload()])]);
	}
});

//#endregion
//#region node_modules/vant/es/uploader/index.mjs
var Uploader = withInstall(stdin_default$5);

//#endregion
//#region node_modules/vant/es/watermark/Watermark.mjs
var [name, bem] = createNamespace("watermark");
var watermarkProps = {
	gapX: makeNumberProp(0),
	gapY: makeNumberProp(0),
	image: String,
	width: makeNumberProp(100),
	height: makeNumberProp(100),
	rotate: makeNumericProp(-22),
	zIndex: numericProp,
	content: String,
	opacity: numericProp,
	fullPage: truthProp,
	textColor: makeStringProp("#dcdee0")
};
var stdin_default$4 = defineComponent({
	name,
	props: watermarkProps,
	setup(props$1, { slots }) {
		const svgElRef = ref();
		const watermarkUrl = ref("");
		const imageBase64 = ref("");
		const renderWatermark = () => {
			const rotateStyle = {
				transformOrigin: "center",
				transform: `rotate(${props$1.rotate}deg)`
			};
			const svgInner = () => {
				if (props$1.image && !slots.content) return createVNode("image", {
					"href": imageBase64.value,
					"xlink:href": imageBase64.value,
					"x": "0",
					"y": "0",
					"width": props$1.width,
					"height": props$1.height,
					"style": rotateStyle
				}, null);
				return createVNode("foreignObject", {
					"x": "0",
					"y": "0",
					"width": props$1.width,
					"height": props$1.height
				}, [createVNode("div", {
					"xmlns": "http://www.w3.org/1999/xhtml",
					"style": rotateStyle
				}, [slots.content ? slots.content() : createVNode("span", { "style": { color: props$1.textColor } }, [props$1.content])])]);
			};
			const svgWidth = props$1.width + props$1.gapX;
			const svgHeight = props$1.height + props$1.gapY;
			return createVNode("svg", {
				"viewBox": `0 0 ${svgWidth} ${svgHeight}`,
				"width": svgWidth,
				"height": svgHeight,
				"xmlns": "http://www.w3.org/2000/svg",
				"xmlns:xlink": "http://www.w3.org/1999/xlink",
				"style": {
					padding: `0 ${props$1.gapX}px ${props$1.gapY}px 0`,
					opacity: props$1.opacity
				}
			}, [svgInner()]);
		};
		const makeImageToBase64 = (url) => {
			const canvas = document.createElement("canvas");
			const image = new Image();
			image.crossOrigin = "anonymous";
			image.referrerPolicy = "no-referrer";
			image.onload = () => {
				canvas.width = image.naturalWidth;
				canvas.height = image.naturalHeight;
				canvas.getContext("2d")?.drawImage(image, 0, 0);
				imageBase64.value = canvas.toDataURL();
			};
			image.src = url;
		};
		const makeSvgToBlobUrl = (svgStr) => {
			const svgBlob = new Blob([svgStr], { type: "image/svg+xml" });
			return URL.createObjectURL(svgBlob);
		};
		const revokeWatermarkUrl = () => {
			if (watermarkUrl.value) URL.revokeObjectURL(watermarkUrl.value);
		};
		const generateWatermarkUrl = () => {
			if (svgElRef.value) {
				revokeWatermarkUrl();
				watermarkUrl.value = makeSvgToBlobUrl(svgElRef.value.innerHTML);
			}
		};
		watchEffect(() => {
			if (props$1.image) makeImageToBase64(props$1.image);
		});
		watch(() => [
			props$1.content,
			props$1.textColor,
			props$1.height,
			props$1.width,
			props$1.rotate,
			props$1.gapX,
			props$1.gapY
		], generateWatermarkUrl);
		watch(imageBase64, () => {
			nextTick(generateWatermarkUrl);
		});
		onMounted(generateWatermarkUrl);
		onUnmounted(revokeWatermarkUrl);
		return () => {
			const style = extend({ backgroundImage: `url(${watermarkUrl.value})` }, getZIndexStyle(props$1.zIndex));
			return createVNode("div", {
				"class": bem({ full: props$1.fullPage }),
				"style": style
			}, [createVNode("div", {
				"class": bem("wrapper"),
				"ref": svgElRef
			}, [renderWatermark()])]);
		};
	}
});

//#endregion
//#region node_modules/vant/es/watermark/index.mjs
var Watermark = withInstall(stdin_default$4);

//#endregion
//#region node_modules/vant/es/lazyload/vue-lazyload/listener.mjs
var ReactiveListener = class {
	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);
	}
	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(event) {
		this.performanceData[event] = Date.now();
	}
	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();
		}
	}
	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;
	}
	filter() {
		Object.keys(this.options.filter).forEach((key) => {
			this.options.filter[key](this, this.options);
		});
	}
	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;
			if (!this.options.silent) console.warn(`[@vant/lazyload] load failed with loading image(${this.loading})`);
		});
	}
	load(onFinish = noop) {
		if (this.attempt > this.options.attempt - 1 && this.state.error) {
			if (!this.options.silent) console.log(`[@vant/lazyload] ${this.src} tried too more than ${this.options.attempt} times`);
			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 || _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(state, cache) {
		this.elRenderer(this, state, cache);
	}
	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() {
		this.el = null;
		this.src = null;
		this.error = null;
		this.loading = null;
		this.bindType = null;
		this.attempt = 0;
	}
};

//#endregion
//#region node_modules/vant/es/lazyload/vue-lazyload/lazy.mjs
var DEFAULT_URL = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
var DEFAULT_EVENTS = [
	"scroll",
	"wheel",
	"mousewheel",
	"resize",
	"animationend",
	"transitionend",
	"touchmove"
];
var DEFAULT_OBSERVER_OPTIONS = {
	rootMargin: "0px",
	threshold: 0
};
function stdin_default$1() {
	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());
		}
		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(el, binding, vnode) {
			if (this.listeners.some((item) => item.el === el)) {
				this.update(el, binding);
				return nextTick(this.lazyLoadHandler);
			}
			const value = this.valueFormatter(binding.value);
			let { src } = value;
			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(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();
				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();
			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();
			}
		}
		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();
			}
		}
		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;
		}
		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;
					}
				}
			});
		}
		initListen(el, start$1) {
			this.options.ListenEvents.forEach((evt) => (start$1 ? 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);
				if (!listener.checkInView()) 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)) {
				if (!value.src && !this.options.silent) console.error("[@vant/lazyload] miss src with " + value);
				({src} = value);
				loading = value.loading || this.options.loading;
				error = value.error || this.options.error;
			}
			return {
				src,
				loading,
				error
			};
		}
	};
}

//#endregion
//#region node_modules/vant/es/lazyload/vue-lazyload/lazy-component.mjs
var stdin_default$2 = (lazy) => ({
	props: { tag: {
		type: String,
		default: "div"
	} },
	emits: ["show"],
	render() {
		return 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;
		}
	}
});

//#endregion
//#region node_modules/vant/es/lazyload/vue-lazyload/lazy-container.mjs
var defaultOptions = { selector: "img" };
var LazyContainer = class {
	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);
		this.getImgs().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() {
		this.getImgs().forEach((el) => this.lazy.remove(el));
		this.vnode = null;
		this.binding = null;
		this.lazy = null;
	}
};
var LazyContainerManager = class {
	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);
	}
};

//#endregion
//#region node_modules/vant/es/lazyload/vue-lazyload/lazy-image.mjs
var stdin_default$3 = (lazyManager) => ({
	props: {
		src: [String, Object],
		tag: {
			type: String,
			default: "img"
		}
	},
	render() {
		var _a, _b;
		return 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) {
				if (!lazyManager.options.silent) console.log(`[@vant/lazyload] ${this.options.src} tried too more than ${this.options.attempt} times`);
				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;
			});
		}
	}
});

//#endregion
//#region node_modules/vant/es/lazyload/vue-lazyload/index.mjs
var Lazyload = { install(app, options = {}) {
	const lazy = new (stdin_default$1())(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$3(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)
	});
} };

//#endregion
//#region node_modules/vant/es/index.mjs
var version = "4.9.21";
function install(app) {
	[
		ActionBar,
		ActionBarButton,
		ActionBarIcon,
		ActionSheet,
		AddressEdit,
		AddressList,
		Area,
		BackTop,
		Badge,
		Barrage,
		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,
		FloatingBubble,
		FloatingPanel,
		Form,
		Grid,
		GridItem,
		Highlight,
		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,
		RollingText,
		Row,
		Search,
		ShareSheet,
		Sidebar,
		SidebarItem,
		Signature,
		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,
		Watermark
	].forEach((item) => {
		if (item.install) app.use(item);
		else if (item.name) app.component(item.name, item);
	});
}
var stdin_default = {
	install,
	version
};

//#endregion
export { RollingText as $, CheckboxGroup as $n, Icon as $r, resetDialogDefaultOptions as $t, Slider as A, circleProps as An, tabProps as Ar, indexAnchorProps as At, skeletonAvatarProps as B, calendarProps as Bn, actionSheetProps as Br, gridProps as Bt, Steps as C, collapseItemProps as Cn, Area as Cr, noticeBarProps as Ct, stepsProps as D, colProps as Dn, pickerGroupProps as Dr, listProps as Dt, Step as E, Col as En, pickerProps as Er, List as Et, skeletonProps as F, Card as Fn, Swipe as Fr, Highlight as Ft, sidebarItemProps as G, AddressList as Gn, ActionBarIcon as Gr, DropdownMenu as Gt, skeletonTitleProps as H, barrageProps as Hn, popupProps$2 as Hr, floatingPanelProps as Ht, SkeletonParagraph as I, cardProps as In, swipeProps as Ir, highlightProps as It, ShareSheet as J, checkboxProps as Jn, actionBarButtonProps as Jr, dropdownMenuProps as Jt, Sidebar as K, addressListProps as Kn, actionBarIconProps as Kr, DropdownItem as Kt, DEFAULT_ROW_WIDTH as L, Image$1 as Ln, Sticky as Lr, GridItem as Lt, SkeletonImage as M, cellGroupProps as Mn, useAllTabStatus as Mr, ImagePreview as Mt, skeletonImageProps as N, Cascader as Nn, useTabStatus as Nr, showImagePreview as Nt, Space as O, rowProps as On, Tabs as Or, IndexBar as Ot, Skeleton as P, cascaderProps as Pn, tabsProps as Pr, imagePreviewProps as Pt, Row as Q, tagProps as Qn, loadingProps as Qr, closeDialog as Qt, skeletonParagraphProps as R, imageProps as Rn, stickyProps as Rr, gridItemProps as Rt, submitBarProps as S, CollapseItem as Sn, cellProps as Sr, NoticeBar as St, stepperProps as T, collapseProps as Tn, Picker as Tr, navBarProps as Tt, Signature as U, BackTop as Un, Overlay as Ur, FloatingBubble as Ut, SkeletonTitle as V, Barrage as Vn, Popup as Vr, FloatingPanel as Vt, SidebarItem as W, backTopProps as Wn, overlayProps as Wr, floatingBubbleProps as Wt, Search as X, radioProps as Xn, buttonProps as Xr, dividerProps as Xt, shareSheetProps as Y, Radio as Yn, Button as Yr, Divider as Yt, searchProps as Z, Tag as Zn, Loading as Zr, Dialog as Zt, Tabbar as _, ContactEdit as _n, Field as _r, closeNotify as _t, Watermark as a, actionBarProps as ai, datePickerProps as an, Switch as ar, Progress as at, swipeCellProps as b, contactCardProps as bn, formProps as br, showNotify as bt, uploaderProps as c, Empty as cn, allowMultipleToast as cr, popoverProps as ct, TimePicker as d, couponCellProps as dn, setToastDefaultOptions as dr, passwordInputProps as dt, iconProps as ei, setDialogDefaultOptions as en, checkboxGroupProps as er, rollingTextProps as et, timePickerProps as f, Coupon as fn, showFailToast as fr, Pagination as ft, tabbarItemProps as g, contactListProps as gn, toastProps as gr, Notify as gt, TabbarItem as h, ContactList as hn, showToast as hr, numberKeyboardProps as ht, Lazyload as i, ActionBar as ii, DatePicker as in, addressEditProps as ir, pullRefreshProps as it, sliderProps as j, CellGroup as jn, SwipeItem as jr, indexBarProps as jt, spaceProps as k, Circle as kn, Tab as kr, IndexAnchor as kt, TreeSelect as l, emptyProps as ln, closeToast as lr, PickerGroup as lt, textEllipsisProps as m, countDownProps as mn, showSuccessToast as mr, NumberKeyboard as mt, stdin_default as n, Badge as ni, showDialog as nn, radioGroupProps as nr, rateProps as nt, watermarkProps as o, Locale as oi, CouponList as on, switchProps as or, progressProps as ot, TextEllipsis as p, CountDown as pn, showLoadingToast as pr, paginationProps as pt, sidebarProps as q, Checkbox as qn, ActionBarButton as qr, dropdownItemProps as qt, version as r, badgeProps as ri, dialogProps as rn, AddressEdit as rr, PullRefresh as rt, Uploader as s, useCurrentLang as si, couponListProps as sn, Toast as sr, Popover as st, install as t, configProviderProps as ti, showConfirmDialog as tn, RadioGroup as tr, Rate as tt, treeSelectProps as u, CouponCell as un, resetToastDefaultOptions as ur, PasswordInput as ut, tabbarProps as v, contactEditProps as vn, fieldProps as vr, resetNotifyDefaultOptions as vt, Stepper as w, Collapse as wn, areaProps as wr, NavBar as wt, SubmitBar as x, ConfigProvider as xn, Cell as xr, notifyProps as xt, SwipeCell as y, ContactCard as yn, Form as yr, setNotifyDefaultOptions as yt, SkeletonAvatar as z, Calendar as zn, ActionSheet as zr, Grid as zt };
//# sourceMappingURL=es-BJC2c_PX.js.map