import { Ar as slotFlagsText, Cr as isVoidTag, Fr as __esm, Ir as __export$268, Lr as __toCommonJS$269, Nr as toHandlerKey, Or as parseStringStyle, Pr as __commonJS, Sr as isSymbol, _r as isObject, ar as NO, br as isSVGTag, cr as camelize$1, dr as generateCodeFrame, fr as init_shared_esm_bundler, gr as isMathMLTag, hr as isHTMLTag, ir as EMPTY_OBJ, kr as shared_esm_bundler_exports, lr as capitalize, m as runtime_dom_esm_bundler_exports, mr as isBuiltInDirective, or as NOOP, pr as isArray, sr as PatchFlagNames, u as init_runtime_dom_esm_bundler, ur as extend, vr as isOn, wr as makeMap, xr as isString, yr as isReservedProp } from "./runtime-dom.esm-bundler-Oj6WMcVd.js";

//#region node_modules/vant/lib/utils/basic.js
var require_basic = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/basic.js": ((exports, module) => {
	var __defProp$268 = Object.defineProperty;
	var __getOwnPropDesc$268 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$268 = Object.getOwnPropertyNames;
	var __hasOwnProp$268 = Object.prototype.hasOwnProperty;
	var __export$267 = (target, all) => {
		for (var name$111 in all) __defProp$268(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$268 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$268(from)) if (!__hasOwnProp$268.call(to, key) && key !== except) __defProp$268(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$268(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$268 = (mod) => __copyProps$268(__defProp$268({}, "__esModule", { value: true }), mod);
	var stdin_exports$266 = {};
	__export$267(stdin_exports$266, {
		extend: () => extend$1,
		flat: () => flat,
		get: () => get,
		inBrowser: () => inBrowser$1,
		isDate: () => isDate,
		isDef: () => isDef,
		isFunction: () => isFunction,
		isIOS: () => isIOS$1,
		isMobile: () => isMobile,
		isNumeric: () => isNumeric,
		isObject: () => isObject$1,
		isPromise: () => isPromise,
		isSameValue: () => isSameValue,
		noop: () => noop,
		pick: () => pick,
		toArray: () => toArray
	});
	module.exports = __toCommonJS$268(stdin_exports$266);
	function noop() {}
	var extend$1 = Object.assign;
	var inBrowser$1 = typeof window !== "undefined";
	var isObject$1 = (val) => val !== null && typeof val === "object";
	var isDef = (val) => val !== void 0 && val !== null;
	var isFunction = (val) => typeof val === "function";
	var isPromise = (val) => isObject$1(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$1 = () => 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$1(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/lib/utils/props.js
var require_props = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/props.js": ((exports, module) => {
	var __defProp$267 = Object.defineProperty;
	var __getOwnPropDesc$267 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$267 = Object.getOwnPropertyNames;
	var __hasOwnProp$267 = Object.prototype.hasOwnProperty;
	var __export$266 = (target, all) => {
		for (var name$111 in all) __defProp$267(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$267 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$267(from)) if (!__hasOwnProp$267.call(to, key) && key !== except) __defProp$267(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$267(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$267 = (mod) => __copyProps$267(__defProp$267({}, "__esModule", { value: true }), mod);
	var stdin_exports$265 = {};
	__export$266(stdin_exports$265, {
		makeArrayProp: () => makeArrayProp,
		makeNumberProp: () => makeNumberProp,
		makeNumericProp: () => makeNumericProp,
		makeRequiredProp: () => makeRequiredProp,
		makeStringProp: () => makeStringProp,
		numericProp: () => numericProp,
		truthProp: () => truthProp,
		unknownProp: () => unknownProp
	});
	module.exports = __toCommonJS$267(stdin_exports$265);
	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/@vue/compiler-core/dist/compiler-core.esm-bundler.js
function registerRuntimeHelpers(helpers) {
	Object.getOwnPropertySymbols(helpers).forEach((s) => {
		helperNameMap[s] = helpers[s];
	});
}
function createRoot(children, source = "") {
	return {
		type: 0,
		source,
		children,
		helpers: /* @__PURE__ */ new Set(),
		components: [],
		directives: [],
		hoists: [],
		imports: [],
		cached: [],
		temps: 0,
		codegenNode: void 0,
		loc: locStub
	};
}
function createVNodeCall(context, tag, props$1, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent$1 = false, loc = locStub) {
	if (context) {
		if (isBlock) {
			context.helper(OPEN_BLOCK);
			context.helper(getVNodeBlockHelper(context.inSSR, isComponent$1));
		} else context.helper(getVNodeHelper(context.inSSR, isComponent$1));
		if (directives) context.helper(WITH_DIRECTIVES);
	}
	return {
		type: 13,
		tag,
		props: props$1,
		children,
		patchFlag,
		dynamicProps,
		directives,
		isBlock,
		disableTracking,
		isComponent: isComponent$1,
		loc
	};
}
function createArrayExpression(elements, loc = locStub) {
	return {
		type: 17,
		loc,
		elements
	};
}
function createObjectExpression(properties, loc = locStub) {
	return {
		type: 15,
		loc,
		properties
	};
}
function createObjectProperty(key, value) {
	return {
		type: 16,
		loc: locStub,
		key: isString(key) ? createSimpleExpression(key, true) : key,
		value
	};
}
function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
	return {
		type: 4,
		loc,
		content,
		isStatic,
		constType: isStatic ? 3 : constType
	};
}
function createInterpolation(content, loc) {
	return {
		type: 5,
		loc,
		content: isString(content) ? createSimpleExpression(content, false, loc) : content
	};
}
function createCompoundExpression(children, loc = locStub) {
	return {
		type: 8,
		loc,
		children
	};
}
function createCallExpression(callee, args = [], loc = locStub) {
	return {
		type: 14,
		loc,
		callee,
		arguments: args
	};
}
function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
	return {
		type: 18,
		params,
		returns,
		newline,
		isSlot,
		loc
	};
}
function createConditionalExpression(test, consequent, alternate, newline = true) {
	return {
		type: 19,
		test,
		consequent,
		alternate,
		newline,
		loc: locStub
	};
}
function createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) {
	return {
		type: 20,
		index,
		value,
		needPauseTracking,
		inVOnce,
		needArraySpread: false,
		loc: locStub
	};
}
function createBlockStatement(body) {
	return {
		type: 21,
		body,
		loc: locStub
	};
}
function createTemplateLiteral(elements) {
	return {
		type: 22,
		elements,
		loc: locStub
	};
}
function createIfStatement(test, consequent, alternate) {
	return {
		type: 23,
		test,
		consequent,
		alternate,
		loc: locStub
	};
}
function createAssignmentExpression(left$1, right$1) {
	return {
		type: 24,
		left: left$1,
		right: right$1,
		loc: locStub
	};
}
function createSequenceExpression(expressions) {
	return {
		type: 25,
		expressions,
		loc: locStub
	};
}
function createReturnStatement(returns) {
	return {
		type: 26,
		returns,
		loc: locStub
	};
}
function getVNodeHelper(ssr, isComponent$1) {
	return ssr || isComponent$1 ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
}
function getVNodeBlockHelper(ssr, isComponent$1) {
	return ssr || isComponent$1 ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
}
function convertToBlock(node, { helper, removeHelper, inSSR }) {
	if (!node.isBlock) {
		node.isBlock = true;
		removeHelper(getVNodeHelper(inSSR, node.isComponent));
		helper(OPEN_BLOCK);
		helper(getVNodeBlockHelper(inSSR, node.isComponent));
	}
}
function isTagStartChar(c) {
	return c >= 97 && c <= 122 || c >= 65 && c <= 90;
}
function isWhitespace(c) {
	return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
}
function isEndOfTagSection(c) {
	return c === 47 || c === 62 || isWhitespace(c);
}
function toCharCodes(str) {
	const ret = new Uint8Array(str.length);
	for (let i = 0; i < str.length; i++) ret[i] = str.charCodeAt(i);
	return ret;
}
function getCompatValue(key, { compatConfig }) {
	const value = compatConfig && compatConfig[key];
	if (key === "MODE") return value || 3;
	else return value;
}
function isCompatEnabled(key, context) {
	const mode = getCompatValue("MODE", context);
	const value = getCompatValue(key, context);
	return mode === 3 ? value === true : value !== false;
}
function checkCompatEnabled(key, context, loc, ...args) {
	const enabled = isCompatEnabled(key, context);
	if (enabled) warnDeprecation(key, context, loc, ...args);
	return enabled;
}
function warnDeprecation(key, context, loc, ...args) {
	if (getCompatValue(key, context) === "suppress-warning") return;
	const { message, link } = deprecationData[key];
	const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? `
  Details: ${link}` : ``}`;
	const err = new SyntaxError(msg);
	err.code = key;
	if (loc) err.loc = loc;
	context.onWarn(err);
}
function defaultOnError(error) {
	throw error;
}
function defaultOnWarn(msg) {
	console.warn(`[Vue warn] ${msg.message}`);
}
function createCompilerError(code, loc, messages$1, additionalMessage) {
	const msg = (messages$1 || errorMessages)[code] + (additionalMessage || ``);
	const error = new SyntaxError(String(msg));
	error.code = code;
	error.loc = loc;
	return error;
}
function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {}
function isReferencedIdentifier(id, parent, parentStack) {
	return false;
}
function isInDestructureAssignment(parent, parentStack) {
	if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
		let i = parentStack.length;
		while (i--) {
			const p = parentStack[i];
			if (p.type === "AssignmentExpression") return true;
			else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) break;
		}
	}
	return false;
}
function isInNewExpression(parentStack) {
	let i = parentStack.length;
	while (i--) {
		const p = parentStack[i];
		if (p.type === "NewExpression") return true;
		else if (p.type !== "MemberExpression") break;
	}
	return false;
}
function walkFunctionParams(node, onIdent) {
	for (const p of node.params) for (const id of extractIdentifiers(p)) onIdent(id);
}
function walkBlockDeclarations(block, onIdent) {
	const body = block.type === "SwitchCase" ? block.consequent : block.body;
	for (const stmt of body) if (stmt.type === "VariableDeclaration") {
		if (stmt.declare) continue;
		for (const decl of stmt.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
	} else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
		if (stmt.declare || !stmt.id) continue;
		onIdent(stmt.id);
	} else if (isForStatement(stmt)) walkForStatement(stmt, true, onIdent);
	else if (stmt.type === "SwitchStatement") walkSwitchStatement(stmt, true, onIdent);
}
function isForStatement(stmt) {
	return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
}
function walkForStatement(stmt, isVar, onIdent) {
	const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
	if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) for (const decl of variable.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
}
function walkSwitchStatement(stmt, isVar, onIdent) {
	for (const cs of stmt.cases) {
		for (const stmt2 of cs.consequent) if (stmt2.type === "VariableDeclaration" && (stmt2.kind === "var" ? isVar : !isVar)) for (const decl of stmt2.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
		walkBlockDeclarations(cs, onIdent);
	}
}
function extractIdentifiers(param, nodes = []) {
	switch (param.type) {
		case "Identifier":
			nodes.push(param);
			break;
		case "MemberExpression":
			let object = param;
			while (object.type === "MemberExpression") object = object.object;
			nodes.push(object);
			break;
		case "ObjectPattern":
			for (const prop of param.properties) if (prop.type === "RestElement") extractIdentifiers(prop.argument, nodes);
			else extractIdentifiers(prop.value, nodes);
			break;
		case "ArrayPattern":
			param.elements.forEach((element) => {
				if (element) extractIdentifiers(element, nodes);
			});
			break;
		case "RestElement":
			extractIdentifiers(param.argument, nodes);
			break;
		case "AssignmentPattern":
			extractIdentifiers(param.left, nodes);
			break;
	}
	return nodes;
}
function unwrapTSNode(node) {
	if (TS_NODE_TYPES.includes(node.type)) return unwrapTSNode(node.expression);
	else return node;
}
function isCoreComponent(tag) {
	switch (tag) {
		case "Teleport":
		case "teleport": return TELEPORT;
		case "Suspense":
		case "suspense": return SUSPENSE;
		case "KeepAlive":
		case "keep-alive": return KEEP_ALIVE;
		case "BaseTransition":
		case "base-transition": return BASE_TRANSITION;
	}
}
function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
	return advancePositionWithMutation({
		offset: pos.offset,
		line: pos.line,
		column: pos.column
	}, source, numberOfCharacters);
}
function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
	let linesCount = 0;
	let lastNewLinePos = -1;
	for (let i = 0; i < numberOfCharacters; i++) if (source.charCodeAt(i) === 10) {
		linesCount++;
		lastNewLinePos = i;
	}
	pos.offset += numberOfCharacters;
	pos.line += linesCount;
	pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
	return pos;
}
function assert(condition, msg) {
	if (!condition) throw new Error(msg || `unexpected compiler condition`);
}
function findDir(node, name$111, allowEmpty = false) {
	for (let i = 0; i < node.props.length; i++) {
		const p = node.props[i];
		if (p.type === 7 && (allowEmpty || p.exp) && (isString(name$111) ? p.name === name$111 : name$111.test(p.name))) return p;
	}
}
function findProp(node, name$111, dynamicOnly = false, allowEmpty = false) {
	for (let i = 0; i < node.props.length; i++) {
		const p = node.props[i];
		if (p.type === 6) {
			if (dynamicOnly) continue;
			if (p.name === name$111 && (p.value || allowEmpty)) return p;
		} else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name$111)) return p;
	}
}
function isStaticArgOf(arg, name$111) {
	return !!(arg && isStaticExp(arg) && arg.content === name$111);
}
function hasDynamicKeyVBind(node) {
	return node.props.some((p) => p.type === 7 && p.name === "bind" && (!p.arg || p.arg.type !== 4 || !p.arg.isStatic));
}
function isText$1(node) {
	return node.type === 5 || node.type === 2;
}
function isVPre(p) {
	return p.type === 7 && p.name === "pre";
}
function isVSlot(p) {
	return p.type === 7 && p.name === "slot";
}
function isTemplateNode(node) {
	return node.type === 1 && node.tagType === 3;
}
function isSlotOutlet(node) {
	return node.type === 1 && node.tagType === 2;
}
function getUnnormalizedProps(props$1, callPath = []) {
	if (props$1 && !isString(props$1) && props$1.type === 14) {
		const callee = props$1.callee;
		if (!isString(callee) && propsHelperSet.has(callee)) return getUnnormalizedProps(props$1.arguments[0], callPath.concat(props$1));
	}
	return [props$1, callPath];
}
function injectProp(node, prop, context) {
	let propsWithInjection;
	let props$1 = node.type === 13 ? node.props : node.arguments[2];
	let callPath = [];
	let parentCall;
	if (props$1 && !isString(props$1) && props$1.type === 14) {
		const ret = getUnnormalizedProps(props$1);
		props$1 = ret[0];
		callPath = ret[1];
		parentCall = callPath[callPath.length - 1];
	}
	if (props$1 == null || isString(props$1)) propsWithInjection = createObjectExpression([prop]);
	else if (props$1.type === 14) {
		const first = props$1.arguments[0];
		if (!isString(first) && first.type === 15) {
			if (!hasProp(prop, first)) first.properties.unshift(prop);
		} else if (props$1.callee === TO_HANDLERS) propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [createObjectExpression([prop]), props$1]);
		else props$1.arguments.unshift(createObjectExpression([prop]));
		!propsWithInjection && (propsWithInjection = props$1);
	} else if (props$1.type === 15) {
		if (!hasProp(prop, props$1)) props$1.properties.unshift(prop);
		propsWithInjection = props$1;
	} else {
		propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [createObjectExpression([prop]), props$1]);
		if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) parentCall = callPath[callPath.length - 2];
	}
	if (node.type === 13) if (parentCall) parentCall.arguments[0] = propsWithInjection;
	else node.props = propsWithInjection;
	else if (parentCall) parentCall.arguments[0] = propsWithInjection;
	else node.arguments[2] = propsWithInjection;
}
function hasProp(prop, props$1) {
	let result = false;
	if (prop.key.type === 4) {
		const propKeyName = prop.key.content;
		result = props$1.properties.some((p) => p.key.type === 4 && p.key.content === propKeyName);
	}
	return result;
}
function toValidAssetId(name$111, type) {
	return `_${type}_${name$111.replace(/[^\w]/g, (searchValue, replaceValue) => {
		return searchValue === "-" ? "_" : name$111.charCodeAt(replaceValue).toString();
	})}`;
}
function hasScopeRef(node, ids) {
	if (!node || Object.keys(ids).length === 0) return false;
	switch (node.type) {
		case 1:
			for (let i = 0; i < node.props.length; i++) {
				const p = node.props[i];
				if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) return true;
			}
			return node.children.some((c) => hasScopeRef(c, ids));
		case 11:
			if (hasScopeRef(node.source, ids)) return true;
			return node.children.some((c) => hasScopeRef(c, ids));
		case 9: return node.branches.some((b) => hasScopeRef(b, ids));
		case 10:
			if (hasScopeRef(node.condition, ids)) return true;
			return node.children.some((c) => hasScopeRef(c, ids));
		case 4: return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
		case 8: return node.children.some((c) => isObject(c) && hasScopeRef(c, ids));
		case 5:
		case 12: return hasScopeRef(node.content, ids);
		case 2:
		case 3:
		case 20: return false;
		default: return false;
	}
}
function getMemoedVNodeCall(node) {
	if (node.type === 14 && node.callee === WITH_MEMO) return node.arguments[1].returns;
	else return node;
}
function isAllWhitespace(str) {
	for (let i = 0; i < str.length; i++) if (!isWhitespace(str.charCodeAt(i))) return false;
	return true;
}
function isWhitespaceText(node) {
	return node.type === 2 && isAllWhitespace(node.content) || node.type === 12 && isWhitespaceText(node.content);
}
function isCommentOrWhitespace(node) {
	return node.type === 3 || isWhitespaceText(node);
}
function parseForExpression(input) {
	const loc = input.loc;
	const exp = input.content;
	const inMatch = exp.match(forAliasRE);
	if (!inMatch) return;
	const [, LHS, RHS] = inMatch;
	const createAliasExpression = (content, offset$1, asParam = false) => {
		const start$1 = loc.start.offset + offset$1;
		return createExp(content, false, getLoc(start$1, start$1 + content.length), 0, asParam ? 1 : 0);
	};
	const result = {
		source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
		value: void 0,
		key: void 0,
		index: void 0,
		finalized: false
	};
	let valueContent = LHS.trim().replace(stripParensRE, "").trim();
	const trimmedOffset = LHS.indexOf(valueContent);
	const iteratorMatch = valueContent.match(forIteratorRE);
	if (iteratorMatch) {
		valueContent = valueContent.replace(forIteratorRE, "").trim();
		const keyContent = iteratorMatch[1].trim();
		let keyOffset;
		if (keyContent) {
			keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
			result.key = createAliasExpression(keyContent, keyOffset, true);
		}
		if (iteratorMatch[2]) {
			const indexContent = iteratorMatch[2].trim();
			if (indexContent) result.index = createAliasExpression(indexContent, exp.indexOf(indexContent, result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length), true);
		}
	}
	if (valueContent) result.value = createAliasExpression(valueContent, trimmedOffset, true);
	return result;
}
function getSlice(start$1, end$1) {
	return currentInput.slice(start$1, end$1);
}
function endOpenTag(end$1) {
	if (tokenizer.inSFCRoot) currentOpenTag.innerLoc = getLoc(end$1 + 1, end$1 + 1);
	addNode(currentOpenTag);
	const { tag, ns } = currentOpenTag;
	if (ns === 0 && currentOptions$3.isPreTag(tag)) inPre++;
	if (currentOptions$3.isVoidTag(tag)) onCloseTag(currentOpenTag, end$1);
	else {
		stack.unshift(currentOpenTag);
		if (ns === 1 || ns === 2) tokenizer.inXML = true;
	}
	currentOpenTag = null;
}
function onText(content, start$1, end$1) {
	{
		const tag = stack[0] && stack[0].tag;
		if (tag !== "script" && tag !== "style" && content.includes("&")) content = currentOptions$3.decodeEntities(content, false);
	}
	const parent = stack[0] || currentRoot;
	const lastNode = parent.children[parent.children.length - 1];
	if (lastNode && lastNode.type === 2) {
		lastNode.content += content;
		setLocEnd(lastNode.loc, end$1);
	} else parent.children.push({
		type: 2,
		content,
		loc: getLoc(start$1, end$1)
	});
}
function onCloseTag(el, end$1, isImplied = false) {
	if (isImplied) setLocEnd(el.loc, backTrack(end$1, 60));
	else setLocEnd(el.loc, lookAhead(end$1, 62) + 1);
	if (tokenizer.inSFCRoot) {
		if (el.children.length) el.innerLoc.end = extend({}, el.children[el.children.length - 1].loc.end);
		else el.innerLoc.end = extend({}, el.innerLoc.start);
		el.innerLoc.source = getSlice(el.innerLoc.start.offset, el.innerLoc.end.offset);
	}
	const { tag, ns, children } = el;
	if (!inVPre) {
		if (tag === "slot") el.tagType = 2;
		else if (isFragmentTemplate(el)) el.tagType = 3;
		else if (isComponent(el)) el.tagType = 1;
	}
	if (!tokenizer.inRCDATA) el.children = condenseWhitespace(children);
	if (ns === 0 && currentOptions$3.isIgnoreNewlineTag(tag)) {
		const first = children[0];
		if (first && first.type === 2) first.content = first.content.replace(/^\r?\n/, "");
	}
	if (ns === 0 && currentOptions$3.isPreTag(tag)) inPre--;
	if (currentVPreBoundary === el) {
		inVPre = tokenizer.inVPre = false;
		currentVPreBoundary = null;
	}
	if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions$3.ns) === 0) tokenizer.inXML = false;
	{
		const props$1 = el.props;
		if (isCompatEnabled("COMPILER_V_IF_V_FOR_PRECEDENCE", currentOptions$3)) {
			let hasIf = false;
			let hasFor = false;
			for (let i = 0; i < props$1.length; i++) {
				const p = props$1[i];
				if (p.type === 7) {
					if (p.name === "if") hasIf = true;
					else if (p.name === "for") hasFor = true;
				}
				if (hasIf && hasFor) {
					warnDeprecation("COMPILER_V_IF_V_FOR_PRECEDENCE", currentOptions$3, el.loc);
					break;
				}
			}
		}
		if (!tokenizer.inSFCRoot && isCompatEnabled("COMPILER_NATIVE_TEMPLATE", currentOptions$3) && el.tag === "template" && !isFragmentTemplate(el)) {
			warnDeprecation("COMPILER_NATIVE_TEMPLATE", currentOptions$3, el.loc);
			const parent = stack[0] || currentRoot;
			const index = parent.children.indexOf(el);
			parent.children.splice(index, 1, ...el.children);
		}
		const inlineTemplateProp = props$1.find((p) => p.type === 6 && p.name === "inline-template");
		if (inlineTemplateProp && checkCompatEnabled("COMPILER_INLINE_TEMPLATE", currentOptions$3, inlineTemplateProp.loc) && el.children.length) inlineTemplateProp.value = {
			type: 2,
			content: getSlice(el.children[0].loc.start.offset, el.children[el.children.length - 1].loc.end.offset),
			loc: inlineTemplateProp.loc
		};
	}
}
function lookAhead(index, c) {
	let i = index;
	while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
	return i;
}
function backTrack(index, c) {
	let i = index;
	while (currentInput.charCodeAt(i) !== c && i >= 0) i--;
	return i;
}
function isFragmentTemplate({ tag, props: props$1 }) {
	if (tag === "template") {
		for (let i = 0; i < props$1.length; i++) if (props$1[i].type === 7 && specialTemplateDir.has(props$1[i].name)) return true;
	}
	return false;
}
function isComponent({ tag, props: props$1 }) {
	if (currentOptions$3.isCustomElement(tag)) return false;
	if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions$3.isBuiltInComponent && currentOptions$3.isBuiltInComponent(tag) || currentOptions$3.isNativeTag && !currentOptions$3.isNativeTag(tag)) return true;
	for (let i = 0; i < props$1.length; i++) {
		const p = props$1[i];
		if (p.type === 6) {
			if (p.name === "is" && p.value) {
				if (p.value.content.startsWith("vue:")) return true;
				else if (checkCompatEnabled("COMPILER_IS_ON_ELEMENT", currentOptions$3, p.loc)) return true;
			}
		} else if (p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled("COMPILER_IS_ON_ELEMENT", currentOptions$3, p.loc)) return true;
	}
	return false;
}
function isUpperCase(c) {
	return c > 64 && c < 91;
}
function condenseWhitespace(nodes) {
	const shouldCondense = currentOptions$3.whitespace !== "preserve";
	let removedWhitespace = false;
	for (let i = 0; i < nodes.length; i++) {
		const node = nodes[i];
		if (node.type === 2) if (!inPre) {
			if (isAllWhitespace(node.content)) {
				const prev = nodes[i - 1] && nodes[i - 1].type;
				const next = nodes[i + 1] && nodes[i + 1].type;
				if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
					removedWhitespace = true;
					nodes[i] = null;
				} else node.content = " ";
			} else if (shouldCondense) node.content = condense(node.content);
		} else node.content = node.content.replace(windowsNewlineRE, "\n");
	}
	return removedWhitespace ? nodes.filter(Boolean) : nodes;
}
function hasNewlineChar(str) {
	for (let i = 0; i < str.length; i++) {
		const c = str.charCodeAt(i);
		if (c === 10 || c === 13) return true;
	}
	return false;
}
function condense(str) {
	let ret = "";
	let prevCharIsWhitespace = false;
	for (let i = 0; i < str.length; i++) if (isWhitespace(str.charCodeAt(i))) {
		if (!prevCharIsWhitespace) {
			ret += " ";
			prevCharIsWhitespace = true;
		}
	} else {
		ret += str[i];
		prevCharIsWhitespace = false;
	}
	return ret;
}
function addNode(node) {
	(stack[0] || currentRoot).children.push(node);
}
function getLoc(start$1, end$1) {
	return {
		start: tokenizer.getPos(start$1),
		end: end$1 == null ? end$1 : tokenizer.getPos(end$1),
		source: end$1 == null ? end$1 : getSlice(start$1, end$1)
	};
}
function cloneLoc(loc) {
	return getLoc(loc.start.offset, loc.end.offset);
}
function setLocEnd(loc, end$1) {
	loc.end = tokenizer.getPos(end$1);
	loc.source = getSlice(loc.start.offset, end$1);
}
function dirToAttr(dir) {
	const attr = {
		type: 6,
		name: dir.rawName,
		nameLoc: getLoc(dir.loc.start.offset, dir.loc.start.offset + dir.rawName.length),
		value: void 0,
		loc: dir.loc
	};
	if (dir.exp) {
		const loc = dir.exp.loc;
		if (loc.end.offset < dir.loc.end.offset) {
			loc.start.offset--;
			loc.start.column--;
			loc.end.offset++;
			loc.end.column++;
		}
		attr.value = {
			type: 2,
			content: dir.exp.content,
			loc
		};
	}
	return attr;
}
function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0) {
	return createSimpleExpression(content, isStatic, loc, constType);
}
function emitError(code, index, message) {
	currentOptions$3.onError(createCompilerError(code, getLoc(index, index), void 0, message));
}
function reset() {
	tokenizer.reset();
	currentOpenTag = null;
	currentProp = null;
	currentAttrValue = "";
	currentAttrStartIndex = -1;
	currentAttrEndIndex = -1;
	stack.length = 0;
}
function baseParse(input, options) {
	reset();
	currentInput = input;
	currentOptions$3 = extend({}, defaultParserOptions);
	if (options) {
		let key;
		for (key in options) if (options[key] != null) currentOptions$3[key] = options[key];
	}
	if (!currentOptions$3.decodeEntities) throw new Error(`[@vue/compiler-core] decodeEntities option is required in browser builds.`);
	tokenizer.mode = currentOptions$3.parseMode === "html" ? 1 : currentOptions$3.parseMode === "sfc" ? 2 : 0;
	tokenizer.inXML = currentOptions$3.ns === 1 || currentOptions$3.ns === 2;
	const delimiters = options && options.delimiters;
	if (delimiters) {
		tokenizer.delimiterOpen = toCharCodes(delimiters[0]);
		tokenizer.delimiterClose = toCharCodes(delimiters[1]);
	}
	const root = currentRoot = createRoot([], input);
	tokenizer.parse(currentInput);
	root.loc = getLoc(0, input.length);
	root.children = condenseWhitespace(root.children);
	currentRoot = null;
	return root;
}
function cacheStatic(root, context) {
	walk(root, void 0, context, !!getSingleElementRoot(root));
}
function getSingleElementRoot(root) {
	const children = root.children.filter((x) => x.type !== 3);
	return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null;
}
function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
	const { children } = node;
	const toCache = [];
	for (let i = 0; i < children.length; i++) {
		const child = children[i];
		if (child.type === 1 && child.tagType === 0) {
			const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
			if (constantType > 0) {
				if (constantType >= 2) {
					child.codegenNode.patchFlag = -1;
					toCache.push(child);
					continue;
				}
			} else {
				const codegenNode = child.codegenNode;
				if (codegenNode.type === 13) {
					const flag = codegenNode.patchFlag;
					if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
						const props$1 = getNodeProps(child);
						if (props$1) codegenNode.props = context.hoist(props$1);
					}
					if (codegenNode.dynamicProps) codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
				}
			}
		} else if (child.type === 12) {
			if ((doNotHoistNode ? 0 : getConstantType(child, context)) >= 2) {
				if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) child.codegenNode.arguments.push(`-1 /* ${PatchFlagNames[-1]} */`);
				toCache.push(child);
				continue;
			}
		}
		if (child.type === 1) {
			const isComponent$1 = child.tagType === 1;
			if (isComponent$1) context.scopes.vSlot++;
			walk(child, node, context, false, inFor);
			if (isComponent$1) context.scopes.vSlot--;
		} else if (child.type === 11) walk(child, node, context, child.children.length === 1, true);
		else if (child.type === 9) for (let i2 = 0; i2 < child.branches.length; i2++) walk(child.branches[i2], node, context, child.branches[i2].children.length === 1, inFor);
	}
	let cachedAsArray = false;
	if (toCache.length === children.length && node.type === 1) {
		if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray(node.codegenNode.children)) {
			node.codegenNode.children = getCacheExpression(createArrayExpression(node.codegenNode.children));
			cachedAsArray = true;
		} else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
			const slot = getSlotNode(node.codegenNode, "default");
			if (slot) {
				slot.returns = getCacheExpression(createArrayExpression(slot.returns));
				cachedAsArray = true;
			}
		} else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {
			const slotName = findDir(node, "slot", true);
			const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);
			if (slot) {
				slot.returns = getCacheExpression(createArrayExpression(slot.returns));
				cachedAsArray = true;
			}
		}
	}
	if (!cachedAsArray) for (const child of toCache) child.codegenNode = context.cache(child.codegenNode);
	function getCacheExpression(value) {
		const exp = context.cache(value);
		exp.needArraySpread = true;
		return exp;
	}
	function getSlotNode(node2, name$111) {
		if (node2.children && !isArray(node2.children) && node2.children.type === 15) {
			const slot = node2.children.properties.find((p) => p.key === name$111 || p.key.content === name$111);
			return slot && slot.value;
		}
	}
	if (toCache.length && context.transformHoist) context.transformHoist(children, context, node);
}
function getConstantType(node, context) {
	const { constantCache } = context;
	switch (node.type) {
		case 1:
			if (node.tagType !== 0) return 0;
			const cached = constantCache.get(node);
			if (cached !== void 0) return cached;
			const codegenNode = node.codegenNode;
			if (codegenNode.type !== 13) return 0;
			if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") return 0;
			if (codegenNode.patchFlag === void 0) {
				let returnType2 = 3;
				const generatedPropsType = getGeneratedPropsConstantType(node, context);
				if (generatedPropsType === 0) {
					constantCache.set(node, 0);
					return 0;
				}
				if (generatedPropsType < returnType2) returnType2 = generatedPropsType;
				for (let i = 0; i < node.children.length; i++) {
					const childType = getConstantType(node.children[i], context);
					if (childType === 0) {
						constantCache.set(node, 0);
						return 0;
					}
					if (childType < returnType2) returnType2 = childType;
				}
				if (returnType2 > 1) for (let i = 0; i < node.props.length; i++) {
					const p = node.props[i];
					if (p.type === 7 && p.name === "bind" && p.exp) {
						const expType = getConstantType(p.exp, context);
						if (expType === 0) {
							constantCache.set(node, 0);
							return 0;
						}
						if (expType < returnType2) returnType2 = expType;
					}
				}
				if (codegenNode.isBlock) {
					for (let i = 0; i < node.props.length; i++) if (node.props[i].type === 7) {
						constantCache.set(node, 0);
						return 0;
					}
					context.removeHelper(OPEN_BLOCK);
					context.removeHelper(getVNodeBlockHelper(context.inSSR, codegenNode.isComponent));
					codegenNode.isBlock = false;
					context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
				}
				constantCache.set(node, returnType2);
				return returnType2;
			} else {
				constantCache.set(node, 0);
				return 0;
			}
		case 2:
		case 3: return 3;
		case 9:
		case 11:
		case 10: return 0;
		case 5:
		case 12: return getConstantType(node.content, context);
		case 4: return node.constType;
		case 8:
			let returnType = 3;
			for (let i = 0; i < node.children.length; i++) {
				const child = node.children[i];
				if (isString(child) || isSymbol(child)) continue;
				const childType = getConstantType(child, context);
				if (childType === 0) return 0;
				else if (childType < returnType) returnType = childType;
			}
			return returnType;
		case 20: return 2;
		default: return 0;
	}
}
function getConstantTypeOfHelperCall(value, context) {
	if (value.type === 14 && !isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {
		const arg = value.arguments[0];
		if (arg.type === 4) return getConstantType(arg, context);
		else if (arg.type === 14) return getConstantTypeOfHelperCall(arg, context);
	}
	return 0;
}
function getGeneratedPropsConstantType(node, context) {
	let returnType = 3;
	const props$1 = getNodeProps(node);
	if (props$1 && props$1.type === 15) {
		const { properties } = props$1;
		for (let i = 0; i < properties.length; i++) {
			const { key, value } = properties[i];
			const keyType = getConstantType(key, context);
			if (keyType === 0) return keyType;
			if (keyType < returnType) returnType = keyType;
			let valueType;
			if (value.type === 4) valueType = getConstantType(value, context);
			else if (value.type === 14) valueType = getConstantTypeOfHelperCall(value, context);
			else valueType = 0;
			if (valueType === 0) return valueType;
			if (valueType < returnType) returnType = valueType;
		}
	}
	return returnType;
}
function getNodeProps(node) {
	const codegenNode = node.codegenNode;
	if (codegenNode.type === 13) return codegenNode.props;
}
function createTransformContext(root, { filename = "", prefixIdentifiers = false, hoistStatic = false, hmr = false, cacheHandlers = false, nodeTransforms = [], directiveTransforms = {}, transformHoist = null, isBuiltInComponent = NOOP, isCustomElement = NOOP, expressionPlugins = [], scopeId = null, slotted = true, ssr = false, inSSR = false, ssrCssVars = ``, bindingMetadata = EMPTY_OBJ, inline = false, isTS = false, onError = defaultOnError, onWarn = defaultOnWarn, compatConfig }) {
	const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
	const context = {
		filename,
		selfName: nameMatch && capitalize(camelize$1(nameMatch[1])),
		prefixIdentifiers,
		hoistStatic,
		hmr,
		cacheHandlers,
		nodeTransforms,
		directiveTransforms,
		transformHoist,
		isBuiltInComponent,
		isCustomElement,
		expressionPlugins,
		scopeId,
		slotted,
		ssr,
		inSSR,
		ssrCssVars,
		bindingMetadata,
		inline,
		isTS,
		onError,
		onWarn,
		compatConfig,
		root,
		helpers: /* @__PURE__ */ new Map(),
		components: /* @__PURE__ */ new Set(),
		directives: /* @__PURE__ */ new Set(),
		hoists: [],
		imports: [],
		cached: [],
		constantCache: /* @__PURE__ */ new WeakMap(),
		temps: 0,
		identifiers: /* @__PURE__ */ Object.create(null),
		scopes: {
			vFor: 0,
			vSlot: 0,
			vPre: 0,
			vOnce: 0
		},
		parent: null,
		grandParent: null,
		currentNode: root,
		childIndex: 0,
		inVOnce: false,
		helper(name$111) {
			const count = context.helpers.get(name$111) || 0;
			context.helpers.set(name$111, count + 1);
			return name$111;
		},
		removeHelper(name$111) {
			const count = context.helpers.get(name$111);
			if (count) {
				const currentCount = count - 1;
				if (!currentCount) context.helpers.delete(name$111);
				else context.helpers.set(name$111, currentCount);
			}
		},
		helperString(name$111) {
			return `_${helperNameMap[context.helper(name$111)]}`;
		},
		replaceNode(node) {
			if (!context.currentNode) throw new Error(`Node being replaced is already removed.`);
			if (!context.parent) throw new Error(`Cannot replace root node.`);
			context.parent.children[context.childIndex] = context.currentNode = node;
		},
		removeNode(node) {
			if (!context.parent) throw new Error(`Cannot remove root node.`);
			const list = context.parent.children;
			const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
			if (removalIndex < 0) throw new Error(`node being removed is not a child of current parent`);
			if (!node || node === context.currentNode) {
				context.currentNode = null;
				context.onNodeRemoved();
			} else if (context.childIndex > removalIndex) {
				context.childIndex--;
				context.onNodeRemoved();
			}
			context.parent.children.splice(removalIndex, 1);
		},
		onNodeRemoved: NOOP,
		addIdentifiers(exp) {},
		removeIdentifiers(exp) {},
		hoist(exp) {
			if (isString(exp)) exp = createSimpleExpression(exp);
			context.hoists.push(exp);
			const identifier = createSimpleExpression(`_hoisted_${context.hoists.length}`, false, exp.loc, 2);
			identifier.hoisted = exp;
			return identifier;
		},
		cache(exp, isVNode = false, inVOnce = false) {
			const cacheExp = createCacheExpression(context.cached.length, exp, isVNode, inVOnce);
			context.cached.push(cacheExp);
			return cacheExp;
		}
	};
	context.filters = /* @__PURE__ */ new Set();
	return context;
}
function transform(root, options) {
	const context = createTransformContext(root, options);
	traverseNode(root, context);
	if (options.hoistStatic) cacheStatic(root, context);
	if (!options.ssr) createRootCodegen(root, context);
	root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
	root.components = [...context.components];
	root.directives = [...context.directives];
	root.imports = context.imports;
	root.hoists = context.hoists;
	root.temps = context.temps;
	root.cached = context.cached;
	root.transformed = true;
	root.filters = [...context.filters];
}
function createRootCodegen(root, context) {
	const { helper } = context;
	const { children } = root;
	if (children.length === 1) {
		const singleElementRootChild = getSingleElementRoot(root);
		if (singleElementRootChild && singleElementRootChild.codegenNode) {
			const codegenNode = singleElementRootChild.codegenNode;
			if (codegenNode.type === 13) convertToBlock(codegenNode, context);
			root.codegenNode = codegenNode;
		} else root.codegenNode = children[0];
	} else if (children.length > 1) {
		let patchFlag = 64;
		if (children.filter((c) => c.type !== 3).length === 1) patchFlag |= 2048;
		root.codegenNode = createVNodeCall(context, helper(FRAGMENT), void 0, root.children, patchFlag, void 0, void 0, true, void 0, false);
	}
}
function traverseChildren(parent, context) {
	let i = 0;
	const nodeRemoved = () => {
		i--;
	};
	for (; i < parent.children.length; i++) {
		const child = parent.children[i];
		if (isString(child)) continue;
		context.grandParent = context.parent;
		context.parent = parent;
		context.childIndex = i;
		context.onNodeRemoved = nodeRemoved;
		traverseNode(child, context);
	}
}
function traverseNode(node, context) {
	context.currentNode = node;
	const { nodeTransforms } = context;
	const exitFns = [];
	for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
		const onExit = nodeTransforms[i2](node, context);
		if (onExit) if (isArray(onExit)) exitFns.push(...onExit);
		else exitFns.push(onExit);
		if (!context.currentNode) return;
		else node = context.currentNode;
	}
	switch (node.type) {
		case 3:
			if (!context.ssr) context.helper(CREATE_COMMENT);
			break;
		case 5:
			if (!context.ssr) context.helper(TO_DISPLAY_STRING);
			break;
		case 9:
			for (let i2 = 0; i2 < node.branches.length; i2++) traverseNode(node.branches[i2], context);
			break;
		case 10:
		case 11:
		case 1:
		case 0:
			traverseChildren(node, context);
			break;
	}
	context.currentNode = node;
	let i = exitFns.length;
	while (i--) exitFns[i]();
}
function createStructuralDirectiveTransform(name$111, fn) {
	const matches = isString(name$111) ? (n) => n === name$111 : (n) => name$111.test(n);
	return (node, context) => {
		if (node.type === 1) {
			const { props: props$1 } = node;
			if (node.tagType === 3 && props$1.some(isVSlot)) return;
			const exitFns = [];
			for (let i = 0; i < props$1.length; i++) {
				const prop = props$1[i];
				if (prop.type === 7 && matches(prop.name)) {
					props$1.splice(i, 1);
					i--;
					const onExit = fn(node, prop, context);
					if (onExit) exitFns.push(onExit);
				}
			}
			return exitFns;
		}
	};
}
function createCodegenContext(ast, { mode = "function", prefixIdentifiers = mode === "module", sourceMap = false, filename = `template.vue.html`, scopeId = null, optimizeImports = false, runtimeGlobalName = `Vue`, runtimeModuleName = `vue`, ssrRuntimeModuleName = "vue/server-renderer", ssr = false, isTS = false, inSSR = false }) {
	const context = {
		mode,
		prefixIdentifiers,
		sourceMap,
		filename,
		scopeId,
		optimizeImports,
		runtimeGlobalName,
		runtimeModuleName,
		ssrRuntimeModuleName,
		ssr,
		isTS,
		inSSR,
		source: ast.source,
		code: ``,
		column: 1,
		line: 1,
		offset: 0,
		indentLevel: 0,
		pure: false,
		map: void 0,
		helper(key) {
			return `_${helperNameMap[key]}`;
		},
		push(code, newlineIndex = -2, node) {
			context.code += code;
		},
		indent() {
			newline(++context.indentLevel);
		},
		deindent(withoutNewLine = false) {
			if (withoutNewLine) --context.indentLevel;
			else newline(--context.indentLevel);
		},
		newline() {
			newline(context.indentLevel);
		}
	};
	function newline(n) {
		context.push("\n" + `  `.repeat(n), 0);
	}
	return context;
}
function generate(ast, options = {}) {
	const context = createCodegenContext(ast, options);
	if (options.onContextCreated) options.onContextCreated(context);
	const { mode, push, prefixIdentifiers, indent, deindent, newline, scopeId, ssr } = context;
	const helpers = Array.from(ast.helpers);
	const hasHelpers = helpers.length > 0;
	const useWithBlock = !prefixIdentifiers && mode !== "module";
	genFunctionPreamble(ast, context);
	push(`function ${ssr ? `ssrRender` : `render`}(${(ssr ? [
		"_ctx",
		"_push",
		"_parent",
		"_attrs"
	] : ["_ctx", "_cache"]).join(", ")}) {`);
	indent();
	if (useWithBlock) {
		push(`with (_ctx) {`);
		indent();
		if (hasHelpers) {
			push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue
`, -1);
			newline();
		}
	}
	if (ast.components.length) {
		genAssets(ast.components, "component", context);
		if (ast.directives.length || ast.temps > 0) newline();
	}
	if (ast.directives.length) {
		genAssets(ast.directives, "directive", context);
		if (ast.temps > 0) newline();
	}
	if (ast.filters && ast.filters.length) {
		newline();
		genAssets(ast.filters, "filter", context);
		newline();
	}
	if (ast.temps > 0) {
		push(`let `);
		for (let i = 0; i < ast.temps; i++) push(`${i > 0 ? `, ` : ``}_temp${i}`);
	}
	if (ast.components.length || ast.directives.length || ast.temps) {
		push(`
`, 0);
		newline();
	}
	if (!ssr) push(`return `);
	if (ast.codegenNode) genNode(ast.codegenNode, context);
	else push(`null`);
	if (useWithBlock) {
		deindent();
		push(`}`);
	}
	deindent();
	push(`}`);
	return {
		ast,
		code: context.code,
		preamble: ``,
		map: context.map ? context.map.toJSON() : void 0
	};
}
function genFunctionPreamble(ast, context) {
	const { ssr, prefixIdentifiers, push, newline, runtimeModuleName, runtimeGlobalName, ssrRuntimeModuleName } = context;
	const VueBinding = runtimeGlobalName;
	const helpers = Array.from(ast.helpers);
	if (helpers.length > 0) {
		push(`const _Vue = ${VueBinding}
`, -1);
		if (ast.hoists.length) push(`const { ${[
			CREATE_VNODE,
			CREATE_ELEMENT_VNODE,
			CREATE_COMMENT,
			CREATE_TEXT,
			CREATE_STATIC
		].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ")} } = _Vue
`, -1);
	}
	genHoists(ast.hoists, context);
	newline();
	push(`return `);
}
function genAssets(assets, type, { helper, push, newline, isTS }) {
	const resolver = helper(type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE);
	for (let i = 0; i < assets.length; i++) {
		let id = assets[i];
		const maybeSelfReference = id.endsWith("__self");
		if (maybeSelfReference) id = id.slice(0, -6);
		push(`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`);
		if (i < assets.length - 1) newline();
	}
}
function genHoists(hoists, context) {
	if (!hoists.length) return;
	context.pure = true;
	const { push, newline } = context;
	newline();
	for (let i = 0; i < hoists.length; i++) {
		const exp = hoists[i];
		if (exp) {
			push(`const _hoisted_${i + 1} = `);
			genNode(exp, context);
			newline();
		}
	}
	context.pure = false;
}
function isText(n) {
	return isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
}
function genNodeListAsArray(nodes, context) {
	const multilines = nodes.length > 3 || nodes.some((n) => isArray(n) || !isText(n));
	context.push(`[`);
	multilines && context.indent();
	genNodeList(nodes, context, multilines);
	multilines && context.deindent();
	context.push(`]`);
}
function genNodeList(nodes, context, multilines = false, comma = true) {
	const { push, newline } = context;
	for (let i = 0; i < nodes.length; i++) {
		const node = nodes[i];
		if (isString(node)) push(node, -3);
		else if (isArray(node)) genNodeListAsArray(node, context);
		else genNode(node, context);
		if (i < nodes.length - 1) if (multilines) {
			comma && push(",");
			newline();
		} else comma && push(", ");
	}
}
function genNode(node, context) {
	if (isString(node)) {
		context.push(node, -3);
		return;
	}
	if (isSymbol(node)) {
		context.push(context.helper(node));
		return;
	}
	switch (node.type) {
		case 1:
		case 9:
		case 11:
			assert(node.codegenNode != null, `Codegen node is missing for element/if/for node. Apply appropriate transforms first.`);
			genNode(node.codegenNode, context);
			break;
		case 2:
			genText(node, context);
			break;
		case 4:
			genExpression(node, context);
			break;
		case 5:
			genInterpolation(node, context);
			break;
		case 12:
			genNode(node.codegenNode, context);
			break;
		case 8:
			genCompoundExpression(node, context);
			break;
		case 3:
			genComment(node, context);
			break;
		case 13:
			genVNodeCall(node, context);
			break;
		case 14:
			genCallExpression(node, context);
			break;
		case 15:
			genObjectExpression(node, context);
			break;
		case 17:
			genArrayExpression(node, context);
			break;
		case 18:
			genFunctionExpression(node, context);
			break;
		case 19:
			genConditionalExpression(node, context);
			break;
		case 20:
			genCacheExpression(node, context);
			break;
		case 21:
			genNodeList(node.body, context, true, false);
			break;
		case 22: break;
		case 23: break;
		case 24: break;
		case 25: break;
		case 26: break;
		case 10: break;
		default:
			assert(false, `unhandled codegen node type: ${node.type}`);
			return node;
	}
}
function genText(node, context) {
	context.push(JSON.stringify(node.content), -3, node);
}
function genExpression(node, context) {
	const { content, isStatic } = node;
	context.push(isStatic ? JSON.stringify(content) : content, -3, node);
}
function genInterpolation(node, context) {
	const { push, helper, pure } = context;
	if (pure) push(PURE_ANNOTATION);
	push(`${helper(TO_DISPLAY_STRING)}(`);
	genNode(node.content, context);
	push(`)`);
}
function genCompoundExpression(node, context) {
	for (let i = 0; i < node.children.length; i++) {
		const child = node.children[i];
		if (isString(child)) context.push(child, -3);
		else genNode(child, context);
	}
}
function genExpressionAsPropertyKey(node, context) {
	const { push } = context;
	if (node.type === 8) {
		push(`[`);
		genCompoundExpression(node, context);
		push(`]`);
	} else if (node.isStatic) push(isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content), -2, node);
	else push(`[${node.content}]`, -3, node);
}
function genComment(node, context) {
	const { push, helper, pure } = context;
	if (pure) push(PURE_ANNOTATION);
	push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, -3, node);
}
function genVNodeCall(node, context) {
	const { push, helper, pure } = context;
	const { tag, props: props$1, children, patchFlag, dynamicProps, directives, isBlock, disableTracking, isComponent: isComponent$1 } = node;
	let patchFlagString;
	if (patchFlag) if (patchFlag < 0) patchFlagString = patchFlag + ` /* ${PatchFlagNames[patchFlag]} */`;
	else patchFlagString = patchFlag + ` /* ${Object.keys(PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => PatchFlagNames[n]).join(`, `)} */`;
	if (directives) push(helper(WITH_DIRECTIVES) + `(`);
	if (isBlock) push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
	if (pure) push(PURE_ANNOTATION);
	push(helper(isBlock ? getVNodeBlockHelper(context.inSSR, isComponent$1) : getVNodeHelper(context.inSSR, isComponent$1)) + `(`, -2, node);
	genNodeList(genNullableArgs([
		tag,
		props$1,
		children,
		patchFlagString,
		dynamicProps
	]), context);
	push(`)`);
	if (isBlock) push(`)`);
	if (directives) {
		push(`, `);
		genNode(directives, context);
		push(`)`);
	}
}
function genNullableArgs(args) {
	let i = args.length;
	while (i--) if (args[i] != null) break;
	return args.slice(0, i + 1).map((arg) => arg || `null`);
}
function genCallExpression(node, context) {
	const { push, helper, pure } = context;
	const callee = isString(node.callee) ? node.callee : helper(node.callee);
	if (pure) push(PURE_ANNOTATION);
	push(callee + `(`, -2, node);
	genNodeList(node.arguments, context);
	push(`)`);
}
function genObjectExpression(node, context) {
	const { push, indent, deindent, newline } = context;
	const { properties } = node;
	if (!properties.length) {
		push(`{}`, -2, node);
		return;
	}
	const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);
	push(multilines ? `{` : `{ `);
	multilines && indent();
	for (let i = 0; i < properties.length; i++) {
		const { key, value } = properties[i];
		genExpressionAsPropertyKey(key, context);
		push(`: `);
		genNode(value, context);
		if (i < properties.length - 1) {
			push(`,`);
			newline();
		}
	}
	multilines && deindent();
	push(multilines ? `}` : ` }`);
}
function genArrayExpression(node, context) {
	genNodeListAsArray(node.elements, context);
}
function genFunctionExpression(node, context) {
	const { push, indent, deindent } = context;
	const { params, returns, body, newline, isSlot } = node;
	if (isSlot) push(`_${helperNameMap[WITH_CTX]}(`);
	push(`(`, -2, node);
	if (isArray(params)) genNodeList(params, context);
	else if (params) genNode(params, context);
	push(`) => `);
	if (newline || body) {
		push(`{`);
		indent();
	}
	if (returns) {
		if (newline) push(`return `);
		if (isArray(returns)) genNodeListAsArray(returns, context);
		else genNode(returns, context);
	} else if (body) genNode(body, context);
	if (newline || body) {
		deindent();
		push(`}`);
	}
	if (isSlot) {
		if (node.isNonScopedSlot) push(`, undefined, true`);
		push(`)`);
	}
}
function genConditionalExpression(node, context) {
	const { test, consequent, alternate, newline: needNewline } = node;
	const { push, indent, deindent, newline } = context;
	if (test.type === 4) {
		const needsParens = !isSimpleIdentifier(test.content);
		needsParens && push(`(`);
		genExpression(test, context);
		needsParens && push(`)`);
	} else {
		push(`(`);
		genNode(test, context);
		push(`)`);
	}
	needNewline && indent();
	context.indentLevel++;
	needNewline || push(` `);
	push(`? `);
	genNode(consequent, context);
	context.indentLevel--;
	needNewline && newline();
	needNewline || push(` `);
	push(`: `);
	const isNested = alternate.type === 19;
	if (!isNested) context.indentLevel++;
	genNode(alternate, context);
	if (!isNested) context.indentLevel--;
	needNewline && deindent(true);
}
function genCacheExpression(node, context) {
	const { push, helper, indent, deindent, newline } = context;
	const { needPauseTracking, needArraySpread } = node;
	if (needArraySpread) push(`[...(`);
	push(`_cache[${node.index}] || (`);
	if (needPauseTracking) {
		indent();
		push(`${helper(SET_BLOCK_TRACKING)}(-1`);
		if (node.inVOnce) push(`, true`);
		push(`),`);
		newline();
		push(`(`);
	}
	push(`_cache[${node.index}] = `);
	genNode(node.value, context);
	if (needPauseTracking) {
		push(`).cacheIndex = ${node.index},`);
		newline();
		push(`${helper(SET_BLOCK_TRACKING)}(1),`);
		newline();
		push(`_cache[${node.index}]`);
		deindent();
	}
	push(`)`);
	if (needArraySpread) push(`)]`);
}
function validateBrowserExpression(node, context, asParams = false, asRawStatements = false) {
	const exp = node.content;
	if (!exp.trim()) return;
	try {
		new Function(asRawStatements ? ` ${exp} ` : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}`);
	} catch (e) {
		let message = e.message;
		const keywordMatch = exp.replace(stripStringRE, "").match(prohibitedKeywordRE);
		if (keywordMatch) message = `avoid using JavaScript keyword as property name: "${keywordMatch[0]}"`;
		context.onError(createCompilerError(45, node.loc, void 0, message));
	}
}
function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
	validateBrowserExpression(node, context, asParams, asRawStatements);
	return node;
}
function stringifyExpression(exp) {
	if (isString(exp)) return exp;
	else if (exp.type === 4) return exp.content;
	else return exp.children.map(stringifyExpression).join("");
}
function processIf(node, dir, context, processCodegen) {
	if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
		const loc = dir.exp ? dir.exp.loc : node.loc;
		context.onError(createCompilerError(28, dir.loc));
		dir.exp = createSimpleExpression(`true`, false, loc);
	}
	if (dir.exp) validateBrowserExpression(dir.exp, context);
	if (dir.name === "if") {
		const branch = createIfBranch(node, dir);
		const ifNode = {
			type: 9,
			loc: cloneLoc(node.loc),
			branches: [branch]
		};
		context.replaceNode(ifNode);
		if (processCodegen) return processCodegen(ifNode, branch, true);
	} else {
		const siblings = context.parent.children;
		const comments = [];
		let i = siblings.indexOf(node);
		while (i-- >= -1) {
			const sibling = siblings[i];
			if (sibling && isCommentOrWhitespace(sibling)) {
				context.removeNode(sibling);
				if (sibling.type === 3) comments.unshift(sibling);
				continue;
			}
			if (sibling && sibling.type === 9) {
				if ((dir.name === "else-if" || dir.name === "else") && sibling.branches[sibling.branches.length - 1].condition === void 0) context.onError(createCompilerError(30, node.loc));
				context.removeNode();
				const branch = createIfBranch(node, dir);
				if (comments.length && !(context.parent && context.parent.type === 1 && (context.parent.tag === "transition" || context.parent.tag === "Transition"))) branch.children = [...comments, ...branch.children];
				{
					const key = branch.userKey;
					if (key) sibling.branches.forEach(({ userKey }) => {
						if (isSameKey(userKey, key)) context.onError(createCompilerError(29, branch.userKey.loc));
					});
				}
				sibling.branches.push(branch);
				const onExit = processCodegen && processCodegen(sibling, branch, false);
				traverseNode(branch, context);
				if (onExit) onExit();
				context.currentNode = null;
			} else context.onError(createCompilerError(30, node.loc));
			break;
		}
	}
}
function createIfBranch(node, dir) {
	const isTemplateIf = node.tagType === 3;
	return {
		type: 10,
		loc: node.loc,
		condition: dir.name === "else" ? void 0 : dir.exp,
		children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
		userKey: findProp(node, `key`),
		isTemplateIf
	};
}
function createCodegenNodeForBranch(branch, keyIndex, context) {
	if (branch.condition) return createConditionalExpression(branch.condition, createChildrenCodegenNode(branch, keyIndex, context), createCallExpression(context.helper(CREATE_COMMENT), ["\"v-if\"", "true"]));
	else return createChildrenCodegenNode(branch, keyIndex, context);
}
function createChildrenCodegenNode(branch, keyIndex, context) {
	const { helper } = context;
	const keyProperty = createObjectProperty(`key`, createSimpleExpression(`${keyIndex}`, false, locStub, 2));
	const { children } = branch;
	const firstChild = children[0];
	if (children.length !== 1 || firstChild.type !== 1) if (children.length === 1 && firstChild.type === 11) {
		const vnodeCall = firstChild.codegenNode;
		injectProp(vnodeCall, keyProperty, context);
		return vnodeCall;
	} else {
		let patchFlag = 64;
		if (!branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) patchFlag |= 2048;
		return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, patchFlag, void 0, void 0, true, false, false, branch.loc);
	}
	else {
		const ret = firstChild.codegenNode;
		const vnodeCall = getMemoedVNodeCall(ret);
		if (vnodeCall.type === 13) convertToBlock(vnodeCall, context);
		injectProp(vnodeCall, keyProperty, context);
		return ret;
	}
}
function isSameKey(a, b) {
	if (!a || a.type !== b.type) return false;
	if (a.type === 6) {
		if (a.value.content !== b.value.content) return false;
	} else {
		const exp = a.exp;
		const branchExp = b.exp;
		if (exp.type !== branchExp.type) return false;
		if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) return false;
	}
	return true;
}
function getParentCondition(node) {
	while (true) if (node.type === 19) if (node.alternate.type === 19) node = node.alternate;
	else return node;
	else if (node.type === 20) node = node.value;
}
function processFor(node, dir, context, processCodegen) {
	if (!dir.exp) {
		context.onError(createCompilerError(31, dir.loc));
		return;
	}
	const parseResult = dir.forParseResult;
	if (!parseResult) {
		context.onError(createCompilerError(32, dir.loc));
		return;
	}
	finalizeForParseResult(parseResult, context);
	const { addIdentifiers, removeIdentifiers, scopes } = context;
	const { source, value, key, index } = parseResult;
	const forNode = {
		type: 11,
		loc: dir.loc,
		source,
		valueAlias: value,
		keyAlias: key,
		objectIndexAlias: index,
		parseResult,
		children: isTemplateNode(node) ? node.children : [node]
	};
	context.replaceNode(forNode);
	scopes.vFor++;
	const onExit = processCodegen && processCodegen(forNode);
	return () => {
		scopes.vFor--;
		if (onExit) onExit();
	};
}
function finalizeForParseResult(result, context) {
	if (result.finalized) return;
	validateBrowserExpression(result.source, context);
	if (result.key) validateBrowserExpression(result.key, context, true);
	if (result.index) validateBrowserExpression(result.index, context, true);
	if (result.value) validateBrowserExpression(result.value, context, true);
	result.finalized = true;
}
function createForLoopParams({ value, key, index }, memoArgs = []) {
	return createParamsList([
		value,
		key,
		index,
		...memoArgs
	]);
}
function createParamsList(args) {
	let i = args.length;
	while (i--) if (args[i]) break;
	return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
}
function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
	context.helper(WITH_CTX);
	const { children, loc } = node;
	const slotsProperties = [];
	const dynamicSlots = [];
	let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
	const onComponentSlot = findDir(node, "slot", true);
	if (onComponentSlot) {
		const { arg, exp } = onComponentSlot;
		if (arg && !isStaticExp(arg)) hasDynamicSlots = true;
		slotsProperties.push(createObjectProperty(arg || createSimpleExpression("default", true), buildSlotFn(exp, void 0, children, loc)));
	}
	let hasTemplateSlots = false;
	let hasNamedDefaultSlot = false;
	const implicitDefaultChildren = [];
	const seenSlotNames = /* @__PURE__ */ new Set();
	let conditionalBranchIndex = 0;
	for (let i = 0; i < children.length; i++) {
		const slotElement = children[i];
		let slotDir;
		if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
			if (slotElement.type !== 3) implicitDefaultChildren.push(slotElement);
			continue;
		}
		if (onComponentSlot) {
			context.onError(createCompilerError(37, slotDir.loc));
			break;
		}
		hasTemplateSlots = true;
		const { children: slotChildren, loc: slotLoc } = slotElement;
		const { arg: slotName = createSimpleExpression(`default`, true), exp: slotProps, loc: dirLoc } = slotDir;
		let staticSlotName;
		if (isStaticExp(slotName)) staticSlotName = slotName ? slotName.content : `default`;
		else hasDynamicSlots = true;
		const vFor = findDir(slotElement, "for");
		const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);
		let vIf;
		let vElse;
		if (vIf = findDir(slotElement, "if")) {
			hasDynamicSlots = true;
			dynamicSlots.push(createConditionalExpression(vIf.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback));
		} else if (vElse = findDir(slotElement, /^else(?:-if)?$/, true)) {
			let j = i;
			let prev;
			while (j--) {
				prev = children[j];
				if (!isCommentOrWhitespace(prev)) break;
			}
			if (prev && isTemplateNode(prev) && findDir(prev, /^(?:else-)?if$/)) {
				let conditional = dynamicSlots[dynamicSlots.length - 1];
				while (conditional.alternate.type === 19) conditional = conditional.alternate;
				conditional.alternate = vElse.exp ? createConditionalExpression(vElse.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
			} else context.onError(createCompilerError(30, vElse.loc));
		} else if (vFor) {
			hasDynamicSlots = true;
			const parseResult = vFor.forParseResult;
			if (parseResult) {
				finalizeForParseResult(parseResult, context);
				dynamicSlots.push(createCallExpression(context.helper(RENDER_LIST), [parseResult.source, createFunctionExpression(createForLoopParams(parseResult), buildDynamicSlot(slotName, slotFunction), true)]));
			} else context.onError(createCompilerError(32, vFor.loc));
		} else {
			if (staticSlotName) {
				if (seenSlotNames.has(staticSlotName)) {
					context.onError(createCompilerError(38, dirLoc));
					continue;
				}
				seenSlotNames.add(staticSlotName);
				if (staticSlotName === "default") hasNamedDefaultSlot = true;
			}
			slotsProperties.push(createObjectProperty(slotName, slotFunction));
		}
	}
	if (!onComponentSlot) {
		const buildDefaultSlotProperty = (props$1, children2) => {
			const fn = buildSlotFn(props$1, void 0, children2, loc);
			if (context.compatConfig) fn.isNonScopedSlot = true;
			return createObjectProperty(`default`, fn);
		};
		if (!hasTemplateSlots) slotsProperties.push(buildDefaultSlotProperty(void 0, children));
		else if (implicitDefaultChildren.length && !implicitDefaultChildren.every(isWhitespaceText)) if (hasNamedDefaultSlot) context.onError(createCompilerError(39, implicitDefaultChildren[0].loc));
		else slotsProperties.push(buildDefaultSlotProperty(void 0, implicitDefaultChildren));
	}
	const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
	let slots = createObjectExpression(slotsProperties.concat(createObjectProperty(`_`, createSimpleExpression(slotFlag + ` /* ${slotFlagsText[slotFlag]} */`, false))), loc);
	if (dynamicSlots.length) slots = createCallExpression(context.helper(CREATE_SLOTS), [slots, createArrayExpression(dynamicSlots)]);
	return {
		slots,
		hasDynamicSlots
	};
}
function buildDynamicSlot(name$111, fn, index) {
	const props$1 = [createObjectProperty(`name`, name$111), createObjectProperty(`fn`, fn)];
	if (index != null) props$1.push(createObjectProperty(`key`, createSimpleExpression(String(index), true)));
	return createObjectExpression(props$1);
}
function hasForwardedSlots(children) {
	for (let i = 0; i < children.length; i++) {
		const child = children[i];
		switch (child.type) {
			case 1:
				if (child.tagType === 2 || hasForwardedSlots(child.children)) return true;
				break;
			case 9:
				if (hasForwardedSlots(child.branches)) return true;
				break;
			case 10:
			case 11:
				if (hasForwardedSlots(child.children)) return true;
				break;
		}
	}
	return false;
}
function resolveComponentType(node, context, ssr = false) {
	let { tag } = node;
	const isExplicitDynamic = isComponentTag(tag);
	const isProp = findProp(node, "is", false, true);
	if (isProp) {
		if (isExplicitDynamic || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context)) {
			let exp;
			if (isProp.type === 6) exp = isProp.value && createSimpleExpression(isProp.value.content, true);
			else {
				exp = isProp.exp;
				if (!exp) exp = createSimpleExpression(`is`, false, isProp.arg.loc);
			}
			if (exp) return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [exp]);
		} else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) tag = isProp.value.content.slice(4);
	}
	const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
	if (builtIn) {
		if (!ssr) context.helper(builtIn);
		return builtIn;
	}
	context.helper(RESOLVE_COMPONENT);
	context.components.add(tag);
	return toValidAssetId(tag, `component`);
}
function buildProps(node, context, props$1 = node.props, isComponent$1, isDynamicComponent, ssr = false) {
	const { tag, loc: elementLoc, children } = node;
	let properties = [];
	const mergeArgs = [];
	const runtimeDirectives = [];
	const hasChildren = children.length > 0;
	let shouldUseBlock = false;
	let patchFlag = 0;
	let hasRef = false;
	let hasClassBinding = false;
	let hasStyleBinding = false;
	let hasHydrationEventBinding = false;
	let hasDynamicKeys = false;
	let hasVnodeHook = false;
	const dynamicPropNames = [];
	const pushMergeArg = (arg) => {
		if (properties.length) {
			mergeArgs.push(createObjectExpression(dedupeProperties(properties), elementLoc));
			properties = [];
		}
		if (arg) mergeArgs.push(arg);
	};
	const pushRefVForMarker = () => {
		if (context.scopes.vFor > 0) properties.push(createObjectProperty(createSimpleExpression("ref_for", true), createSimpleExpression("true")));
	};
	const analyzePatchFlag = ({ key, value }) => {
		if (isStaticExp(key)) {
			const name$111 = key.content;
			const isEventHandler = isOn(name$111);
			if (isEventHandler && (!isComponent$1 || isDynamicComponent) && name$111.toLowerCase() !== "onclick" && name$111 !== "onUpdate:modelValue" && !isReservedProp(name$111)) hasHydrationEventBinding = true;
			if (isEventHandler && isReservedProp(name$111)) hasVnodeHook = true;
			if (isEventHandler && value.type === 14) value = value.arguments[0];
			if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) return;
			if (name$111 === "ref") hasRef = true;
			else if (name$111 === "class") hasClassBinding = true;
			else if (name$111 === "style") hasStyleBinding = true;
			else if (name$111 !== "key" && !dynamicPropNames.includes(name$111)) dynamicPropNames.push(name$111);
			if (isComponent$1 && (name$111 === "class" || name$111 === "style") && !dynamicPropNames.includes(name$111)) dynamicPropNames.push(name$111);
		} else hasDynamicKeys = true;
	};
	for (let i = 0; i < props$1.length; i++) {
		const prop = props$1[i];
		if (prop.type === 6) {
			const { loc, name: name$111, nameLoc, value } = prop;
			let isStatic = true;
			if (name$111 === "ref") {
				hasRef = true;
				pushRefVForMarker();
			}
			if (name$111 === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context))) continue;
			properties.push(createObjectProperty(createSimpleExpression(name$111, true, nameLoc), createSimpleExpression(value ? value.content : "", isStatic, value ? value.loc : loc)));
		} else {
			const { name: name$111, arg, exp, loc, modifiers } = prop;
			const isVBind = name$111 === "bind";
			const isVOn = name$111 === "on";
			if (name$111 === "slot") {
				if (!isComponent$1) context.onError(createCompilerError(40, loc));
				continue;
			}
			if (name$111 === "once" || name$111 === "memo") continue;
			if (name$111 === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context))) continue;
			if (isVOn && ssr) continue;
			if (isVBind && isStaticArgOf(arg, "key") || isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")) shouldUseBlock = true;
			if (isVBind && isStaticArgOf(arg, "ref")) pushRefVForMarker();
			if (!arg && (isVBind || isVOn)) {
				hasDynamicKeys = true;
				if (exp) if (isVBind) {
					pushMergeArg();
					if (mergeArgs.some((arg2) => {
						if (arg2.type === 15) return arg2.properties.some(({ key }) => {
							if (key.type !== 4 || !key.isStatic) return true;
							return key.content !== "class" && key.content !== "style" && !isOn(key.content);
						});
						else return true;
					})) checkCompatEnabled("COMPILER_V_BIND_OBJECT_ORDER", context, loc);
					if (isCompatEnabled("COMPILER_V_BIND_OBJECT_ORDER", context)) {
						mergeArgs.unshift(exp);
						continue;
					}
					pushRefVForMarker();
					pushMergeArg();
					mergeArgs.push(exp);
				} else pushMergeArg({
					type: 14,
					loc,
					callee: context.helper(TO_HANDLERS),
					arguments: isComponent$1 ? [exp] : [exp, `true`]
				});
				else context.onError(createCompilerError(isVBind ? 34 : 35, loc));
				continue;
			}
			if (isVBind && modifiers.some((mod) => mod.content === "prop")) patchFlag |= 32;
			const directiveTransform = context.directiveTransforms[name$111];
			if (directiveTransform) {
				const { props: props2, needRuntime } = directiveTransform(prop, node, context);
				!ssr && props2.forEach(analyzePatchFlag);
				if (isVOn && arg && !isStaticExp(arg)) pushMergeArg(createObjectExpression(props2, elementLoc));
				else properties.push(...props2);
				if (needRuntime) {
					runtimeDirectives.push(prop);
					if (isSymbol(needRuntime)) directiveImportMap.set(prop, needRuntime);
				}
			} else if (!isBuiltInDirective(name$111)) {
				runtimeDirectives.push(prop);
				if (hasChildren) shouldUseBlock = true;
			}
		}
	}
	let propsExpression = void 0;
	if (mergeArgs.length) {
		pushMergeArg();
		if (mergeArgs.length > 1) propsExpression = createCallExpression(context.helper(MERGE_PROPS), mergeArgs, elementLoc);
		else propsExpression = mergeArgs[0];
	} else if (properties.length) propsExpression = createObjectExpression(dedupeProperties(properties), elementLoc);
	if (hasDynamicKeys) patchFlag |= 16;
	else {
		if (hasClassBinding && !isComponent$1) patchFlag |= 2;
		if (hasStyleBinding && !isComponent$1) patchFlag |= 4;
		if (dynamicPropNames.length) patchFlag |= 8;
		if (hasHydrationEventBinding) patchFlag |= 32;
	}
	if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) patchFlag |= 512;
	if (!context.inSSR && propsExpression) switch (propsExpression.type) {
		case 15:
			let classKeyIndex = -1;
			let styleKeyIndex = -1;
			let hasDynamicKey = false;
			for (let i = 0; i < propsExpression.properties.length; i++) {
				const key = propsExpression.properties[i].key;
				if (isStaticExp(key)) {
					if (key.content === "class") classKeyIndex = i;
					else if (key.content === "style") styleKeyIndex = i;
				} else if (!key.isHandlerKey) hasDynamicKey = true;
			}
			const classProp = propsExpression.properties[classKeyIndex];
			const styleProp = propsExpression.properties[styleKeyIndex];
			if (!hasDynamicKey) {
				if (classProp && !isStaticExp(classProp.value)) classProp.value = createCallExpression(context.helper(NORMALIZE_CLASS), [classProp.value]);
				if (styleProp && (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || styleProp.value.type === 17)) styleProp.value = createCallExpression(context.helper(NORMALIZE_STYLE), [styleProp.value]);
			} else propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [propsExpression]);
			break;
		case 14: break;
		default:
			propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [propsExpression])]);
			break;
	}
	return {
		props: propsExpression,
		directives: runtimeDirectives,
		patchFlag,
		dynamicPropNames,
		shouldUseBlock
	};
}
function dedupeProperties(properties) {
	const knownProps = /* @__PURE__ */ new Map();
	const deduped = [];
	for (let i = 0; i < properties.length; i++) {
		const prop = properties[i];
		if (prop.key.type === 8 || !prop.key.isStatic) {
			deduped.push(prop);
			continue;
		}
		const name$111 = prop.key.content;
		const existing = knownProps.get(name$111);
		if (existing) {
			if (name$111 === "style" || name$111 === "class" || isOn(name$111)) mergeAsArray(existing, prop);
		} else {
			knownProps.set(name$111, prop);
			deduped.push(prop);
		}
	}
	return deduped;
}
function mergeAsArray(existing, incoming) {
	if (existing.value.type === 17) existing.value.elements.push(incoming.value);
	else existing.value = createArrayExpression([existing.value, incoming.value], existing.loc);
}
function buildDirectiveArgs(dir, context) {
	const dirArgs = [];
	const runtime = directiveImportMap.get(dir);
	if (runtime) dirArgs.push(context.helperString(runtime));
	else {
		context.helper(RESOLVE_DIRECTIVE);
		context.directives.add(dir.name);
		dirArgs.push(toValidAssetId(dir.name, `directive`));
	}
	const { loc } = dir;
	if (dir.exp) dirArgs.push(dir.exp);
	if (dir.arg) {
		if (!dir.exp) dirArgs.push(`void 0`);
		dirArgs.push(dir.arg);
	}
	if (Object.keys(dir.modifiers).length) {
		if (!dir.arg) {
			if (!dir.exp) dirArgs.push(`void 0`);
			dirArgs.push(`void 0`);
		}
		const trueExpression = createSimpleExpression(`true`, false, loc);
		dirArgs.push(createObjectExpression(dir.modifiers.map((modifier) => createObjectProperty(modifier, trueExpression)), loc));
	}
	return createArrayExpression(dirArgs, dir.loc);
}
function stringifyDynamicPropNames(props$1) {
	let propsNamesString = `[`;
	for (let i = 0, l = props$1.length; i < l; i++) {
		propsNamesString += JSON.stringify(props$1[i]);
		if (i < l - 1) propsNamesString += ", ";
	}
	return propsNamesString + `]`;
}
function isComponentTag(tag) {
	return tag === "component" || tag === "Component";
}
function processSlotOutlet(node, context) {
	let slotName = `"default"`;
	let slotProps = void 0;
	const nonNameProps = [];
	for (let i = 0; i < node.props.length; i++) {
		const p = node.props[i];
		if (p.type === 6) {
			if (p.value) if (p.name === "name") slotName = JSON.stringify(p.value.content);
			else {
				p.name = camelize$1(p.name);
				nonNameProps.push(p);
			}
		} else if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
			if (p.exp) slotName = p.exp;
			else if (p.arg && p.arg.type === 4) slotName = p.exp = createSimpleExpression(camelize$1(p.arg.content), false, p.arg.loc);
		} else {
			if (p.name === "bind" && p.arg && isStaticExp(p.arg)) p.arg.content = camelize$1(p.arg.content);
			nonNameProps.push(p);
		}
	}
	if (nonNameProps.length > 0) {
		const { props: props$1, directives } = buildProps(node, context, nonNameProps, false, false);
		slotProps = props$1;
		if (directives.length) context.onError(createCompilerError(36, directives[0].loc));
	}
	return {
		slotName,
		slotProps
	};
}
function createTransformProps(props$1 = []) {
	return { props: props$1 };
}
function rewriteFilter(node, context) {
	if (node.type === 4) parseFilter(node, context);
	else for (let i = 0; i < node.children.length; i++) {
		const child = node.children[i];
		if (typeof child !== "object") continue;
		if (child.type === 4) parseFilter(child, context);
		else if (child.type === 8) rewriteFilter(node, context);
		else if (child.type === 5) rewriteFilter(child.content, context);
	}
}
function parseFilter(node, context) {
	const exp = node.content;
	let inSingle = false;
	let inDouble = false;
	let inTemplateString = false;
	let inRegex = false;
	let curly = 0;
	let square = 0;
	let paren = 0;
	let lastFilterIndex = 0;
	let c, prev, i, expression, filters = [];
	for (i = 0; i < exp.length; i++) {
		prev = c;
		c = exp.charCodeAt(i);
		if (inSingle) {
			if (c === 39 && prev !== 92) inSingle = false;
		} else if (inDouble) {
			if (c === 34 && prev !== 92) inDouble = false;
		} else if (inTemplateString) {
			if (c === 96 && prev !== 92) inTemplateString = false;
		} else if (inRegex) {
			if (c === 47 && prev !== 92) inRegex = false;
		} else if (c === 124 && exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) if (expression === void 0) {
			lastFilterIndex = i + 1;
			expression = exp.slice(0, i).trim();
		} else pushFilter();
		else {
			switch (c) {
				case 34:
					inDouble = true;
					break;
				case 39:
					inSingle = true;
					break;
				case 96:
					inTemplateString = true;
					break;
				case 40:
					paren++;
					break;
				case 41:
					paren--;
					break;
				case 91:
					square++;
					break;
				case 93:
					square--;
					break;
				case 123:
					curly++;
					break;
				case 125:
					curly--;
					break;
			}
			if (c === 47) {
				let j = i - 1;
				let p;
				for (; j >= 0; j--) {
					p = exp.charAt(j);
					if (p !== " ") break;
				}
				if (!p || !validDivisionCharRE.test(p)) inRegex = true;
			}
		}
	}
	if (expression === void 0) expression = exp.slice(0, i).trim();
	else if (lastFilterIndex !== 0) pushFilter();
	function pushFilter() {
		filters.push(exp.slice(lastFilterIndex, i).trim());
		lastFilterIndex = i + 1;
	}
	if (filters.length) {
		warnDeprecation("COMPILER_FILTERS", context, node.loc);
		for (i = 0; i < filters.length; i++) expression = wrapFilter(expression, filters[i], context);
		node.content = expression;
		node.ast = void 0;
	}
}
function wrapFilter(exp, filter, context) {
	context.helper(RESOLVE_FILTER);
	const i = filter.indexOf("(");
	if (i < 0) {
		context.filters.add(filter);
		return `${toValidAssetId(filter, "filter")}(${exp})`;
	} else {
		const name$111 = filter.slice(0, i);
		const args = filter.slice(i + 1);
		context.filters.add(name$111);
		return `${toValidAssetId(name$111, "filter")}(${exp}${args !== ")" ? "," + args : args}`;
	}
}
function getBaseTransformPreset(prefixIdentifiers) {
	return [[
		transformVBindShorthand,
		transformOnce,
		transformIf,
		transformMemo,
		transformFor,
		...[transformFilter],
		...[transformExpression],
		transformSlotOutlet,
		transformElement,
		trackSlotScopes,
		transformText
	], {
		on: transformOn,
		bind: transformBind,
		model: transformModel
	}];
}
function baseCompile(source, options = {}) {
	const onError = options.onError || defaultOnError;
	const isModuleMode = options.mode === "module";
	if (options.prefixIdentifiers === true) onError(createCompilerError(47));
	else if (isModuleMode) onError(createCompilerError(48));
	const prefixIdentifiers = false;
	if (options.cacheHandlers) onError(createCompilerError(49));
	if (options.scopeId && !isModuleMode) onError(createCompilerError(50));
	const resolvedOptions = extend({}, options, { prefixIdentifiers });
	const ast = isString(source) ? baseParse(source, resolvedOptions) : source;
	const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
	transform(ast, extend({}, resolvedOptions, {
		nodeTransforms: [...nodeTransforms, ...options.nodeTransforms || []],
		directiveTransforms: extend({}, directiveTransforms, options.directiveTransforms || {})
	}));
	return generate(ast, resolvedOptions);
}
var FRAGMENT, TELEPORT, SUSPENSE, KEEP_ALIVE, BASE_TRANSITION, OPEN_BLOCK, CREATE_BLOCK, CREATE_ELEMENT_BLOCK, CREATE_VNODE, CREATE_ELEMENT_VNODE, CREATE_COMMENT, CREATE_TEXT, CREATE_STATIC, RESOLVE_COMPONENT, RESOLVE_DYNAMIC_COMPONENT, RESOLVE_DIRECTIVE, RESOLVE_FILTER, WITH_DIRECTIVES, RENDER_LIST, RENDER_SLOT, CREATE_SLOTS, TO_DISPLAY_STRING, MERGE_PROPS, NORMALIZE_CLASS, NORMALIZE_STYLE, NORMALIZE_PROPS, GUARD_REACTIVE_PROPS, TO_HANDLERS, CAMELIZE, CAPITALIZE, TO_HANDLER_KEY, SET_BLOCK_TRACKING, PUSH_SCOPE_ID, POP_SCOPE_ID, WITH_CTX, UNREF, IS_REF, WITH_MEMO, IS_MEMO_SAME, helperNameMap, Namespaces, NodeTypes, ElementTypes, ConstantTypes, locStub, defaultDelimitersOpen, defaultDelimitersClose, Sequences, Tokenizer, CompilerDeprecationTypes, deprecationData, ErrorCodes, errorMessages, isFunctionType, isStaticProperty, isStaticPropertyKey, TS_NODE_TYPES, isStaticExp, nonIdentifierRE, isSimpleIdentifier, validFirstIdentCharRE, validIdentCharRE, whitespaceRE, getExpSource, isMemberExpressionBrowser, isMemberExpressionNode, isMemberExpression, fnExpRE, isFnExpressionBrowser, isFnExpressionNode, isFnExpression, propsHelperSet, forAliasRE, defaultParserOptions, currentOptions$3, currentRoot, currentInput, currentOpenTag, currentProp, currentAttrValue, currentAttrStartIndex, currentAttrEndIndex, inPre, inVPre, currentVPreBoundary, stack, tokenizer, forIteratorRE, stripParensRE, specialTemplateDir, windowsNewlineRE, allowHoistedHelperSet, PURE_ANNOTATION, aliasHelper, prohibitedKeywordRE, stripStringRE, transformExpression, transformIf, transformFor, defaultFallback, trackSlotScopes, trackVForSlotScopes, buildClientSlotFn, directiveImportMap, transformElement, transformSlotOutlet, transformOn, transformBind, injectPrefix, transformText, seen$1, transformOnce, transformModel, validDivisionCharRE, transformFilter, seen, transformMemo, transformVBindShorthand, BindingTypes, noopDirectiveTransform;
var init_compiler_core_esm_bundler = __esm({ "node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js": (() => {
	init_shared_esm_bundler();
	FRAGMENT = Symbol(`Fragment`);
	TELEPORT = Symbol(`Teleport`);
	SUSPENSE = Symbol(`Suspense`);
	KEEP_ALIVE = Symbol(`KeepAlive`);
	BASE_TRANSITION = Symbol(`BaseTransition`);
	OPEN_BLOCK = Symbol(`openBlock`);
	CREATE_BLOCK = Symbol(`createBlock`);
	CREATE_ELEMENT_BLOCK = Symbol(`createElementBlock`);
	CREATE_VNODE = Symbol(`createVNode`);
	CREATE_ELEMENT_VNODE = Symbol(`createElementVNode`);
	CREATE_COMMENT = Symbol(`createCommentVNode`);
	CREATE_TEXT = Symbol(`createTextVNode`);
	CREATE_STATIC = Symbol(`createStaticVNode`);
	RESOLVE_COMPONENT = Symbol(`resolveComponent`);
	RESOLVE_DYNAMIC_COMPONENT = Symbol(`resolveDynamicComponent`);
	RESOLVE_DIRECTIVE = Symbol(`resolveDirective`);
	RESOLVE_FILTER = Symbol(`resolveFilter`);
	WITH_DIRECTIVES = Symbol(`withDirectives`);
	RENDER_LIST = Symbol(`renderList`);
	RENDER_SLOT = Symbol(`renderSlot`);
	CREATE_SLOTS = Symbol(`createSlots`);
	TO_DISPLAY_STRING = Symbol(`toDisplayString`);
	MERGE_PROPS = Symbol(`mergeProps`);
	NORMALIZE_CLASS = Symbol(`normalizeClass`);
	NORMALIZE_STYLE = Symbol(`normalizeStyle`);
	NORMALIZE_PROPS = Symbol(`normalizeProps`);
	GUARD_REACTIVE_PROPS = Symbol(`guardReactiveProps`);
	TO_HANDLERS = Symbol(`toHandlers`);
	CAMELIZE = Symbol(`camelize`);
	CAPITALIZE = Symbol(`capitalize`);
	TO_HANDLER_KEY = Symbol(`toHandlerKey`);
	SET_BLOCK_TRACKING = Symbol(`setBlockTracking`);
	PUSH_SCOPE_ID = Symbol(`pushScopeId`);
	POP_SCOPE_ID = Symbol(`popScopeId`);
	WITH_CTX = Symbol(`withCtx`);
	UNREF = Symbol(`unref`);
	IS_REF = Symbol(`isRef`);
	WITH_MEMO = Symbol(`withMemo`);
	IS_MEMO_SAME = Symbol(`isMemoSame`);
	helperNameMap = {
		[FRAGMENT]: `Fragment`,
		[TELEPORT]: `Teleport`,
		[SUSPENSE]: `Suspense`,
		[KEEP_ALIVE]: `KeepAlive`,
		[BASE_TRANSITION]: `BaseTransition`,
		[OPEN_BLOCK]: `openBlock`,
		[CREATE_BLOCK]: `createBlock`,
		[CREATE_ELEMENT_BLOCK]: `createElementBlock`,
		[CREATE_VNODE]: `createVNode`,
		[CREATE_ELEMENT_VNODE]: `createElementVNode`,
		[CREATE_COMMENT]: `createCommentVNode`,
		[CREATE_TEXT]: `createTextVNode`,
		[CREATE_STATIC]: `createStaticVNode`,
		[RESOLVE_COMPONENT]: `resolveComponent`,
		[RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
		[RESOLVE_DIRECTIVE]: `resolveDirective`,
		[RESOLVE_FILTER]: `resolveFilter`,
		[WITH_DIRECTIVES]: `withDirectives`,
		[RENDER_LIST]: `renderList`,
		[RENDER_SLOT]: `renderSlot`,
		[CREATE_SLOTS]: `createSlots`,
		[TO_DISPLAY_STRING]: `toDisplayString`,
		[MERGE_PROPS]: `mergeProps`,
		[NORMALIZE_CLASS]: `normalizeClass`,
		[NORMALIZE_STYLE]: `normalizeStyle`,
		[NORMALIZE_PROPS]: `normalizeProps`,
		[GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
		[TO_HANDLERS]: `toHandlers`,
		[CAMELIZE]: `camelize`,
		[CAPITALIZE]: `capitalize`,
		[TO_HANDLER_KEY]: `toHandlerKey`,
		[SET_BLOCK_TRACKING]: `setBlockTracking`,
		[PUSH_SCOPE_ID]: `pushScopeId`,
		[POP_SCOPE_ID]: `popScopeId`,
		[WITH_CTX]: `withCtx`,
		[UNREF]: `unref`,
		[IS_REF]: `isRef`,
		[WITH_MEMO]: `withMemo`,
		[IS_MEMO_SAME]: `isMemoSame`
	};
	Namespaces = {
		"HTML": 0,
		"0": "HTML",
		"SVG": 1,
		"1": "SVG",
		"MATH_ML": 2,
		"2": "MATH_ML"
	};
	NodeTypes = {
		"ROOT": 0,
		"0": "ROOT",
		"ELEMENT": 1,
		"1": "ELEMENT",
		"TEXT": 2,
		"2": "TEXT",
		"COMMENT": 3,
		"3": "COMMENT",
		"SIMPLE_EXPRESSION": 4,
		"4": "SIMPLE_EXPRESSION",
		"INTERPOLATION": 5,
		"5": "INTERPOLATION",
		"ATTRIBUTE": 6,
		"6": "ATTRIBUTE",
		"DIRECTIVE": 7,
		"7": "DIRECTIVE",
		"COMPOUND_EXPRESSION": 8,
		"8": "COMPOUND_EXPRESSION",
		"IF": 9,
		"9": "IF",
		"IF_BRANCH": 10,
		"10": "IF_BRANCH",
		"FOR": 11,
		"11": "FOR",
		"TEXT_CALL": 12,
		"12": "TEXT_CALL",
		"VNODE_CALL": 13,
		"13": "VNODE_CALL",
		"JS_CALL_EXPRESSION": 14,
		"14": "JS_CALL_EXPRESSION",
		"JS_OBJECT_EXPRESSION": 15,
		"15": "JS_OBJECT_EXPRESSION",
		"JS_PROPERTY": 16,
		"16": "JS_PROPERTY",
		"JS_ARRAY_EXPRESSION": 17,
		"17": "JS_ARRAY_EXPRESSION",
		"JS_FUNCTION_EXPRESSION": 18,
		"18": "JS_FUNCTION_EXPRESSION",
		"JS_CONDITIONAL_EXPRESSION": 19,
		"19": "JS_CONDITIONAL_EXPRESSION",
		"JS_CACHE_EXPRESSION": 20,
		"20": "JS_CACHE_EXPRESSION",
		"JS_BLOCK_STATEMENT": 21,
		"21": "JS_BLOCK_STATEMENT",
		"JS_TEMPLATE_LITERAL": 22,
		"22": "JS_TEMPLATE_LITERAL",
		"JS_IF_STATEMENT": 23,
		"23": "JS_IF_STATEMENT",
		"JS_ASSIGNMENT_EXPRESSION": 24,
		"24": "JS_ASSIGNMENT_EXPRESSION",
		"JS_SEQUENCE_EXPRESSION": 25,
		"25": "JS_SEQUENCE_EXPRESSION",
		"JS_RETURN_STATEMENT": 26,
		"26": "JS_RETURN_STATEMENT"
	};
	ElementTypes = {
		"ELEMENT": 0,
		"0": "ELEMENT",
		"COMPONENT": 1,
		"1": "COMPONENT",
		"SLOT": 2,
		"2": "SLOT",
		"TEMPLATE": 3,
		"3": "TEMPLATE"
	};
	ConstantTypes = {
		"NOT_CONSTANT": 0,
		"0": "NOT_CONSTANT",
		"CAN_SKIP_PATCH": 1,
		"1": "CAN_SKIP_PATCH",
		"CAN_CACHE": 2,
		"2": "CAN_CACHE",
		"CAN_STRINGIFY": 3,
		"3": "CAN_STRINGIFY"
	};
	locStub = {
		start: {
			line: 1,
			column: 1,
			offset: 0
		},
		end: {
			line: 1,
			column: 1,
			offset: 0
		},
		source: ""
	};
	defaultDelimitersOpen = new Uint8Array([123, 123]);
	defaultDelimitersClose = new Uint8Array([125, 125]);
	Sequences = {
		Cdata: new Uint8Array([
			67,
			68,
			65,
			84,
			65,
			91
		]),
		CdataEnd: new Uint8Array([
			93,
			93,
			62
		]),
		CommentEnd: new Uint8Array([
			45,
			45,
			62
		]),
		ScriptEnd: new Uint8Array([
			60,
			47,
			115,
			99,
			114,
			105,
			112,
			116
		]),
		StyleEnd: new Uint8Array([
			60,
			47,
			115,
			116,
			121,
			108,
			101
		]),
		TitleEnd: new Uint8Array([
			60,
			47,
			116,
			105,
			116,
			108,
			101
		]),
		TextareaEnd: new Uint8Array([
			60,
			47,
			116,
			101,
			120,
			116,
			97,
			114,
			101,
			97
		])
	};
	Tokenizer = class {
		constructor(stack$1, cbs) {
			this.stack = stack$1;
			this.cbs = cbs;
			/** The current state the tokenizer is in. */
			this.state = 1;
			/** The read buffer. */
			this.buffer = "";
			/** The beginning of the section that is currently being read. */
			this.sectionStart = 0;
			/** The index within the buffer that we are currently looking at. */
			this.index = 0;
			/** The start of the last entity. */
			this.entityStart = 0;
			/** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
			this.baseState = 1;
			/** For special parsing behavior inside of script and style tags. */
			this.inRCDATA = false;
			/** For disabling RCDATA tags handling */
			this.inXML = false;
			/** For disabling interpolation parsing in v-pre */
			this.inVPre = false;
			/** Record newline positions for fast line / column calculation */
			this.newlines = [];
			this.mode = 0;
			this.delimiterOpen = defaultDelimitersOpen;
			this.delimiterClose = defaultDelimitersClose;
			this.delimiterIndex = -1;
			this.currentSequence = void 0;
			this.sequenceIndex = 0;
		}
		get inSFCRoot() {
			return this.mode === 2 && this.stack.length === 0;
		}
		reset() {
			this.state = 1;
			this.mode = 0;
			this.buffer = "";
			this.sectionStart = 0;
			this.index = 0;
			this.baseState = 1;
			this.inRCDATA = false;
			this.currentSequence = void 0;
			this.newlines.length = 0;
			this.delimiterOpen = defaultDelimitersOpen;
			this.delimiterClose = defaultDelimitersClose;
		}
		/**
		* Generate Position object with line / column information using recorded
		* newline positions. We know the index is always going to be an already
		* processed index, so all the newlines up to this index should have been
		* recorded.
		*/
		getPos(index) {
			let line = 1;
			let column = index + 1;
			for (let i = this.newlines.length - 1; i >= 0; i--) {
				const newlineIndex = this.newlines[i];
				if (index > newlineIndex) {
					line = i + 2;
					column = index - newlineIndex;
					break;
				}
			}
			return {
				column,
				line,
				offset: index
			};
		}
		peek() {
			return this.buffer.charCodeAt(this.index + 1);
		}
		stateText(c) {
			if (c === 60) {
				if (this.index > this.sectionStart) this.cbs.ontext(this.sectionStart, this.index);
				this.state = 5;
				this.sectionStart = this.index;
			} else if (!this.inVPre && c === this.delimiterOpen[0]) {
				this.state = 2;
				this.delimiterIndex = 0;
				this.stateInterpolationOpen(c);
			}
		}
		stateInterpolationOpen(c) {
			if (c === this.delimiterOpen[this.delimiterIndex]) if (this.delimiterIndex === this.delimiterOpen.length - 1) {
				const start$1 = this.index + 1 - this.delimiterOpen.length;
				if (start$1 > this.sectionStart) this.cbs.ontext(this.sectionStart, start$1);
				this.state = 3;
				this.sectionStart = start$1;
			} else this.delimiterIndex++;
			else if (this.inRCDATA) {
				this.state = 32;
				this.stateInRCDATA(c);
			} else {
				this.state = 1;
				this.stateText(c);
			}
		}
		stateInterpolation(c) {
			if (c === this.delimiterClose[0]) {
				this.state = 4;
				this.delimiterIndex = 0;
				this.stateInterpolationClose(c);
			}
		}
		stateInterpolationClose(c) {
			if (c === this.delimiterClose[this.delimiterIndex]) if (this.delimiterIndex === this.delimiterClose.length - 1) {
				this.cbs.oninterpolation(this.sectionStart, this.index + 1);
				if (this.inRCDATA) this.state = 32;
				else this.state = 1;
				this.sectionStart = this.index + 1;
			} else this.delimiterIndex++;
			else {
				this.state = 3;
				this.stateInterpolation(c);
			}
		}
		stateSpecialStartSequence(c) {
			const isEnd = this.sequenceIndex === this.currentSequence.length;
			if (!(isEnd ? isEndOfTagSection(c) : (c | 32) === this.currentSequence[this.sequenceIndex])) this.inRCDATA = false;
			else if (!isEnd) {
				this.sequenceIndex++;
				return;
			}
			this.sequenceIndex = 0;
			this.state = 6;
			this.stateInTagName(c);
		}
		/** Look for an end tag. For <title> and <textarea>, also decode entities. */
		stateInRCDATA(c) {
			if (this.sequenceIndex === this.currentSequence.length) {
				if (c === 62 || isWhitespace(c)) {
					const endOfText = this.index - this.currentSequence.length;
					if (this.sectionStart < endOfText) {
						const actualIndex = this.index;
						this.index = endOfText;
						this.cbs.ontext(this.sectionStart, endOfText);
						this.index = actualIndex;
					}
					this.sectionStart = endOfText + 2;
					this.stateInClosingTagName(c);
					this.inRCDATA = false;
					return;
				}
				this.sequenceIndex = 0;
			}
			if ((c | 32) === this.currentSequence[this.sequenceIndex]) this.sequenceIndex += 1;
			else if (this.sequenceIndex === 0) {
				if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
					if (!this.inVPre && c === this.delimiterOpen[0]) {
						this.state = 2;
						this.delimiterIndex = 0;
						this.stateInterpolationOpen(c);
					}
				} else if (this.fastForwardTo(60)) this.sequenceIndex = 1;
			} else this.sequenceIndex = Number(c === 60);
		}
		stateCDATASequence(c) {
			if (c === Sequences.Cdata[this.sequenceIndex]) {
				if (++this.sequenceIndex === Sequences.Cdata.length) {
					this.state = 28;
					this.currentSequence = Sequences.CdataEnd;
					this.sequenceIndex = 0;
					this.sectionStart = this.index + 1;
				}
			} else {
				this.sequenceIndex = 0;
				this.state = 23;
				this.stateInDeclaration(c);
			}
		}
		/**
		* When we wait for one specific character, we can speed things up
		* by skipping through the buffer until we find it.
		*
		* @returns Whether the character was found.
		*/
		fastForwardTo(c) {
			while (++this.index < this.buffer.length) {
				const cc = this.buffer.charCodeAt(this.index);
				if (cc === 10) this.newlines.push(this.index);
				if (cc === c) return true;
			}
			this.index = this.buffer.length - 1;
			return false;
		}
		/**
		* Comments and CDATA end with `-->` and `]]>`.
		*
		* Their common qualities are:
		* - Their end sequences have a distinct character they start with.
		* - That character is then repeated, so we have to check multiple repeats.
		* - All characters but the start character of the sequence can be skipped.
		*/
		stateInCommentLike(c) {
			if (c === this.currentSequence[this.sequenceIndex]) {
				if (++this.sequenceIndex === this.currentSequence.length) {
					if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, this.index - 2);
					else this.cbs.oncomment(this.sectionStart, this.index - 2);
					this.sequenceIndex = 0;
					this.sectionStart = this.index + 1;
					this.state = 1;
				}
			} else if (this.sequenceIndex === 0) {
				if (this.fastForwardTo(this.currentSequence[0])) this.sequenceIndex = 1;
			} else if (c !== this.currentSequence[this.sequenceIndex - 1]) this.sequenceIndex = 0;
		}
		startSpecial(sequence, offset$1) {
			this.enterRCDATA(sequence, offset$1);
			this.state = 31;
		}
		enterRCDATA(sequence, offset$1) {
			this.inRCDATA = true;
			this.currentSequence = sequence;
			this.sequenceIndex = offset$1;
		}
		stateBeforeTagName(c) {
			if (c === 33) {
				this.state = 22;
				this.sectionStart = this.index + 1;
			} else if (c === 63) {
				this.state = 24;
				this.sectionStart = this.index + 1;
			} else if (isTagStartChar(c)) {
				this.sectionStart = this.index;
				if (this.mode === 0) this.state = 6;
				else if (this.inSFCRoot) this.state = 34;
				else if (!this.inXML) if (c === 116) this.state = 30;
				else this.state = c === 115 ? 29 : 6;
				else this.state = 6;
			} else if (c === 47) this.state = 8;
			else {
				this.state = 1;
				this.stateText(c);
			}
		}
		stateInTagName(c) {
			if (isEndOfTagSection(c)) this.handleTagName(c);
		}
		stateInSFCRootTagName(c) {
			if (isEndOfTagSection(c)) {
				const tag = this.buffer.slice(this.sectionStart, this.index);
				if (tag !== "template") this.enterRCDATA(toCharCodes(`</` + tag), 0);
				this.handleTagName(c);
			}
		}
		handleTagName(c) {
			this.cbs.onopentagname(this.sectionStart, this.index);
			this.sectionStart = -1;
			this.state = 11;
			this.stateBeforeAttrName(c);
		}
		stateBeforeClosingTagName(c) {
			if (isWhitespace(c));
			else if (c === 62) {
				this.cbs.onerr(14, this.index);
				this.state = 1;
				this.sectionStart = this.index + 1;
			} else {
				this.state = isTagStartChar(c) ? 9 : 27;
				this.sectionStart = this.index;
			}
		}
		stateInClosingTagName(c) {
			if (c === 62 || isWhitespace(c)) {
				this.cbs.onclosetag(this.sectionStart, this.index);
				this.sectionStart = -1;
				this.state = 10;
				this.stateAfterClosingTagName(c);
			}
		}
		stateAfterClosingTagName(c) {
			if (c === 62) {
				this.state = 1;
				this.sectionStart = this.index + 1;
			}
		}
		stateBeforeAttrName(c) {
			if (c === 62) {
				this.cbs.onopentagend(this.index);
				if (this.inRCDATA) this.state = 32;
				else this.state = 1;
				this.sectionStart = this.index + 1;
			} else if (c === 47) {
				this.state = 7;
				if (this.peek() !== 62) this.cbs.onerr(22, this.index);
			} else if (c === 60 && this.peek() === 47) {
				this.cbs.onopentagend(this.index);
				this.state = 5;
				this.sectionStart = this.index;
			} else if (!isWhitespace(c)) {
				if (c === 61) this.cbs.onerr(19, this.index);
				this.handleAttrStart(c);
			}
		}
		handleAttrStart(c) {
			if (c === 118 && this.peek() === 45) {
				this.state = 13;
				this.sectionStart = this.index;
			} else if (c === 46 || c === 58 || c === 64 || c === 35) {
				this.cbs.ondirname(this.index, this.index + 1);
				this.state = 14;
				this.sectionStart = this.index + 1;
			} else {
				this.state = 12;
				this.sectionStart = this.index;
			}
		}
		stateInSelfClosingTag(c) {
			if (c === 62) {
				this.cbs.onselfclosingtag(this.index);
				this.state = 1;
				this.sectionStart = this.index + 1;
				this.inRCDATA = false;
			} else if (!isWhitespace(c)) {
				this.state = 11;
				this.stateBeforeAttrName(c);
			}
		}
		stateInAttrName(c) {
			if (c === 61 || isEndOfTagSection(c)) {
				this.cbs.onattribname(this.sectionStart, this.index);
				this.handleAttrNameEnd(c);
			} else if (c === 34 || c === 39 || c === 60) this.cbs.onerr(17, this.index);
		}
		stateInDirName(c) {
			if (c === 61 || isEndOfTagSection(c)) {
				this.cbs.ondirname(this.sectionStart, this.index);
				this.handleAttrNameEnd(c);
			} else if (c === 58) {
				this.cbs.ondirname(this.sectionStart, this.index);
				this.state = 14;
				this.sectionStart = this.index + 1;
			} else if (c === 46) {
				this.cbs.ondirname(this.sectionStart, this.index);
				this.state = 16;
				this.sectionStart = this.index + 1;
			}
		}
		stateInDirArg(c) {
			if (c === 61 || isEndOfTagSection(c)) {
				this.cbs.ondirarg(this.sectionStart, this.index);
				this.handleAttrNameEnd(c);
			} else if (c === 91) this.state = 15;
			else if (c === 46) {
				this.cbs.ondirarg(this.sectionStart, this.index);
				this.state = 16;
				this.sectionStart = this.index + 1;
			}
		}
		stateInDynamicDirArg(c) {
			if (c === 93) this.state = 14;
			else if (c === 61 || isEndOfTagSection(c)) {
				this.cbs.ondirarg(this.sectionStart, this.index + 1);
				this.handleAttrNameEnd(c);
				this.cbs.onerr(27, this.index);
			}
		}
		stateInDirModifier(c) {
			if (c === 61 || isEndOfTagSection(c)) {
				this.cbs.ondirmodifier(this.sectionStart, this.index);
				this.handleAttrNameEnd(c);
			} else if (c === 46) {
				this.cbs.ondirmodifier(this.sectionStart, this.index);
				this.sectionStart = this.index + 1;
			}
		}
		handleAttrNameEnd(c) {
			this.sectionStart = this.index;
			this.state = 17;
			this.cbs.onattribnameend(this.index);
			this.stateAfterAttrName(c);
		}
		stateAfterAttrName(c) {
			if (c === 61) this.state = 18;
			else if (c === 47 || c === 62) {
				this.cbs.onattribend(0, this.sectionStart);
				this.sectionStart = -1;
				this.state = 11;
				this.stateBeforeAttrName(c);
			} else if (!isWhitespace(c)) {
				this.cbs.onattribend(0, this.sectionStart);
				this.handleAttrStart(c);
			}
		}
		stateBeforeAttrValue(c) {
			if (c === 34) {
				this.state = 19;
				this.sectionStart = this.index + 1;
			} else if (c === 39) {
				this.state = 20;
				this.sectionStart = this.index + 1;
			} else if (!isWhitespace(c)) {
				this.sectionStart = this.index;
				this.state = 21;
				this.stateInAttrValueNoQuotes(c);
			}
		}
		handleInAttrValue(c, quote) {
			if (c === quote || this.fastForwardTo(quote)) {
				this.cbs.onattribdata(this.sectionStart, this.index);
				this.sectionStart = -1;
				this.cbs.onattribend(quote === 34 ? 3 : 2, this.index + 1);
				this.state = 11;
			}
		}
		stateInAttrValueDoubleQuotes(c) {
			this.handleInAttrValue(c, 34);
		}
		stateInAttrValueSingleQuotes(c) {
			this.handleInAttrValue(c, 39);
		}
		stateInAttrValueNoQuotes(c) {
			if (isWhitespace(c) || c === 62) {
				this.cbs.onattribdata(this.sectionStart, this.index);
				this.sectionStart = -1;
				this.cbs.onattribend(1, this.index);
				this.state = 11;
				this.stateBeforeAttrName(c);
			} else if (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) this.cbs.onerr(18, this.index);
		}
		stateBeforeDeclaration(c) {
			if (c === 91) {
				this.state = 26;
				this.sequenceIndex = 0;
			} else this.state = c === 45 ? 25 : 23;
		}
		stateInDeclaration(c) {
			if (c === 62 || this.fastForwardTo(62)) {
				this.state = 1;
				this.sectionStart = this.index + 1;
			}
		}
		stateInProcessingInstruction(c) {
			if (c === 62 || this.fastForwardTo(62)) {
				this.cbs.onprocessinginstruction(this.sectionStart, this.index);
				this.state = 1;
				this.sectionStart = this.index + 1;
			}
		}
		stateBeforeComment(c) {
			if (c === 45) {
				this.state = 28;
				this.currentSequence = Sequences.CommentEnd;
				this.sequenceIndex = 2;
				this.sectionStart = this.index + 1;
			} else this.state = 23;
		}
		stateInSpecialComment(c) {
			if (c === 62 || this.fastForwardTo(62)) {
				this.cbs.oncomment(this.sectionStart, this.index);
				this.state = 1;
				this.sectionStart = this.index + 1;
			}
		}
		stateBeforeSpecialS(c) {
			if (c === Sequences.ScriptEnd[3]) this.startSpecial(Sequences.ScriptEnd, 4);
			else if (c === Sequences.StyleEnd[3]) this.startSpecial(Sequences.StyleEnd, 4);
			else {
				this.state = 6;
				this.stateInTagName(c);
			}
		}
		stateBeforeSpecialT(c) {
			if (c === Sequences.TitleEnd[3]) this.startSpecial(Sequences.TitleEnd, 4);
			else if (c === Sequences.TextareaEnd[3]) this.startSpecial(Sequences.TextareaEnd, 4);
			else {
				this.state = 6;
				this.stateInTagName(c);
			}
		}
		startEntity() {}
		stateInEntity() {}
		/**
		* Iterates through the buffer, calling the function corresponding to the current state.
		*
		* States that are more likely to be hit are higher up, as a performance improvement.
		*/
		parse(input) {
			this.buffer = input;
			while (this.index < this.buffer.length) {
				const c = this.buffer.charCodeAt(this.index);
				if (c === 10 && this.state !== 33) this.newlines.push(this.index);
				switch (this.state) {
					case 1:
						this.stateText(c);
						break;
					case 2:
						this.stateInterpolationOpen(c);
						break;
					case 3:
						this.stateInterpolation(c);
						break;
					case 4:
						this.stateInterpolationClose(c);
						break;
					case 31:
						this.stateSpecialStartSequence(c);
						break;
					case 32:
						this.stateInRCDATA(c);
						break;
					case 26:
						this.stateCDATASequence(c);
						break;
					case 19:
						this.stateInAttrValueDoubleQuotes(c);
						break;
					case 12:
						this.stateInAttrName(c);
						break;
					case 13:
						this.stateInDirName(c);
						break;
					case 14:
						this.stateInDirArg(c);
						break;
					case 15:
						this.stateInDynamicDirArg(c);
						break;
					case 16:
						this.stateInDirModifier(c);
						break;
					case 28:
						this.stateInCommentLike(c);
						break;
					case 27:
						this.stateInSpecialComment(c);
						break;
					case 11:
						this.stateBeforeAttrName(c);
						break;
					case 6:
						this.stateInTagName(c);
						break;
					case 34:
						this.stateInSFCRootTagName(c);
						break;
					case 9:
						this.stateInClosingTagName(c);
						break;
					case 5:
						this.stateBeforeTagName(c);
						break;
					case 17:
						this.stateAfterAttrName(c);
						break;
					case 20:
						this.stateInAttrValueSingleQuotes(c);
						break;
					case 18:
						this.stateBeforeAttrValue(c);
						break;
					case 8:
						this.stateBeforeClosingTagName(c);
						break;
					case 10:
						this.stateAfterClosingTagName(c);
						break;
					case 29:
						this.stateBeforeSpecialS(c);
						break;
					case 30:
						this.stateBeforeSpecialT(c);
						break;
					case 21:
						this.stateInAttrValueNoQuotes(c);
						break;
					case 7:
						this.stateInSelfClosingTag(c);
						break;
					case 23:
						this.stateInDeclaration(c);
						break;
					case 22:
						this.stateBeforeDeclaration(c);
						break;
					case 25:
						this.stateBeforeComment(c);
						break;
					case 24:
						this.stateInProcessingInstruction(c);
						break;
					case 33:
						this.stateInEntity();
						break;
				}
				this.index++;
			}
			this.cleanup();
			this.finish();
		}
		/**
		* Remove data that has already been consumed from the buffer.
		*/
		cleanup() {
			if (this.sectionStart !== this.index) {
				if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
					this.cbs.ontext(this.sectionStart, this.index);
					this.sectionStart = this.index;
				} else if (this.state === 19 || this.state === 20 || this.state === 21) {
					this.cbs.onattribdata(this.sectionStart, this.index);
					this.sectionStart = this.index;
				}
			}
		}
		finish() {
			this.handleTrailingData();
			this.cbs.onend();
		}
		/** Handle any trailing data. */
		handleTrailingData() {
			const endIndex = this.buffer.length;
			if (this.sectionStart >= endIndex) return;
			if (this.state === 28) if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, endIndex);
			else this.cbs.oncomment(this.sectionStart, endIndex);
			else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9);
			else this.cbs.ontext(this.sectionStart, endIndex);
		}
		emitCodePoint(cp, consumed) {}
	};
	CompilerDeprecationTypes = {
		"COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT",
		"COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC",
		"COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER",
		"COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE",
		"COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE",
		"COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE",
		"COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE",
		"COMPILER_FILTERS": "COMPILER_FILTERS"
	};
	deprecationData = {
		["COMPILER_IS_ON_ELEMENT"]: {
			message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
			link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`
		},
		["COMPILER_V_BIND_SYNC"]: {
			message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
			link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
		},
		["COMPILER_V_BIND_OBJECT_ORDER"]: {
			message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
			link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
		},
		["COMPILER_V_ON_NATIVE"]: {
			message: `.native modifier for v-on has been removed as is no longer necessary.`,
			link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`
		},
		["COMPILER_V_IF_V_FOR_PRECEDENCE"]: {
			message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,
			link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`
		},
		["COMPILER_NATIVE_TEMPLATE"]: { message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.` },
		["COMPILER_INLINE_TEMPLATE"]: {
			message: `"inline-template" has been removed in Vue 3.`,
			link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`
		},
		["COMPILER_FILTERS"]: {
			message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,
			link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
		}
	};
	ErrorCodes = {
		"ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0,
		"0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT",
		"CDATA_IN_HTML_CONTENT": 1,
		"1": "CDATA_IN_HTML_CONTENT",
		"DUPLICATE_ATTRIBUTE": 2,
		"2": "DUPLICATE_ATTRIBUTE",
		"END_TAG_WITH_ATTRIBUTES": 3,
		"3": "END_TAG_WITH_ATTRIBUTES",
		"END_TAG_WITH_TRAILING_SOLIDUS": 4,
		"4": "END_TAG_WITH_TRAILING_SOLIDUS",
		"EOF_BEFORE_TAG_NAME": 5,
		"5": "EOF_BEFORE_TAG_NAME",
		"EOF_IN_CDATA": 6,
		"6": "EOF_IN_CDATA",
		"EOF_IN_COMMENT": 7,
		"7": "EOF_IN_COMMENT",
		"EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8,
		"8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT",
		"EOF_IN_TAG": 9,
		"9": "EOF_IN_TAG",
		"INCORRECTLY_CLOSED_COMMENT": 10,
		"10": "INCORRECTLY_CLOSED_COMMENT",
		"INCORRECTLY_OPENED_COMMENT": 11,
		"11": "INCORRECTLY_OPENED_COMMENT",
		"INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12,
		"12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME",
		"MISSING_ATTRIBUTE_VALUE": 13,
		"13": "MISSING_ATTRIBUTE_VALUE",
		"MISSING_END_TAG_NAME": 14,
		"14": "MISSING_END_TAG_NAME",
		"MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15,
		"15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES",
		"NESTED_COMMENT": 16,
		"16": "NESTED_COMMENT",
		"UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17,
		"17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME",
		"UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18,
		"18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE",
		"UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19,
		"19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME",
		"UNEXPECTED_NULL_CHARACTER": 20,
		"20": "UNEXPECTED_NULL_CHARACTER",
		"UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21,
		"21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME",
		"UNEXPECTED_SOLIDUS_IN_TAG": 22,
		"22": "UNEXPECTED_SOLIDUS_IN_TAG",
		"X_INVALID_END_TAG": 23,
		"23": "X_INVALID_END_TAG",
		"X_MISSING_END_TAG": 24,
		"24": "X_MISSING_END_TAG",
		"X_MISSING_INTERPOLATION_END": 25,
		"25": "X_MISSING_INTERPOLATION_END",
		"X_MISSING_DIRECTIVE_NAME": 26,
		"26": "X_MISSING_DIRECTIVE_NAME",
		"X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27,
		"27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END",
		"X_V_IF_NO_EXPRESSION": 28,
		"28": "X_V_IF_NO_EXPRESSION",
		"X_V_IF_SAME_KEY": 29,
		"29": "X_V_IF_SAME_KEY",
		"X_V_ELSE_NO_ADJACENT_IF": 30,
		"30": "X_V_ELSE_NO_ADJACENT_IF",
		"X_V_FOR_NO_EXPRESSION": 31,
		"31": "X_V_FOR_NO_EXPRESSION",
		"X_V_FOR_MALFORMED_EXPRESSION": 32,
		"32": "X_V_FOR_MALFORMED_EXPRESSION",
		"X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33,
		"33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT",
		"X_V_BIND_NO_EXPRESSION": 34,
		"34": "X_V_BIND_NO_EXPRESSION",
		"X_V_ON_NO_EXPRESSION": 35,
		"35": "X_V_ON_NO_EXPRESSION",
		"X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36,
		"36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET",
		"X_V_SLOT_MIXED_SLOT_USAGE": 37,
		"37": "X_V_SLOT_MIXED_SLOT_USAGE",
		"X_V_SLOT_DUPLICATE_SLOT_NAMES": 38,
		"38": "X_V_SLOT_DUPLICATE_SLOT_NAMES",
		"X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39,
		"39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN",
		"X_V_SLOT_MISPLACED": 40,
		"40": "X_V_SLOT_MISPLACED",
		"X_V_MODEL_NO_EXPRESSION": 41,
		"41": "X_V_MODEL_NO_EXPRESSION",
		"X_V_MODEL_MALFORMED_EXPRESSION": 42,
		"42": "X_V_MODEL_MALFORMED_EXPRESSION",
		"X_V_MODEL_ON_SCOPE_VARIABLE": 43,
		"43": "X_V_MODEL_ON_SCOPE_VARIABLE",
		"X_V_MODEL_ON_PROPS": 44,
		"44": "X_V_MODEL_ON_PROPS",
		"X_INVALID_EXPRESSION": 45,
		"45": "X_INVALID_EXPRESSION",
		"X_KEEP_ALIVE_INVALID_CHILDREN": 46,
		"46": "X_KEEP_ALIVE_INVALID_CHILDREN",
		"X_PREFIX_ID_NOT_SUPPORTED": 47,
		"47": "X_PREFIX_ID_NOT_SUPPORTED",
		"X_MODULE_MODE_NOT_SUPPORTED": 48,
		"48": "X_MODULE_MODE_NOT_SUPPORTED",
		"X_CACHE_HANDLER_NOT_SUPPORTED": 49,
		"49": "X_CACHE_HANDLER_NOT_SUPPORTED",
		"X_SCOPE_ID_NOT_SUPPORTED": 50,
		"50": "X_SCOPE_ID_NOT_SUPPORTED",
		"X_VNODE_HOOKS": 51,
		"51": "X_VNODE_HOOKS",
		"X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 52,
		"52": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT",
		"__EXTEND_POINT__": 53,
		"53": "__EXTEND_POINT__"
	};
	errorMessages = {
		[0]: "Illegal comment.",
		[1]: "CDATA section is allowed only in XML context.",
		[2]: "Duplicate attribute.",
		[3]: "End tag cannot have attributes.",
		[4]: "Illegal '/' in tags.",
		[5]: "Unexpected EOF in tag.",
		[6]: "Unexpected EOF in CDATA section.",
		[7]: "Unexpected EOF in comment.",
		[8]: "Unexpected EOF in script.",
		[9]: "Unexpected EOF in tag.",
		[10]: "Incorrectly closed comment.",
		[11]: "Incorrectly opened comment.",
		[12]: "Illegal tag name. Use '&lt;' to print '<'.",
		[13]: "Attribute value was expected.",
		[14]: "End tag name was expected.",
		[15]: "Whitespace was expected.",
		[16]: "Unexpected '<!--' in comment.",
		[17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
		[18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
		[19]: "Attribute name cannot start with '='.",
		[21]: "'<?' is allowed only in XML context.",
		[20]: `Unexpected null character.`,
		[22]: "Illegal '/' in tags.",
		[23]: "Invalid end tag.",
		[24]: "Element is missing end tag.",
		[25]: "Interpolation end sign was not found.",
		[27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
		[26]: "Legal directive name was expected.",
		[28]: `v-if/v-else-if is missing expression.`,
		[29]: `v-if/else branches must use unique keys.`,
		[30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
		[31]: `v-for is missing expression.`,
		[32]: `v-for has invalid expression.`,
		[33]: `<template v-for> key should be placed on the <template> tag.`,
		[34]: `v-bind is missing expression.`,
		[52]: `v-bind with same-name shorthand only allows static argument.`,
		[35]: `v-on is missing expression.`,
		[36]: `Unexpected custom directive on <slot> outlet.`,
		[37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
		[38]: `Duplicate slot names found. `,
		[39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
		[40]: `v-slot can only be used on components or <template> tags.`,
		[41]: `v-model is missing expression.`,
		[42]: `v-model value must be a valid JavaScript member expression.`,
		[43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
		[44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
		[45]: `Error parsing JavaScript expression: `,
		[46]: `<KeepAlive> expects exactly one child component.`,
		[51]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`,
		[47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
		[48]: `ES module mode is not supported in this build of compiler.`,
		[49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
		[50]: `"scopeId" option is only supported in module mode.`,
		[53]: ``
	};
	isFunctionType = (node) => {
		return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
	};
	isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
	isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
	TS_NODE_TYPES = [
		"TSAsExpression",
		"TSTypeAssertion",
		"TSNonNullExpression",
		"TSInstantiationExpression",
		"TSSatisfiesExpression"
	];
	isStaticExp = (p) => p.type === 4 && p.isStatic;
	nonIdentifierRE = /^$|^\d|[^\$\w\xA0-\uFFFF]/;
	isSimpleIdentifier = (name$111) => !nonIdentifierRE.test(name$111);
	validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
	validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
	whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
	getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
	isMemberExpressionBrowser = (exp) => {
		const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
		let state = 0;
		let stateStack = [];
		let currentOpenBracketCount = 0;
		let currentOpenParensCount = 0;
		let currentStringType = null;
		for (let i = 0; i < path.length; i++) {
			const char = path.charAt(i);
			switch (state) {
				case 0:
					if (char === "[") {
						stateStack.push(state);
						state = 1;
						currentOpenBracketCount++;
					} else if (char === "(") {
						stateStack.push(state);
						state = 2;
						currentOpenParensCount++;
					} else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) return false;
					break;
				case 1:
					if (char === `'` || char === `"` || char === "`") {
						stateStack.push(state);
						state = 3;
						currentStringType = char;
					} else if (char === `[`) currentOpenBracketCount++;
					else if (char === `]`) {
						if (!--currentOpenBracketCount) state = stateStack.pop();
					}
					break;
				case 2:
					if (char === `'` || char === `"` || char === "`") {
						stateStack.push(state);
						state = 3;
						currentStringType = char;
					} else if (char === `(`) currentOpenParensCount++;
					else if (char === `)`) {
						if (i === path.length - 1) return false;
						if (!--currentOpenParensCount) state = stateStack.pop();
					}
					break;
				case 3:
					if (char === currentStringType) {
						state = stateStack.pop();
						currentStringType = null;
					}
					break;
			}
		}
		return !currentOpenBracketCount && !currentOpenParensCount;
	};
	isMemberExpressionNode = NOOP;
	isMemberExpression = isMemberExpressionBrowser;
	fnExpRE = /^\s*(?:async\s*)?(?:\([^)]*?\)|[\w$_]+)\s*(?::[^=]+)?=>|^\s*(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/;
	isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
	isFnExpressionNode = NOOP;
	isFnExpression = isFnExpressionBrowser;
	propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
	forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
	defaultParserOptions = {
		parseMode: "base",
		ns: 0,
		delimiters: [`{{`, `}}`],
		getNamespace: () => 0,
		isVoidTag: NO,
		isPreTag: NO,
		isIgnoreNewlineTag: NO,
		isCustomElement: NO,
		onError: defaultOnError,
		onWarn: defaultOnWarn,
		comments: true,
		prefixIdentifiers: false
	};
	currentOptions$3 = defaultParserOptions;
	currentRoot = null;
	currentInput = "";
	currentOpenTag = null;
	currentProp = null;
	currentAttrValue = "";
	currentAttrStartIndex = -1;
	currentAttrEndIndex = -1;
	inPre = 0;
	inVPre = false;
	currentVPreBoundary = null;
	stack = [];
	tokenizer = new Tokenizer(stack, {
		onerr: emitError,
		ontext(start$1, end$1) {
			onText(getSlice(start$1, end$1), start$1, end$1);
		},
		ontextentity(char, start$1, end$1) {
			onText(char, start$1, end$1);
		},
		oninterpolation(start$1, end$1) {
			if (inVPre) return onText(getSlice(start$1, end$1), start$1, end$1);
			let innerStart = start$1 + tokenizer.delimiterOpen.length;
			let innerEnd = end$1 - tokenizer.delimiterClose.length;
			while (isWhitespace(currentInput.charCodeAt(innerStart))) innerStart++;
			while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) innerEnd--;
			let exp = getSlice(innerStart, innerEnd);
			if (exp.includes("&")) exp = currentOptions$3.decodeEntities(exp, false);
			addNode({
				type: 5,
				content: createExp(exp, false, getLoc(innerStart, innerEnd)),
				loc: getLoc(start$1, end$1)
			});
		},
		onopentagname(start$1, end$1) {
			const name$111 = getSlice(start$1, end$1);
			currentOpenTag = {
				type: 1,
				tag: name$111,
				ns: currentOptions$3.getNamespace(name$111, stack[0], currentOptions$3.ns),
				tagType: 0,
				props: [],
				children: [],
				loc: getLoc(start$1 - 1, end$1),
				codegenNode: void 0
			};
		},
		onopentagend(end$1) {
			endOpenTag(end$1);
		},
		onclosetag(start$1, end$1) {
			const name$111 = getSlice(start$1, end$1);
			if (!currentOptions$3.isVoidTag(name$111)) {
				let found = false;
				for (let i = 0; i < stack.length; i++) if (stack[i].tag.toLowerCase() === name$111.toLowerCase()) {
					found = true;
					if (i > 0) emitError(24, stack[0].loc.start.offset);
					for (let j = 0; j <= i; j++) onCloseTag(stack.shift(), end$1, j < i);
					break;
				}
				if (!found) emitError(23, backTrack(start$1, 60));
			}
		},
		onselfclosingtag(end$1) {
			const name$111 = currentOpenTag.tag;
			currentOpenTag.isSelfClosing = true;
			endOpenTag(end$1);
			if (stack[0] && stack[0].tag === name$111) onCloseTag(stack.shift(), end$1);
		},
		onattribname(start$1, end$1) {
			currentProp = {
				type: 6,
				name: getSlice(start$1, end$1),
				nameLoc: getLoc(start$1, end$1),
				value: void 0,
				loc: getLoc(start$1)
			};
		},
		ondirname(start$1, end$1) {
			const raw = getSlice(start$1, end$1);
			const name$111 = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
			if (!inVPre && name$111 === "") emitError(26, start$1);
			if (inVPre || name$111 === "") currentProp = {
				type: 6,
				name: raw,
				nameLoc: getLoc(start$1, end$1),
				value: void 0,
				loc: getLoc(start$1)
			};
			else {
				currentProp = {
					type: 7,
					name: name$111,
					rawName: raw,
					exp: void 0,
					arg: void 0,
					modifiers: raw === "." ? [createSimpleExpression("prop")] : [],
					loc: getLoc(start$1)
				};
				if (name$111 === "pre") {
					inVPre = tokenizer.inVPre = true;
					currentVPreBoundary = currentOpenTag;
					const props$1 = currentOpenTag.props;
					for (let i = 0; i < props$1.length; i++) if (props$1[i].type === 7) props$1[i] = dirToAttr(props$1[i]);
				}
			}
		},
		ondirarg(start$1, end$1) {
			if (start$1 === end$1) return;
			const arg = getSlice(start$1, end$1);
			if (inVPre && !isVPre(currentProp)) {
				currentProp.name += arg;
				setLocEnd(currentProp.nameLoc, end$1);
			} else {
				const isStatic = arg[0] !== `[`;
				currentProp.arg = createExp(isStatic ? arg : arg.slice(1, -1), isStatic, getLoc(start$1, end$1), isStatic ? 3 : 0);
			}
		},
		ondirmodifier(start$1, end$1) {
			const mod = getSlice(start$1, end$1);
			if (inVPre && !isVPre(currentProp)) {
				currentProp.name += "." + mod;
				setLocEnd(currentProp.nameLoc, end$1);
			} else if (currentProp.name === "slot") {
				const arg = currentProp.arg;
				if (arg) {
					arg.content += "." + mod;
					setLocEnd(arg.loc, end$1);
				}
			} else {
				const exp = createSimpleExpression(mod, true, getLoc(start$1, end$1));
				currentProp.modifiers.push(exp);
			}
		},
		onattribdata(start$1, end$1) {
			currentAttrValue += getSlice(start$1, end$1);
			if (currentAttrStartIndex < 0) currentAttrStartIndex = start$1;
			currentAttrEndIndex = end$1;
		},
		onattribentity(char, start$1, end$1) {
			currentAttrValue += char;
			if (currentAttrStartIndex < 0) currentAttrStartIndex = start$1;
			currentAttrEndIndex = end$1;
		},
		onattribnameend(end$1) {
			const start$1 = currentProp.loc.start.offset;
			const name$111 = getSlice(start$1, end$1);
			if (currentProp.type === 7) currentProp.rawName = name$111;
			if (currentOpenTag.props.some((p) => (p.type === 7 ? p.rawName : p.name) === name$111)) emitError(2, start$1);
		},
		onattribend(quote, end$1) {
			if (currentOpenTag && currentProp) {
				setLocEnd(currentProp.loc, end$1);
				if (quote !== 0) {
					if (currentAttrValue.includes("&")) currentAttrValue = currentOptions$3.decodeEntities(currentAttrValue, true);
					if (currentProp.type === 6) {
						if (currentProp.name === "class") currentAttrValue = condense(currentAttrValue).trim();
						if (quote === 1 && !currentAttrValue) emitError(13, end$1);
						currentProp.value = {
							type: 2,
							content: currentAttrValue,
							loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
						};
						if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
					} else {
						currentProp.exp = createExp(currentAttrValue, false, getLoc(currentAttrStartIndex, currentAttrEndIndex), 0, 0);
						if (currentProp.name === "for") currentProp.forParseResult = parseForExpression(currentProp.exp);
						let syncIndex = -1;
						if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.findIndex((mod) => mod.content === "sync")) > -1 && checkCompatEnabled("COMPILER_V_BIND_SYNC", currentOptions$3, currentProp.loc, currentProp.arg.loc.source)) {
							currentProp.name = "model";
							currentProp.modifiers.splice(syncIndex, 1);
						}
					}
				}
				if (currentProp.type !== 7 || currentProp.name !== "pre") currentOpenTag.props.push(currentProp);
			}
			currentAttrValue = "";
			currentAttrStartIndex = currentAttrEndIndex = -1;
		},
		oncomment(start$1, end$1) {
			if (currentOptions$3.comments) addNode({
				type: 3,
				content: getSlice(start$1, end$1),
				loc: getLoc(start$1 - 4, end$1 + 3)
			});
		},
		onend() {
			const end$1 = currentInput.length;
			if (tokenizer.state !== 1) switch (tokenizer.state) {
				case 5:
				case 8:
					emitError(5, end$1);
					break;
				case 3:
				case 4:
					emitError(25, tokenizer.sectionStart);
					break;
				case 28:
					if (tokenizer.currentSequence === Sequences.CdataEnd) emitError(6, end$1);
					else emitError(7, end$1);
					break;
				case 6:
				case 7:
				case 9:
				case 11:
				case 12:
				case 13:
				case 14:
				case 15:
				case 16:
				case 17:
				case 18:
				case 19:
				case 20:
				case 21:
					emitError(9, end$1);
					break;
			}
			for (let index = 0; index < stack.length; index++) {
				onCloseTag(stack[index], end$1 - 1);
				emitError(24, stack[index].loc.start.offset);
			}
		},
		oncdata(start$1, end$1) {
			if (stack[0].ns !== 0) onText(getSlice(start$1, end$1), start$1, end$1);
			else emitError(1, start$1 - 9);
		},
		onprocessinginstruction(start$1) {
			if ((stack[0] ? stack[0].ns : currentOptions$3.ns) === 0) emitError(21, start$1 - 1);
		}
	});
	forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
	stripParensRE = /^\(|\)$/g;
	specialTemplateDir = /* @__PURE__ */ new Set([
		"if",
		"else",
		"else-if",
		"for",
		"slot"
	]);
	windowsNewlineRE = /\r\n/g;
	allowHoistedHelperSet = /* @__PURE__ */ new Set([
		NORMALIZE_CLASS,
		NORMALIZE_STYLE,
		NORMALIZE_PROPS,
		GUARD_REACTIVE_PROPS
	]);
	PURE_ANNOTATION = `/*@__PURE__*/`;
	aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
	prohibitedKeywordRE = /* @__PURE__ */ new RegExp("\\b" + "arguments,await,break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,let,new,return,super,switch,throw,try,var,void,while,with,yield".split(",").join("\\b|\\b") + "\\b");
	stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
	transformExpression = (node, context) => {
		if (node.type === 5) node.content = processExpression(node.content, context);
		else if (node.type === 1) {
			const memo = findDir(node, "memo");
			for (let i = 0; i < node.props.length; i++) {
				const dir = node.props[i];
				if (dir.type === 7 && dir.name !== "for") {
					const exp = dir.exp;
					const arg = dir.arg;
					if (exp && exp.type === 4 && !(dir.name === "on" && arg) && !(memo && arg && arg.type === 4 && arg.content === "key")) dir.exp = processExpression(exp, context, dir.name === "slot");
					if (arg && arg.type === 4 && !arg.isStatic) dir.arg = processExpression(arg, context);
				}
			}
		}
	};
	transformIf = createStructuralDirectiveTransform(/^(?:if|else|else-if)$/, (node, dir, context) => {
		return processIf(node, dir, context, (ifNode, branch, isRoot) => {
			const siblings = context.parent.children;
			let i = siblings.indexOf(ifNode);
			let key = 0;
			while (i-- >= 0) {
				const sibling = siblings[i];
				if (sibling && sibling.type === 9) key += sibling.branches.length;
			}
			return () => {
				if (isRoot) ifNode.codegenNode = createCodegenNodeForBranch(branch, key, context);
				else {
					const parentCondition = getParentCondition(ifNode.codegenNode);
					parentCondition.alternate = createCodegenNodeForBranch(branch, key + ifNode.branches.length - 1, context);
				}
			};
		});
	});
	transformFor = createStructuralDirectiveTransform("for", (node, dir, context) => {
		const { helper, removeHelper } = context;
		return processFor(node, dir, context, (forNode) => {
			const renderExp = createCallExpression(helper(RENDER_LIST), [forNode.source]);
			const isTemplate = isTemplateNode(node);
			const memo = findDir(node, "memo");
			const keyProp = findProp(node, `key`, false, true);
			keyProp && keyProp.type;
			let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
			const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;
			const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
			const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
			forNode.codegenNode = createVNodeCall(context, helper(FRAGMENT), void 0, renderExp, fragmentFlag, void 0, void 0, true, !isStableFragment, false, node.loc);
			return () => {
				let childBlock;
				const { children } = forNode;
				if (isTemplate) node.children.some((c) => {
					if (c.type === 1) {
						const key = findProp(c, "key");
						if (key) {
							context.onError(createCompilerError(33, key.loc));
							return true;
						}
					}
				});
				const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
				const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
				if (slotOutlet) {
					childBlock = slotOutlet.codegenNode;
					if (isTemplate && keyProperty) injectProp(childBlock, keyProperty, context);
				} else if (needFragmentWrapper) childBlock = createVNodeCall(context, helper(FRAGMENT), keyProperty ? createObjectExpression([keyProperty]) : void 0, node.children, 64, void 0, void 0, true, void 0, false);
				else {
					childBlock = children[0].codegenNode;
					if (isTemplate && keyProperty) injectProp(childBlock, keyProperty, context);
					if (childBlock.isBlock !== !isStableFragment) if (childBlock.isBlock) {
						removeHelper(OPEN_BLOCK);
						removeHelper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
					} else removeHelper(getVNodeHelper(context.inSSR, childBlock.isComponent));
					childBlock.isBlock = !isStableFragment;
					if (childBlock.isBlock) {
						helper(OPEN_BLOCK);
						helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
					} else helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
				}
				if (memo) {
					const loop = createFunctionExpression(createForLoopParams(forNode.parseResult, [createSimpleExpression(`_cached`)]));
					loop.body = createBlockStatement([
						createCompoundExpression([
							`const _memo = (`,
							memo.exp,
							`)`
						]),
						createCompoundExpression([
							`if (_cached`,
							...keyExp ? [` && _cached.key === `, keyExp] : [],
							` && ${context.helperString(IS_MEMO_SAME)}(_cached, _memo)) return _cached`
						]),
						createCompoundExpression([`const _item = `, childBlock]),
						createSimpleExpression(`_item.memo = _memo`),
						createSimpleExpression(`return _item`)
					]);
					renderExp.arguments.push(loop, createSimpleExpression(`_cache`), createSimpleExpression(String(context.cached.length)));
					context.cached.push(null);
				} else renderExp.arguments.push(createFunctionExpression(createForLoopParams(forNode.parseResult), childBlock, true));
			};
		});
	});
	defaultFallback = createSimpleExpression(`undefined`, false);
	trackSlotScopes = (node, context) => {
		if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
			const vSlot = findDir(node, "slot");
			if (vSlot) {
				vSlot.exp;
				context.scopes.vSlot++;
				return () => {
					context.scopes.vSlot--;
				};
			}
		}
	};
	trackVForSlotScopes = (node, context) => {
		let vFor;
		if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
			const result = vFor.forParseResult;
			if (result) {
				finalizeForParseResult(result, context);
				const { value, key, index } = result;
				const { addIdentifiers, removeIdentifiers } = context;
				value && addIdentifiers(value);
				key && addIdentifiers(key);
				index && addIdentifiers(index);
				return () => {
					value && removeIdentifiers(value);
					key && removeIdentifiers(key);
					index && removeIdentifiers(index);
				};
			}
		}
	};
	buildClientSlotFn = (props$1, _vForExp, children, loc) => createFunctionExpression(props$1, children, false, true, children.length ? children[0].loc : loc);
	directiveImportMap = /* @__PURE__ */ new WeakMap();
	transformElement = (node, context) => {
		return function postTransformElement() {
			node = context.currentNode;
			if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) return;
			const { tag, props: props$1 } = node;
			const isComponent$1 = node.tagType === 1;
			let vnodeTag = isComponent$1 ? resolveComponentType(node, context) : `"${tag}"`;
			const isDynamicComponent = isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
			let vnodeProps;
			let vnodeChildren;
			let patchFlag = 0;
			let vnodeDynamicProps;
			let dynamicPropNames;
			let vnodeDirectives;
			let shouldUseBlock = isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent$1 && (tag === "svg" || tag === "foreignObject" || tag === "math");
			if (props$1.length > 0) {
				const propsBuildResult = buildProps(node, context, void 0, isComponent$1, isDynamicComponent);
				vnodeProps = propsBuildResult.props;
				patchFlag = propsBuildResult.patchFlag;
				dynamicPropNames = propsBuildResult.dynamicPropNames;
				const directives = propsBuildResult.directives;
				vnodeDirectives = directives && directives.length ? createArrayExpression(directives.map((dir) => buildDirectiveArgs(dir, context))) : void 0;
				if (propsBuildResult.shouldUseBlock) shouldUseBlock = true;
			}
			if (node.children.length > 0) {
				if (vnodeTag === KEEP_ALIVE) {
					shouldUseBlock = true;
					patchFlag |= 1024;
					if (node.children.length > 1) context.onError(createCompilerError(46, {
						start: node.children[0].loc.start,
						end: node.children[node.children.length - 1].loc.end,
						source: ""
					}));
				}
				if (isComponent$1 && vnodeTag !== TELEPORT && vnodeTag !== KEEP_ALIVE) {
					const { slots, hasDynamicSlots } = buildSlots(node, context);
					vnodeChildren = slots;
					if (hasDynamicSlots) patchFlag |= 1024;
				} else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
					const child = node.children[0];
					const type = child.type;
					const hasDynamicTextChild = type === 5 || type === 8;
					if (hasDynamicTextChild && getConstantType(child, context) === 0) patchFlag |= 1;
					if (hasDynamicTextChild || type === 2) vnodeChildren = child;
					else vnodeChildren = node.children;
				} else vnodeChildren = node.children;
			}
			if (dynamicPropNames && dynamicPropNames.length) vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
			node.codegenNode = createVNodeCall(context, vnodeTag, vnodeProps, vnodeChildren, patchFlag === 0 ? void 0 : patchFlag, vnodeDynamicProps, vnodeDirectives, !!shouldUseBlock, false, isComponent$1, node.loc);
		};
	};
	transformSlotOutlet = (node, context) => {
		if (isSlotOutlet(node)) {
			const { children, loc } = node;
			const { slotName, slotProps } = processSlotOutlet(node, context);
			const slotArgs = [
				context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
				slotName,
				"{}",
				"undefined",
				"true"
			];
			let expectedLen = 2;
			if (slotProps) {
				slotArgs[2] = slotProps;
				expectedLen = 3;
			}
			if (children.length) {
				slotArgs[3] = createFunctionExpression([], children, false, false, loc);
				expectedLen = 4;
			}
			if (context.scopeId && !context.slotted) expectedLen = 5;
			slotArgs.splice(expectedLen);
			node.codegenNode = createCallExpression(context.helper(RENDER_SLOT), slotArgs, loc);
		}
	};
	transformOn = (dir, node, context, augmentor) => {
		const { loc, modifiers, arg } = dir;
		if (!dir.exp && !modifiers.length) context.onError(createCompilerError(35, loc));
		let eventName;
		if (arg.type === 4) if (arg.isStatic) {
			let rawName = arg.content;
			if (rawName.startsWith("vnode")) context.onError(createCompilerError(51, arg.loc));
			if (rawName.startsWith("vue:")) rawName = `vnode-${rawName.slice(4)}`;
			eventName = createSimpleExpression(node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? toHandlerKey(camelize$1(rawName)) : `on:${rawName}`, true, arg.loc);
		} else eventName = createCompoundExpression([
			`${context.helperString(TO_HANDLER_KEY)}(`,
			arg,
			`)`
		]);
		else {
			eventName = arg;
			eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
			eventName.children.push(`)`);
		}
		let exp = dir.exp;
		if (exp && !exp.content.trim()) exp = void 0;
		let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
		if (exp) {
			const isMemberExp = isMemberExpression(exp);
			const isInlineStatement = !(isMemberExp || isFnExpression(exp));
			const hasMultipleStatements = exp.content.includes(`;`);
			validateBrowserExpression(exp, context, false, hasMultipleStatements);
			if (isInlineStatement || shouldCache && isMemberExp) exp = createCompoundExpression([
				`${isInlineStatement ? `$event` : `(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
				exp,
				hasMultipleStatements ? `}` : `)`
			]);
		}
		let ret = { props: [createObjectProperty(eventName, exp || createSimpleExpression(`() => {}`, false, loc))] };
		if (augmentor) ret = augmentor(ret);
		if (shouldCache) ret.props[0].value = context.cache(ret.props[0].value);
		ret.props.forEach((p) => p.key.isHandlerKey = true);
		return ret;
	};
	transformBind = (dir, _node, context) => {
		const { modifiers, loc } = dir;
		const arg = dir.arg;
		let { exp } = dir;
		if (exp && exp.type === 4 && !exp.content.trim()) exp = void 0;
		if (arg.type !== 4) {
			arg.children.unshift(`(`);
			arg.children.push(`) || ""`);
		} else if (!arg.isStatic) arg.content = arg.content ? `${arg.content} || ""` : `""`;
		if (modifiers.some((mod) => mod.content === "camel")) if (arg.type === 4) if (arg.isStatic) arg.content = camelize$1(arg.content);
		else arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
		else {
			arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
			arg.children.push(`)`);
		}
		if (!context.inSSR) {
			if (modifiers.some((mod) => mod.content === "prop")) injectPrefix(arg, ".");
			if (modifiers.some((mod) => mod.content === "attr")) injectPrefix(arg, "^");
		}
		return { props: [createObjectProperty(arg, exp)] };
	};
	injectPrefix = (arg, prefix) => {
		if (arg.type === 4) if (arg.isStatic) arg.content = prefix + arg.content;
		else arg.content = `\`${prefix}\${${arg.content}}\``;
		else {
			arg.children.unshift(`'${prefix}' + (`);
			arg.children.push(`)`);
		}
	};
	transformText = (node, context) => {
		if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) return () => {
			const children = node.children;
			let currentContainer = void 0;
			let hasText = false;
			for (let i = 0; i < children.length; i++) {
				const child = children[i];
				if (isText$1(child)) {
					hasText = true;
					for (let j = i + 1; j < children.length; j++) {
						const next = children[j];
						if (isText$1(next)) {
							if (!currentContainer) currentContainer = children[i] = createCompoundExpression([child], child.loc);
							currentContainer.children.push(` + `, next);
							children.splice(j, 1);
							j--;
						} else {
							currentContainer = void 0;
							break;
						}
					}
				}
			}
			if (!hasText || children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && !node.props.find((p) => p.type === 7 && !context.directiveTransforms[p.name]) && !(node.tag === "template"))) return;
			for (let i = 0; i < children.length; i++) {
				const child = children[i];
				if (isText$1(child) || child.type === 8) {
					const callArgs = [];
					if (child.type !== 2 || child.content !== " ") callArgs.push(child);
					if (!context.ssr && getConstantType(child, context) === 0) callArgs.push(`1 /* ${PatchFlagNames[1]} */`);
					children[i] = {
						type: 12,
						content: child,
						loc: child.loc,
						codegenNode: createCallExpression(context.helper(CREATE_TEXT), callArgs)
					};
				}
			}
		};
	};
	seen$1 = /* @__PURE__ */ new WeakSet();
	transformOnce = (node, context) => {
		if (node.type === 1 && findDir(node, "once", true)) {
			if (seen$1.has(node) || context.inVOnce || context.inSSR) return;
			seen$1.add(node);
			context.inVOnce = true;
			context.helper(SET_BLOCK_TRACKING);
			return () => {
				context.inVOnce = false;
				const cur = context.currentNode;
				if (cur.codegenNode) cur.codegenNode = context.cache(cur.codegenNode, true, true);
			};
		}
	};
	transformModel = (dir, node, context) => {
		const { exp, arg } = dir;
		if (!exp) {
			context.onError(createCompilerError(41, dir.loc));
			return createTransformProps();
		}
		const rawExp = exp.loc.source.trim();
		const expString = exp.type === 4 ? exp.content : rawExp;
		const bindingType = context.bindingMetadata[rawExp];
		if (bindingType === "props" || bindingType === "props-aliased") {
			context.onError(createCompilerError(44, exp.loc));
			return createTransformProps();
		}
		if (!expString.trim() || !isMemberExpression(exp) && true) {
			context.onError(createCompilerError(42, exp.loc));
			return createTransformProps();
		}
		const propName = arg ? arg : createSimpleExpression("modelValue", true);
		const eventName = arg ? isStaticExp(arg) ? `onUpdate:${camelize$1(arg.content)}` : createCompoundExpression(["\"onUpdate:\" + ", arg]) : `onUpdate:modelValue`;
		let assignmentExp;
		assignmentExp = createCompoundExpression([
			`${context.isTS ? `($event: any)` : `$event`} => ((`,
			exp,
			`) = $event)`
		]);
		const props$1 = [createObjectProperty(propName, dir.exp), createObjectProperty(eventName, assignmentExp)];
		if (dir.modifiers.length && node.tagType === 1) {
			const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
			const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, " + \"Modifiers\""]) : `modelModifiers`;
			props$1.push(createObjectProperty(modifiersKey, createSimpleExpression(`{ ${modifiers} }`, false, dir.loc, 2)));
		}
		return createTransformProps(props$1);
	};
	validDivisionCharRE = /[\w).+\-_$\]]/;
	transformFilter = (node, context) => {
		if (!isCompatEnabled("COMPILER_FILTERS", context)) return;
		if (node.type === 5) rewriteFilter(node.content, context);
		else if (node.type === 1) node.props.forEach((prop) => {
			if (prop.type === 7 && prop.name !== "for" && prop.exp) rewriteFilter(prop.exp, context);
		});
	};
	seen = /* @__PURE__ */ new WeakSet();
	transformMemo = (node, context) => {
		if (node.type === 1) {
			const dir = findDir(node, "memo");
			if (!dir || seen.has(node) || context.inSSR) return;
			seen.add(node);
			return () => {
				const codegenNode = node.codegenNode || context.currentNode.codegenNode;
				if (codegenNode && codegenNode.type === 13) {
					if (node.tagType !== 1) convertToBlock(codegenNode, context);
					node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [
						dir.exp,
						createFunctionExpression(void 0, codegenNode),
						`_cache`,
						String(context.cached.length)
					]);
					context.cached.push(null);
				}
			};
		}
	};
	transformVBindShorthand = (node, context) => {
		if (node.type === 1) {
			for (const prop of node.props) if (prop.type === 7 && prop.name === "bind" && (!prop.exp || prop.exp.type === 4 && !prop.exp.content.trim()) && prop.arg) {
				const arg = prop.arg;
				if (arg.type !== 4 || !arg.isStatic) {
					context.onError(createCompilerError(52, arg.loc));
					prop.exp = createSimpleExpression("", true, arg.loc);
				} else {
					const propName = camelize$1(arg.content);
					if (validFirstIdentCharRE.test(propName[0]) || propName[0] === "-") prop.exp = createSimpleExpression(propName, false, arg.loc);
				}
			}
		}
	};
	BindingTypes = {
		"DATA": "data",
		"PROPS": "props",
		"PROPS_ALIASED": "props-aliased",
		"SETUP_LET": "setup-let",
		"SETUP_CONST": "setup-const",
		"SETUP_REACTIVE_CONST": "setup-reactive-const",
		"SETUP_MAYBE_REF": "setup-maybe-ref",
		"SETUP_REF": "setup-ref",
		"OPTIONS": "options",
		"LITERAL_CONST": "literal-const"
	};
	noopDirectiveTransform = () => ({ props: [] });
}) });

//#endregion
//#region node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js
var compiler_dom_esm_bundler_exports = /* @__PURE__ */ __export$268({
	BASE_TRANSITION: () => BASE_TRANSITION,
	BindingTypes: () => BindingTypes,
	CAMELIZE: () => CAMELIZE,
	CAPITALIZE: () => CAPITALIZE,
	CREATE_BLOCK: () => CREATE_BLOCK,
	CREATE_COMMENT: () => CREATE_COMMENT,
	CREATE_ELEMENT_BLOCK: () => CREATE_ELEMENT_BLOCK,
	CREATE_ELEMENT_VNODE: () => CREATE_ELEMENT_VNODE,
	CREATE_SLOTS: () => CREATE_SLOTS,
	CREATE_STATIC: () => CREATE_STATIC,
	CREATE_TEXT: () => CREATE_TEXT,
	CREATE_VNODE: () => CREATE_VNODE,
	CompilerDeprecationTypes: () => CompilerDeprecationTypes,
	ConstantTypes: () => ConstantTypes,
	DOMDirectiveTransforms: () => DOMDirectiveTransforms,
	DOMErrorCodes: () => DOMErrorCodes,
	DOMErrorMessages: () => DOMErrorMessages,
	DOMNodeTransforms: () => DOMNodeTransforms,
	ElementTypes: () => ElementTypes,
	ErrorCodes: () => ErrorCodes,
	FRAGMENT: () => FRAGMENT,
	GUARD_REACTIVE_PROPS: () => GUARD_REACTIVE_PROPS,
	IS_MEMO_SAME: () => IS_MEMO_SAME,
	IS_REF: () => IS_REF,
	KEEP_ALIVE: () => KEEP_ALIVE,
	MERGE_PROPS: () => MERGE_PROPS,
	NORMALIZE_CLASS: () => NORMALIZE_CLASS,
	NORMALIZE_PROPS: () => NORMALIZE_PROPS,
	NORMALIZE_STYLE: () => NORMALIZE_STYLE,
	Namespaces: () => Namespaces,
	NodeTypes: () => NodeTypes,
	OPEN_BLOCK: () => OPEN_BLOCK,
	POP_SCOPE_ID: () => POP_SCOPE_ID,
	PUSH_SCOPE_ID: () => PUSH_SCOPE_ID,
	RENDER_LIST: () => RENDER_LIST,
	RENDER_SLOT: () => RENDER_SLOT,
	RESOLVE_COMPONENT: () => RESOLVE_COMPONENT,
	RESOLVE_DIRECTIVE: () => RESOLVE_DIRECTIVE,
	RESOLVE_DYNAMIC_COMPONENT: () => RESOLVE_DYNAMIC_COMPONENT,
	RESOLVE_FILTER: () => RESOLVE_FILTER,
	SET_BLOCK_TRACKING: () => SET_BLOCK_TRACKING,
	SUSPENSE: () => SUSPENSE,
	TELEPORT: () => TELEPORT,
	TO_DISPLAY_STRING: () => TO_DISPLAY_STRING,
	TO_HANDLERS: () => TO_HANDLERS,
	TO_HANDLER_KEY: () => TO_HANDLER_KEY,
	TRANSITION: () => TRANSITION,
	TRANSITION_GROUP: () => TRANSITION_GROUP,
	TS_NODE_TYPES: () => TS_NODE_TYPES,
	UNREF: () => UNREF,
	V_MODEL_CHECKBOX: () => V_MODEL_CHECKBOX,
	V_MODEL_DYNAMIC: () => V_MODEL_DYNAMIC,
	V_MODEL_RADIO: () => V_MODEL_RADIO,
	V_MODEL_SELECT: () => V_MODEL_SELECT,
	V_MODEL_TEXT: () => V_MODEL_TEXT,
	V_ON_WITH_KEYS: () => V_ON_WITH_KEYS,
	V_ON_WITH_MODIFIERS: () => V_ON_WITH_MODIFIERS,
	V_SHOW: () => V_SHOW,
	WITH_CTX: () => WITH_CTX,
	WITH_DIRECTIVES: () => WITH_DIRECTIVES,
	WITH_MEMO: () => WITH_MEMO,
	advancePositionWithClone: () => advancePositionWithClone,
	advancePositionWithMutation: () => advancePositionWithMutation,
	assert: () => assert,
	baseCompile: () => baseCompile,
	baseParse: () => baseParse,
	buildDirectiveArgs: () => buildDirectiveArgs,
	buildProps: () => buildProps,
	buildSlots: () => buildSlots,
	checkCompatEnabled: () => checkCompatEnabled,
	compile: () => compile,
	convertToBlock: () => convertToBlock,
	createArrayExpression: () => createArrayExpression,
	createAssignmentExpression: () => createAssignmentExpression,
	createBlockStatement: () => createBlockStatement,
	createCacheExpression: () => createCacheExpression,
	createCallExpression: () => createCallExpression,
	createCompilerError: () => createCompilerError,
	createCompoundExpression: () => createCompoundExpression,
	createConditionalExpression: () => createConditionalExpression,
	createDOMCompilerError: () => createDOMCompilerError,
	createForLoopParams: () => createForLoopParams,
	createFunctionExpression: () => createFunctionExpression,
	createIfStatement: () => createIfStatement,
	createInterpolation: () => createInterpolation,
	createObjectExpression: () => createObjectExpression,
	createObjectProperty: () => createObjectProperty,
	createReturnStatement: () => createReturnStatement,
	createRoot: () => createRoot,
	createSequenceExpression: () => createSequenceExpression,
	createSimpleExpression: () => createSimpleExpression,
	createStructuralDirectiveTransform: () => createStructuralDirectiveTransform,
	createTemplateLiteral: () => createTemplateLiteral,
	createTransformContext: () => createTransformContext,
	createVNodeCall: () => createVNodeCall,
	errorMessages: () => errorMessages,
	extractIdentifiers: () => extractIdentifiers,
	findDir: () => findDir,
	findProp: () => findProp,
	forAliasRE: () => forAliasRE,
	generate: () => generate,
	generateCodeFrame: () => generateCodeFrame,
	getBaseTransformPreset: () => getBaseTransformPreset,
	getConstantType: () => getConstantType,
	getMemoedVNodeCall: () => getMemoedVNodeCall,
	getVNodeBlockHelper: () => getVNodeBlockHelper,
	getVNodeHelper: () => getVNodeHelper,
	hasDynamicKeyVBind: () => hasDynamicKeyVBind,
	hasScopeRef: () => hasScopeRef,
	helperNameMap: () => helperNameMap,
	injectProp: () => injectProp,
	isAllWhitespace: () => isAllWhitespace,
	isCommentOrWhitespace: () => isCommentOrWhitespace,
	isCoreComponent: () => isCoreComponent,
	isFnExpression: () => isFnExpression,
	isFnExpressionBrowser: () => isFnExpressionBrowser,
	isFnExpressionNode: () => isFnExpressionNode,
	isFunctionType: () => isFunctionType,
	isInDestructureAssignment: () => isInDestructureAssignment,
	isInNewExpression: () => isInNewExpression,
	isMemberExpression: () => isMemberExpression,
	isMemberExpressionBrowser: () => isMemberExpressionBrowser,
	isMemberExpressionNode: () => isMemberExpressionNode,
	isReferencedIdentifier: () => isReferencedIdentifier,
	isSimpleIdentifier: () => isSimpleIdentifier,
	isSlotOutlet: () => isSlotOutlet,
	isStaticArgOf: () => isStaticArgOf,
	isStaticExp: () => isStaticExp,
	isStaticProperty: () => isStaticProperty,
	isStaticPropertyKey: () => isStaticPropertyKey,
	isTemplateNode: () => isTemplateNode,
	isText: () => isText$1,
	isVPre: () => isVPre,
	isVSlot: () => isVSlot,
	isWhitespaceText: () => isWhitespaceText,
	locStub: () => locStub,
	noopDirectiveTransform: () => noopDirectiveTransform,
	parse: () => parse,
	parserOptions: () => parserOptions,
	processExpression: () => processExpression,
	processFor: () => processFor,
	processIf: () => processIf,
	processSlotOutlet: () => processSlotOutlet,
	registerRuntimeHelpers: () => registerRuntimeHelpers,
	resolveComponentType: () => resolveComponentType,
	stringifyExpression: () => stringifyExpression,
	toValidAssetId: () => toValidAssetId,
	trackSlotScopes: () => trackSlotScopes,
	trackVForSlotScopes: () => trackVForSlotScopes,
	transform: () => transform,
	transformBind: () => transformBind,
	transformElement: () => transformElement,
	transformExpression: () => transformExpression,
	transformModel: () => transformModel,
	transformOn: () => transformOn,
	transformStyle: () => transformStyle,
	transformVBindShorthand: () => transformVBindShorthand,
	traverseNode: () => traverseNode,
	unwrapTSNode: () => unwrapTSNode,
	validFirstIdentCharRE: () => validFirstIdentCharRE,
	walkBlockDeclarations: () => walkBlockDeclarations,
	walkFunctionParams: () => walkFunctionParams,
	walkIdentifiers: () => walkIdentifiers,
	warnDeprecation: () => warnDeprecation
});
function decodeHtmlBrowser(raw, asAttr = false) {
	if (!decoder) decoder = document.createElement("div");
	if (asAttr) {
		decoder.innerHTML = `<div foo="${raw.replace(/"/g, "&quot;")}">`;
		return decoder.children[0].getAttribute("foo");
	} else {
		decoder.innerHTML = raw;
		return decoder.textContent;
	}
}
function createDOMCompilerError(code, loc) {
	return createCompilerError(code, loc, DOMErrorMessages);
}
function hasMultipleChildren(node) {
	const children = node.children = node.children.filter((c) => !isCommentOrWhitespace(c));
	const child = children[0];
	return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
}
function isValidHTMLNesting(parent, child) {
	if (parent === "template") return true;
	if (parent in onlyValidChildren) return onlyValidChildren[parent].has(child);
	if (child in onlyValidParents) return onlyValidParents[child].has(parent);
	if (parent in knownInvalidChildren) {
		if (knownInvalidChildren[parent].has(child)) return false;
	}
	if (child in knownInvalidParents) {
		if (knownInvalidParents[child].has(parent)) return false;
	}
	return true;
}
function compile(src, options = {}) {
	return baseCompile(src, extend({}, parserOptions, options, {
		nodeTransforms: [
			ignoreSideEffectTags,
			...DOMNodeTransforms,
			...options.nodeTransforms || []
		],
		directiveTransforms: extend({}, DOMDirectiveTransforms, options.directiveTransforms || {}),
		transformHoist: null
	}));
}
function parse(template, options = {}) {
	return baseParse(template, extend({}, parserOptions, options));
}
var V_MODEL_RADIO, V_MODEL_CHECKBOX, V_MODEL_TEXT, V_MODEL_SELECT, V_MODEL_DYNAMIC, V_ON_WITH_MODIFIERS, V_ON_WITH_KEYS, V_SHOW, TRANSITION, TRANSITION_GROUP, decoder, parserOptions, transformStyle, parseInlineCSS, DOMErrorCodes, DOMErrorMessages, transformVHtml, transformVText, transformModel$1, isEventOptionModifier, isNonKeyModifier, maybeKeyModifier, isKeyboardEvent, resolveModifiers, transformClick, transformOn$1, transformShow, transformTransition, ignoreSideEffectTags, headings, emptySet, onlyValidChildren, onlyValidParents, knownInvalidChildren, knownInvalidParents, validateHtmlNesting, DOMNodeTransforms, DOMDirectiveTransforms;
var init_compiler_dom_esm_bundler = __esm({ "node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js": (() => {
	init_compiler_core_esm_bundler();
	init_compiler_core_esm_bundler();
	init_shared_esm_bundler();
	V_MODEL_RADIO = Symbol(`vModelRadio`);
	V_MODEL_CHECKBOX = Symbol(`vModelCheckbox`);
	V_MODEL_TEXT = Symbol(`vModelText`);
	V_MODEL_SELECT = Symbol(`vModelSelect`);
	V_MODEL_DYNAMIC = Symbol(`vModelDynamic`);
	V_ON_WITH_MODIFIERS = Symbol(`vOnModifiersGuard`);
	V_ON_WITH_KEYS = Symbol(`vOnKeysGuard`);
	V_SHOW = Symbol(`vShow`);
	TRANSITION = Symbol(`Transition`);
	TRANSITION_GROUP = Symbol(`TransitionGroup`);
	registerRuntimeHelpers({
		[V_MODEL_RADIO]: `vModelRadio`,
		[V_MODEL_CHECKBOX]: `vModelCheckbox`,
		[V_MODEL_TEXT]: `vModelText`,
		[V_MODEL_SELECT]: `vModelSelect`,
		[V_MODEL_DYNAMIC]: `vModelDynamic`,
		[V_ON_WITH_MODIFIERS]: `withModifiers`,
		[V_ON_WITH_KEYS]: `withKeys`,
		[V_SHOW]: `vShow`,
		[TRANSITION]: `Transition`,
		[TRANSITION_GROUP]: `TransitionGroup`
	});
	;
	parserOptions = {
		parseMode: "html",
		isVoidTag,
		isNativeTag: (tag) => isHTMLTag(tag) || isSVGTag(tag) || isMathMLTag(tag),
		isPreTag: (tag) => tag === "pre",
		isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
		decodeEntities: decodeHtmlBrowser,
		isBuiltInComponent: (tag) => {
			if (tag === "Transition" || tag === "transition") return TRANSITION;
			else if (tag === "TransitionGroup" || tag === "transition-group") return TRANSITION_GROUP;
		},
		getNamespace(tag, parent, rootNamespace) {
			let ns = parent ? parent.ns : rootNamespace;
			if (parent && ns === 2) {
				if (parent.tag === "annotation-xml") {
					if (tag === "svg") return 1;
					if (parent.props.some((a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml"))) ns = 0;
				} else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") ns = 0;
			} else if (parent && ns === 1) {
				if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") ns = 0;
			}
			if (ns === 0) {
				if (tag === "svg") return 1;
				if (tag === "math") return 2;
			}
			return ns;
		}
	};
	transformStyle = (node) => {
		if (node.type === 1) node.props.forEach((p, i) => {
			if (p.type === 6 && p.name === "style" && p.value) node.props[i] = {
				type: 7,
				name: `bind`,
				arg: createSimpleExpression(`style`, true, p.loc),
				exp: parseInlineCSS(p.value.content, p.loc),
				modifiers: [],
				loc: p.loc
			};
		});
	};
	parseInlineCSS = (cssText, loc) => {
		const normalized = parseStringStyle(cssText);
		return createSimpleExpression(JSON.stringify(normalized), false, loc, 3);
	};
	DOMErrorCodes = {
		"X_V_HTML_NO_EXPRESSION": 53,
		"53": "X_V_HTML_NO_EXPRESSION",
		"X_V_HTML_WITH_CHILDREN": 54,
		"54": "X_V_HTML_WITH_CHILDREN",
		"X_V_TEXT_NO_EXPRESSION": 55,
		"55": "X_V_TEXT_NO_EXPRESSION",
		"X_V_TEXT_WITH_CHILDREN": 56,
		"56": "X_V_TEXT_WITH_CHILDREN",
		"X_V_MODEL_ON_INVALID_ELEMENT": 57,
		"57": "X_V_MODEL_ON_INVALID_ELEMENT",
		"X_V_MODEL_ARG_ON_ELEMENT": 58,
		"58": "X_V_MODEL_ARG_ON_ELEMENT",
		"X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
		"59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
		"X_V_MODEL_UNNECESSARY_VALUE": 60,
		"60": "X_V_MODEL_UNNECESSARY_VALUE",
		"X_V_SHOW_NO_EXPRESSION": 61,
		"61": "X_V_SHOW_NO_EXPRESSION",
		"X_TRANSITION_INVALID_CHILDREN": 62,
		"62": "X_TRANSITION_INVALID_CHILDREN",
		"X_IGNORED_SIDE_EFFECT_TAG": 63,
		"63": "X_IGNORED_SIDE_EFFECT_TAG",
		"__EXTEND_POINT__": 64,
		"64": "__EXTEND_POINT__"
	};
	DOMErrorMessages = {
		[53]: `v-html is missing expression.`,
		[54]: `v-html will override element children.`,
		[55]: `v-text is missing expression.`,
		[56]: `v-text will override element children.`,
		[57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
		[58]: `v-model argument is not supported on plain elements.`,
		[59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
		[60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
		[61]: `v-show is missing expression.`,
		[62]: `<Transition> expects exactly one child element or component.`,
		[63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
	};
	transformVHtml = (dir, node, context) => {
		const { exp, loc } = dir;
		if (!exp) context.onError(createDOMCompilerError(53, loc));
		if (node.children.length) {
			context.onError(createDOMCompilerError(54, loc));
			node.children.length = 0;
		}
		return { props: [createObjectProperty(createSimpleExpression(`innerHTML`, true, loc), exp || createSimpleExpression("", true))] };
	};
	transformVText = (dir, node, context) => {
		const { exp, loc } = dir;
		if (!exp) context.onError(createDOMCompilerError(55, loc));
		if (node.children.length) {
			context.onError(createDOMCompilerError(56, loc));
			node.children.length = 0;
		}
		return { props: [createObjectProperty(createSimpleExpression(`textContent`, true), exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(context.helperString(TO_DISPLAY_STRING), [exp], loc) : createSimpleExpression("", true))] };
	};
	transformModel$1 = (dir, node, context) => {
		const baseResult = transformModel(dir, node, context);
		if (!baseResult.props.length || node.tagType === 1) return baseResult;
		if (dir.arg) context.onError(createDOMCompilerError(58, dir.arg.loc));
		function checkDuplicatedValue() {
			const value = findDir(node, "bind");
			if (value && isStaticArgOf(value.arg, "value")) context.onError(createDOMCompilerError(60, value.loc));
		}
		const { tag } = node;
		const isCustomElement = context.isCustomElement(tag);
		if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
			let directiveToUse = V_MODEL_TEXT;
			let isInvalidType = false;
			if (tag === "input" || isCustomElement) {
				const type = findProp(node, `type`);
				if (type) {
					if (type.type === 7) directiveToUse = V_MODEL_DYNAMIC;
					else if (type.value) switch (type.value.content) {
						case "radio":
							directiveToUse = V_MODEL_RADIO;
							break;
						case "checkbox":
							directiveToUse = V_MODEL_CHECKBOX;
							break;
						case "file":
							isInvalidType = true;
							context.onError(createDOMCompilerError(59, dir.loc));
							break;
						default:
							checkDuplicatedValue();
							break;
					}
				} else if (hasDynamicKeyVBind(node)) directiveToUse = V_MODEL_DYNAMIC;
				else checkDuplicatedValue();
			} else if (tag === "select") directiveToUse = V_MODEL_SELECT;
			else checkDuplicatedValue();
			if (!isInvalidType) baseResult.needRuntime = context.helper(directiveToUse);
		} else context.onError(createDOMCompilerError(57, dir.loc));
		baseResult.props = baseResult.props.filter((p) => !(p.key.type === 4 && p.key.content === "modelValue"));
		return baseResult;
	};
	isEventOptionModifier = /* @__PURE__ */ makeMap(`passive,once,capture`);
	isNonKeyModifier = /* @__PURE__ */ makeMap(`stop,prevent,self,ctrl,shift,alt,meta,exact,middle`);
	maybeKeyModifier = /* @__PURE__ */ makeMap("left,right");
	isKeyboardEvent = /* @__PURE__ */ makeMap(`onkeyup,onkeydown,onkeypress`);
	resolveModifiers = (key, modifiers, context, loc) => {
		const keyModifiers = [];
		const nonKeyModifiers = [];
		const eventOptionModifiers = [];
		for (let i = 0; i < modifiers.length; i++) {
			const modifier = modifiers[i].content;
			if (modifier === "native" && checkCompatEnabled("COMPILER_V_ON_NATIVE", context, loc)) eventOptionModifiers.push(modifier);
			else if (isEventOptionModifier(modifier)) eventOptionModifiers.push(modifier);
			else if (maybeKeyModifier(modifier)) if (isStaticExp(key)) if (isKeyboardEvent(key.content.toLowerCase())) keyModifiers.push(modifier);
			else nonKeyModifiers.push(modifier);
			else {
				keyModifiers.push(modifier);
				nonKeyModifiers.push(modifier);
			}
			else if (isNonKeyModifier(modifier)) nonKeyModifiers.push(modifier);
			else keyModifiers.push(modifier);
		}
		return {
			keyModifiers,
			nonKeyModifiers,
			eventOptionModifiers
		};
	};
	transformClick = (key, event) => {
		return isStaticExp(key) && key.content.toLowerCase() === "onclick" ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([
			`(`,
			key,
			`) === "onClick" ? "${event}" : (`,
			key,
			`)`
		]) : key;
	};
	transformOn$1 = (dir, node, context) => {
		return transformOn(dir, node, context, (baseResult) => {
			const { modifiers } = dir;
			if (!modifiers.length) return baseResult;
			let { key, value: handlerExp } = baseResult.props[0];
			const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
			if (nonKeyModifiers.includes("right")) key = transformClick(key, `onContextmenu`);
			if (nonKeyModifiers.includes("middle")) key = transformClick(key, `onMouseup`);
			if (nonKeyModifiers.length) handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [handlerExp, JSON.stringify(nonKeyModifiers)]);
			if (keyModifiers.length && (!isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [handlerExp, JSON.stringify(keyModifiers)]);
			if (eventOptionModifiers.length) {
				const modifierPostfix = eventOptionModifiers.map(capitalize).join("");
				key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([
					`(`,
					key,
					`) + "${modifierPostfix}"`
				]);
			}
			return { props: [createObjectProperty(key, handlerExp)] };
		});
	};
	transformShow = (dir, node, context) => {
		const { exp, loc } = dir;
		if (!exp) context.onError(createDOMCompilerError(61, loc));
		return {
			props: [],
			needRuntime: context.helper(V_SHOW)
		};
	};
	transformTransition = (node, context) => {
		if (node.type === 1 && node.tagType === 1) {
			if (context.isBuiltInComponent(node.tag) === TRANSITION) return () => {
				if (!node.children.length) return;
				if (hasMultipleChildren(node)) context.onError(createDOMCompilerError(62, {
					start: node.children[0].loc.start,
					end: node.children[node.children.length - 1].loc.end,
					source: ""
				}));
				const child = node.children[0];
				if (child.type === 1) {
					for (const p of child.props) if (p.type === 7 && p.name === "show") node.props.push({
						type: 6,
						name: "persisted",
						nameLoc: node.loc,
						value: void 0,
						loc: node.loc
					});
				}
			};
		}
	};
	ignoreSideEffectTags = (node, context) => {
		if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
			context.onError(createDOMCompilerError(63, node.loc));
			context.removeNode();
		}
	};
	headings = /* @__PURE__ */ new Set([
		"h1",
		"h2",
		"h3",
		"h4",
		"h5",
		"h6"
	]);
	emptySet = /* @__PURE__ */ new Set([]);
	onlyValidChildren = {
		head: /* @__PURE__ */ new Set([
			"base",
			"basefront",
			"bgsound",
			"link",
			"meta",
			"title",
			"noscript",
			"noframes",
			"style",
			"script",
			"template"
		]),
		optgroup: /* @__PURE__ */ new Set(["option"]),
		select: /* @__PURE__ */ new Set([
			"optgroup",
			"option",
			"hr"
		]),
		table: /* @__PURE__ */ new Set([
			"caption",
			"colgroup",
			"tbody",
			"tfoot",
			"thead"
		]),
		tr: /* @__PURE__ */ new Set(["td", "th"]),
		colgroup: /* @__PURE__ */ new Set(["col"]),
		tbody: /* @__PURE__ */ new Set(["tr"]),
		thead: /* @__PURE__ */ new Set(["tr"]),
		tfoot: /* @__PURE__ */ new Set(["tr"]),
		script: emptySet,
		iframe: emptySet,
		option: emptySet,
		textarea: emptySet,
		style: emptySet,
		title: emptySet
	};
	onlyValidParents = {
		html: emptySet,
		body: /* @__PURE__ */ new Set(["html"]),
		head: /* @__PURE__ */ new Set(["html"]),
		td: /* @__PURE__ */ new Set(["tr"]),
		colgroup: /* @__PURE__ */ new Set(["table"]),
		caption: /* @__PURE__ */ new Set(["table"]),
		tbody: /* @__PURE__ */ new Set(["table"]),
		tfoot: /* @__PURE__ */ new Set(["table"]),
		col: /* @__PURE__ */ new Set(["colgroup"]),
		th: /* @__PURE__ */ new Set(["tr"]),
		thead: /* @__PURE__ */ new Set(["table"]),
		tr: /* @__PURE__ */ new Set([
			"tbody",
			"thead",
			"tfoot"
		]),
		dd: /* @__PURE__ */ new Set(["dl", "div"]),
		dt: /* @__PURE__ */ new Set(["dl", "div"]),
		figcaption: /* @__PURE__ */ new Set(["figure"]),
		summary: /* @__PURE__ */ new Set(["details"]),
		area: /* @__PURE__ */ new Set(["map"])
	};
	knownInvalidChildren = {
		p: /* @__PURE__ */ new Set([
			"address",
			"article",
			"aside",
			"blockquote",
			"center",
			"details",
			"dialog",
			"dir",
			"div",
			"dl",
			"fieldset",
			"figure",
			"footer",
			"form",
			"h1",
			"h2",
			"h3",
			"h4",
			"h5",
			"h6",
			"header",
			"hgroup",
			"hr",
			"li",
			"main",
			"nav",
			"menu",
			"ol",
			"p",
			"pre",
			"section",
			"table",
			"ul"
		]),
		svg: /* @__PURE__ */ new Set([
			"b",
			"blockquote",
			"br",
			"code",
			"dd",
			"div",
			"dl",
			"dt",
			"em",
			"embed",
			"h1",
			"h2",
			"h3",
			"h4",
			"h5",
			"h6",
			"hr",
			"i",
			"img",
			"li",
			"menu",
			"meta",
			"ol",
			"p",
			"pre",
			"ruby",
			"s",
			"small",
			"span",
			"strong",
			"sub",
			"sup",
			"table",
			"u",
			"ul",
			"var"
		])
	};
	knownInvalidParents = {
		a: /* @__PURE__ */ new Set(["a"]),
		button: /* @__PURE__ */ new Set(["button"]),
		dd: /* @__PURE__ */ new Set(["dd", "dt"]),
		dt: /* @__PURE__ */ new Set(["dd", "dt"]),
		form: /* @__PURE__ */ new Set(["form"]),
		li: /* @__PURE__ */ new Set(["li"]),
		h1: headings,
		h2: headings,
		h3: headings,
		h4: headings,
		h5: headings,
		h6: headings
	};
	validateHtmlNesting = (node, context) => {
		if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {
			const error = /* @__PURE__ */ new SyntaxError(`<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`);
			error.loc = node.loc;
			context.onWarn(error);
		}
	};
	DOMNodeTransforms = [transformStyle, ...[transformTransition, validateHtmlNesting]];
	DOMDirectiveTransforms = {
		cloak: noopDirectiveTransform,
		html: transformVHtml,
		text: transformVText,
		model: transformModel$1,
		on: transformOn$1,
		show: transformShow
	};
}) });

//#endregion
//#region node_modules/vue/dist/vue.cjs.js
/**
* vue v3.5.25
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
var require_vue_cjs = /* @__PURE__ */ __commonJS({ "node_modules/vue/dist/vue.cjs.js": ((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	var compilerDom = (init_compiler_dom_esm_bundler(), __toCommonJS$269(compiler_dom_esm_bundler_exports));
	var runtimeDom = (init_runtime_dom_esm_bundler(), __toCommonJS$269(runtime_dom_esm_bundler_exports));
	var shared = (init_shared_esm_bundler(), __toCommonJS$269(shared_esm_bundler_exports));
	function _interopNamespaceDefault(e) {
		var n = Object.create(null);
		if (e) for (var k in e) n[k] = e[k];
		n.default = e;
		return Object.freeze(n);
	}
	var runtimeDom__namespace = /* @__PURE__ */ _interopNamespaceDefault(runtimeDom);
	var compileCache = /* @__PURE__ */ Object.create(null);
	function compileToFunction(template, options) {
		if (!shared.isString(template)) if (template.nodeType) template = template.innerHTML;
		else {
			runtimeDom.warn(`invalid template option: `, template);
			return shared.NOOP;
		}
		const key = shared.genCacheKey(template, options);
		const cached = compileCache[key];
		if (cached) return cached;
		if (template[0] === "#") {
			const el = document.querySelector(template);
			if (!el) runtimeDom.warn(`Template element not found or is empty: ${template}`);
			template = el ? el.innerHTML : ``;
		}
		const opts = shared.extend({
			hoistStatic: true,
			onError,
			onWarn: (e) => onError(e, true)
		}, options);
		if (!opts.isCustomElement && typeof customElements !== "undefined") opts.isCustomElement = (tag) => !!customElements.get(tag);
		const { code } = compilerDom.compile(template, opts);
		function onError(err, asWarning = false) {
			const message = asWarning ? err.message : `Template compilation error: ${err.message}`;
			const codeFrame = err.loc && shared.generateCodeFrame(template, err.loc.start.offset, err.loc.end.offset);
			runtimeDom.warn(codeFrame ? `${message}
${codeFrame}` : message);
		}
		const render = new Function("Vue", code)(runtimeDom__namespace);
		render._rc = true;
		return compileCache[key] = render;
	}
	runtimeDom.registerRuntimeCompiler(compileToFunction);
	exports.compile = compileToFunction;
	Object.keys(runtimeDom).forEach(function(k) {
		if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeDom[k];
	});
}) });

//#endregion
//#region node_modules/vue/index.js
var require_vue = /* @__PURE__ */ __commonJS({ "node_modules/vue/index.js": ((exports, module) => {
	module.exports = require_vue_cjs();
}) });

//#endregion
//#region node_modules/@vant/use/dist/index.cjs.js
var require_index_cjs$1 = /* @__PURE__ */ __commonJS({ "node_modules/@vant/use/dist/index.cjs.js": ((exports, module) => {
	var __defProp$266 = Object.defineProperty;
	var __getOwnPropDesc$266 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$266 = Object.getOwnPropertyNames;
	var __hasOwnProp$266 = Object.prototype.hasOwnProperty;
	var __export$265 = (target, all) => {
		for (var name$111 in all) __defProp$266(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$266 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$266(from)) if (!__hasOwnProp$266.call(to, key) && key !== except) __defProp$266(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$266(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$266 = (mod) => __copyProps$266(__defProp$266({}, "__esModule", { value: true }), mod);
	var src_exports$1 = {};
	__export$265(src_exports$1, {
		CUSTOM_FIELD_INJECTION_KEY: () => CUSTOM_FIELD_INJECTION_KEY,
		cancelRaf: () => cancelRaf,
		doubleRaf: () => doubleRaf,
		flattenVNodes: () => flattenVNodes,
		getScrollParent: () => getScrollParent$1,
		inBrowser: () => inBrowser,
		onMountedOrActivated: () => onMountedOrActivated,
		raf: () => raf,
		sortChildren: () => sortChildren,
		supportsPassive: () => supportsPassive,
		useChildren: () => useChildren,
		useClickAway: () => useClickAway,
		useCountDown: () => useCountDown,
		useCustomFieldValue: () => useCustomFieldValue,
		useEventListener: () => useEventListener,
		usePageVisibility: () => usePageVisibility,
		useParent: () => useParent,
		useRaf: () => useRaf,
		useRect: () => useRect,
		useScrollParent: () => useScrollParent,
		useToggle: () => useToggle,
		useWindowSize: () => useWindowSize
	});
	module.exports = __toCommonJS$266(src_exports$1);
	var inBrowser = typeof window !== "undefined";
	var supportsPassive = true;
	function raf(fn) {
		return inBrowser ? requestAnimationFrame(fn) : -1;
	}
	function cancelRaf(id) {
		if (inBrowser) cancelAnimationFrame(id);
	}
	function doubleRaf(fn) {
		raf(() => raf(fn));
	}
	var import_vue$138 = require_vue();
	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 = (0, import_vue$138.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);
	};
	var import_vue2 = require_vue();
	function useToggle(defaultValue = false) {
		const state = (0, import_vue2.ref)(defaultValue);
		const toggle = (value = !state.value) => {
			state.value = value;
		};
		return [state, toggle];
	}
	var import_vue3 = require_vue();
	function useParent(key) {
		const parent = (0, import_vue3.inject)(key, null);
		if (parent) {
			const instance$3 = (0, import_vue3.getCurrentInstance)();
			const { link, unlink, internalChildren } = parent;
			link(instance$3);
			(0, import_vue3.onUnmounted)(() => unlink(instance$3));
			return {
				parent,
				index: (0, import_vue3.computed)(() => internalChildren.indexOf(instance$3))
			};
		}
		return {
			parent: null,
			index: (0, import_vue3.ref)(-1)
		};
	}
	var import_vue4 = require_vue();
	function flattenVNodes(children) {
		const result = [];
		const traverse = (children2) => {
			if (Array.isArray(children2)) children2.forEach((child) => {
				var _a;
				if ((0, import_vue4.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 = (0, import_vue4.reactive)([]);
		const internalChildren = (0, import_vue4.reactive)([]);
		const parent = (0, import_vue4.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);
			};
			(0, import_vue4.provide)(key, Object.assign({
				link,
				unlink,
				children: publicChildren,
				internalChildren
			}, value));
		};
		return {
			children: publicChildren,
			linkChildren
		};
	}
	var import_vue5 = require_vue();
	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 = (0, import_vue5.ref)(options.time);
		const current$1 = (0, import_vue5.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$1 = (totalTime = options.time) => {
			pause();
			remain.value = totalTime;
		};
		(0, import_vue5.onBeforeUnmount)(pause);
		(0, import_vue5.onActivated)(() => {
			if (deactivated) {
				counting = true;
				deactivated = false;
				tick();
			}
		});
		(0, import_vue5.onDeactivated)(() => {
			if (counting) {
				pause();
				deactivated = true;
			}
		});
		return {
			start: start$1,
			pause,
			reset: reset$1,
			current: current$1
		};
	}
	var import_vue8 = require_vue();
	var import_vue7 = require_vue();
	var import_vue6 = require_vue();
	function onMountedOrActivated(hook) {
		let mounted;
		(0, import_vue6.onMounted)(() => {
			hook();
			(0, import_vue6.nextTick)(() => {
				mounted = true;
			});
		});
		(0, import_vue6.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 = (0, import_vue7.unref)(target2);
			if (element && !attached) {
				element.addEventListener(type, listener, {
					capture,
					passive: passive$1
				});
				attached = true;
			}
		};
		const remove$1 = (target2) => {
			if (cleaned) return;
			const element = (0, import_vue7.unref)(target2);
			if (element && attached) {
				element.removeEventListener(type, listener, capture);
				attached = false;
			}
		};
		(0, import_vue7.onUnmounted)(() => remove$1(target));
		(0, import_vue7.onDeactivated)(() => remove$1(target));
		onMountedOrActivated(() => add(target));
		let stopWatch;
		if ((0, import_vue7.isRef)(target)) stopWatch = (0, import_vue7.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 = (0, import_vue8.unref)(item);
				return element && !element.contains(event.target);
			})) listener(event);
		};
		useEventListener(eventName, onClick, { target: document });
	}
	var import_vue9 = require_vue();
	var width;
	var height;
	function useWindowSize() {
		if (!width) {
			width = (0, import_vue9.ref)(0);
			height = (0, import_vue9.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 import_vue10 = require_vue();
	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$1(el, root = defaultRoot) {
		let node = el;
		while (node && node !== root && isElement$1(node)) {
			const { overflowY } = window.getComputedStyle(node);
			if (overflowScrollReg.test(overflowY)) return node;
			node = node.parentNode;
		}
		return root;
	}
	function useScrollParent(el, root = defaultRoot) {
		const scrollParent = (0, import_vue10.ref)();
		(0, import_vue10.onMounted)(() => {
			if (el.value) scrollParent.value = getScrollParent$1(el.value, root);
		});
		return scrollParent;
	}
	var import_vue11 = require_vue();
	var visibility;
	function usePageVisibility() {
		if (!visibility) {
			visibility = (0, import_vue11.ref)("visible");
			if (inBrowser) {
				const update = () => {
					visibility.value = document.hidden ? "hidden" : "visible";
				};
				update();
				window.addEventListener("visibilitychange", update);
			}
		}
		return visibility;
	}
	var import_vue12 = require_vue();
	var CUSTOM_FIELD_INJECTION_KEY = Symbol("van-field");
	function useCustomFieldValue(customValue) {
		const field = (0, import_vue12.inject)(CUSTOM_FIELD_INJECTION_KEY, null);
		if (field && !field.customValue.value) {
			field.customValue.value = customValue;
			(0, import_vue12.watch)(customValue, () => {
				field.resetValidation();
				field.validateWithTrigger("onChange");
			});
		}
	}
	function useRaf(fn, options) {
		if (inBrowser) {
			const { interval = 0, isLoop = false } = options || {};
			let start$1;
			let isStopped = false;
			let rafId;
			const stop = () => {
				isStopped = true;
				cancelAnimationFrame(rafId);
			};
			const frameWrapper = (timestamp) => {
				if (isStopped) return;
				if (start$1 === void 0) start$1 = timestamp;
				else if (timestamp - start$1 > interval) {
					fn(timestamp);
					start$1 = timestamp;
					if (!isLoop) {
						stop();
						return;
					}
				}
				rafId = requestAnimationFrame(frameWrapper);
			};
			rafId = requestAnimationFrame(frameWrapper);
			return stop;
		}
		return () => {};
	}
}) });

//#endregion
//#region node_modules/vant/lib/utils/dom.js
var require_dom = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/dom.js": ((exports, module) => {
	var __defProp$265 = Object.defineProperty;
	var __getOwnPropDesc$265 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$265 = Object.getOwnPropertyNames;
	var __hasOwnProp$265 = Object.prototype.hasOwnProperty;
	var __export$264 = (target, all) => {
		for (var name$111 in all) __defProp$265(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$265 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$265(from)) if (!__hasOwnProp$265.call(to, key) && key !== except) __defProp$265(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$265(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$265 = (mod) => __copyProps$265(__defProp$265({}, "__esModule", { value: true }), mod);
	var stdin_exports$264 = {};
	__export$264(stdin_exports$264, {
		getContainingBlock: () => getContainingBlock$1,
		getElementTop: () => getElementTop,
		getRootScrollTop: () => getRootScrollTop,
		getScrollTop: () => getScrollTop,
		isHidden: () => isHidden,
		preventDefault: () => preventDefault,
		resetScroll: () => resetScroll,
		setRootScrollTop: () => setRootScrollTop,
		setScrollTop: () => setScrollTop,
		stopPropagation: () => stopPropagation,
		windowHeight: () => windowHeight,
		windowWidth: () => windowWidth
	});
	module.exports = __toCommonJS$265(stdin_exports$264);
	var import_use$67 = require_index_cjs$1();
	var import_vue$137 = require_vue();
	var import_basic$5 = require_basic();
	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 (0, import_use$67.useRect)(el).top + scrollTop;
	}
	var isIOS = (0, import_basic$5.isIOS)();
	function resetScroll() {
		if (isIOS) 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 = (0, import_vue$137.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 } = (0, import_use$67.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/lib/utils/format.js
var require_format = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/format.js": ((exports, module) => {
	var __defProp$264 = Object.defineProperty;
	var __getOwnPropDesc$264 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$264 = Object.getOwnPropertyNames;
	var __hasOwnProp$264 = Object.prototype.hasOwnProperty;
	var __export$263 = (target, all) => {
		for (var name$111 in all) __defProp$264(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$264 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$264(from)) if (!__hasOwnProp$264.call(to, key) && key !== except) __defProp$264(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$264(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$264 = (mod) => __copyProps$264(__defProp$264({}, "__esModule", { value: true }), mod);
	var stdin_exports$263 = {};
	__export$263(stdin_exports$263, {
		addNumber: () => addNumber,
		addUnit: () => addUnit,
		camelize: () => camelize,
		clamp: () => clamp,
		formatNumber: () => formatNumber,
		getSizeStyle: () => getSizeStyle,
		getZIndexStyle: () => getZIndexStyle,
		kebabCase: () => kebabCase,
		padZero: () => padZero,
		unitToPx: () => unitToPx
	});
	module.exports = __toCommonJS$264(stdin_exports$263);
	var import_basic$4 = require_basic();
	var import_dom$1 = require_dom();
	var import_basic2 = require_basic();
	function addUnit(value) {
		if ((0, import_basic2.isDef)(value)) return (0, import_basic2.isNumeric)(value) ? `${value}px` : String(value);
	}
	function getSizeStyle(originSize) {
		if ((0, import_basic2.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 * import_dom$1.windowWidth.value / 100;
	}
	function convertVh(value) {
		value = value.replace(/vh/g, "");
		return +value * import_dom$1.windowHeight.value / 100;
	}
	function unitToPx(value) {
		if (typeof value === "number") return value;
		if (import_basic$4.inBrowser) {
			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/lib/utils/deep-assign.js
var require_deep_assign = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/deep-assign.js": ((exports, module) => {
	var __defProp$263 = Object.defineProperty;
	var __getOwnPropDesc$263 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$263 = Object.getOwnPropertyNames;
	var __hasOwnProp$263 = Object.prototype.hasOwnProperty;
	var __export$262 = (target, all) => {
		for (var name$111 in all) __defProp$263(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$263 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$263(from)) if (!__hasOwnProp$263.call(to, key) && key !== except) __defProp$263(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$263(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$263 = (mod) => __copyProps$263(__defProp$263({}, "__esModule", { value: true }), mod);
	var stdin_exports$262 = {};
	__export$262(stdin_exports$262, { deepAssign: () => deepAssign });
	module.exports = __toCommonJS$263(stdin_exports$262);
	var import_basic$3 = require_basic();
	var { hasOwnProperty } = Object.prototype;
	function assignKey(to, from, key) {
		const val = from[key];
		if (!(0, import_basic$3.isDef)(val)) return;
		if (!hasOwnProperty.call(to, key) || !(0, import_basic$3.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/lib/locale/lang/zh-CN.js
var require_zh_CN = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/locale/lang/zh-CN.js": ((exports, module) => {
	var __defProp$262 = Object.defineProperty;
	var __getOwnPropDesc$262 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$262 = Object.getOwnPropertyNames;
	var __hasOwnProp$262 = Object.prototype.hasOwnProperty;
	var __export$261 = (target, all) => {
		for (var name$111 in all) __defProp$262(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$262 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$262(from)) if (!__hasOwnProp$262.call(to, key) && key !== except) __defProp$262(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$262(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$262 = (mod) => __copyProps$262(__defProp$262({}, "__esModule", { value: true }), mod);
	var stdin_exports$261 = {};
	__export$261(stdin_exports$261, { default: () => stdin_default$219 });
	module.exports = __toCommonJS$262(stdin_exports$261);
	var stdin_default$219 = {
		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/lib/locale/index.js
var require_locale = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/locale/index.js": ((exports, module) => {
	var __create$122 = Object.create;
	var __defProp$261 = Object.defineProperty;
	var __getOwnPropDesc$261 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$261 = Object.getOwnPropertyNames;
	var __getProtoOf$122 = Object.getPrototypeOf;
	var __hasOwnProp$261 = Object.prototype.hasOwnProperty;
	var __export$260 = (target, all) => {
		for (var name$111 in all) __defProp$261(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$261 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$261(from)) if (!__hasOwnProp$261.call(to, key) && key !== except) __defProp$261(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$261(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$122 = (mod, isNodeMode, target) => (target = mod != null ? __create$122(__getProtoOf$122(mod)) : {}, __copyProps$261(isNodeMode || !mod || !mod.__esModule ? __defProp$261(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$261 = (mod) => __copyProps$261(__defProp$261({}, "__esModule", { value: true }), mod);
	var stdin_exports$260 = {};
	__export$260(stdin_exports$260, {
		Locale: () => Locale,
		default: () => stdin_default$218,
		useCurrentLang: () => useCurrentLang
	});
	module.exports = __toCommonJS$261(stdin_exports$260);
	var import_vue$136 = require_vue();
	var import_deep_assign = require_deep_assign();
	var import_zh_CN = __toESM$122(require_zh_CN());
	var lang = (0, import_vue$136.ref)("zh-CN");
	var messages = (0, import_vue$136.reactive)({ "zh-CN": import_zh_CN.default });
	var Locale = {
		messages() {
			return messages[lang.value];
		},
		use(newLang, newMessages) {
			lang.value = newLang;
			this.add({ [newLang]: newMessages });
		},
		add(newMessages = {}) {
			(0, import_deep_assign.deepAssign)(messages, newMessages);
		}
	};
	var useCurrentLang = () => lang;
	var stdin_default$218 = Locale;
}) });

//#endregion
//#region node_modules/vant/lib/utils/create.js
var require_create = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/create.js": ((exports, module) => {
	var __create$121 = Object.create;
	var __defProp$260 = Object.defineProperty;
	var __getOwnPropDesc$260 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$260 = Object.getOwnPropertyNames;
	var __getProtoOf$121 = Object.getPrototypeOf;
	var __hasOwnProp$260 = Object.prototype.hasOwnProperty;
	var __export$259 = (target, all) => {
		for (var name$111 in all) __defProp$260(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$260 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$260(from)) if (!__hasOwnProp$260.call(to, key) && key !== except) __defProp$260(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$260(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$121 = (mod, isNodeMode, target) => (target = mod != null ? __create$121(__getProtoOf$121(mod)) : {}, __copyProps$260(isNodeMode || !mod || !mod.__esModule ? __defProp$260(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$260 = (mod) => __copyProps$260(__defProp$260({}, "__esModule", { value: true }), mod);
	var stdin_exports$259 = {};
	__export$259(stdin_exports$259, {
		createBEM: () => createBEM,
		createNamespace: () => createNamespace,
		createTranslate: () => createTranslate
	});
	module.exports = __toCommonJS$260(stdin_exports$259);
	var import_basic$2 = require_basic();
	var import_format$1 = require_format();
	var import_locale$1 = __toESM$121(require_locale());
	function createTranslate(name$111) {
		const prefix = (0, import_format$1.camelize)(name$111) + ".";
		return (path, ...args) => {
			const messages$1 = import_locale$1.default.messages();
			const message = (0, import_basic$2.get)(messages$1, prefix + path) || (0, import_basic$2.get)(messages$1, path);
			return (0, import_basic$2.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/lib/utils/constant.js
var require_constant = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/constant.js": ((exports, module) => {
	var __defProp$259 = Object.defineProperty;
	var __getOwnPropDesc$259 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$259 = Object.getOwnPropertyNames;
	var __hasOwnProp$259 = Object.prototype.hasOwnProperty;
	var __export$258 = (target, all) => {
		for (var name$111 in all) __defProp$259(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$259 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$259(from)) if (!__hasOwnProp$259.call(to, key) && key !== except) __defProp$259(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$259(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$259 = (mod) => __copyProps$259(__defProp$259({}, "__esModule", { value: true }), mod);
	var stdin_exports$258 = {};
	__export$258(stdin_exports$258, {
		BORDER: () => BORDER,
		BORDER_BOTTOM: () => BORDER_BOTTOM,
		BORDER_LEFT: () => BORDER_LEFT,
		BORDER_RIGHT: () => BORDER_RIGHT,
		BORDER_SURROUND: () => BORDER_SURROUND,
		BORDER_TOP: () => BORDER_TOP,
		BORDER_TOP_BOTTOM: () => BORDER_TOP_BOTTOM,
		BORDER_UNSET_TOP_BOTTOM: () => BORDER_UNSET_TOP_BOTTOM,
		FORM_KEY: () => FORM_KEY,
		HAPTICS_FEEDBACK: () => HAPTICS_FEEDBACK,
		LONG_PRESS_START_TIME: () => LONG_PRESS_START_TIME,
		TAP_OFFSET: () => TAP_OFFSET
	});
	module.exports = __toCommonJS$259(stdin_exports$258);
	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/lib/utils/interceptor.js
var require_interceptor = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/interceptor.js": ((exports, module) => {
	var __defProp$258 = Object.defineProperty;
	var __getOwnPropDesc$258 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$258 = Object.getOwnPropertyNames;
	var __hasOwnProp$258 = Object.prototype.hasOwnProperty;
	var __export$257 = (target, all) => {
		for (var name$111 in all) __defProp$258(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$258 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$258(from)) if (!__hasOwnProp$258.call(to, key) && key !== except) __defProp$258(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$258(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$258 = (mod) => __copyProps$258(__defProp$258({}, "__esModule", { value: true }), mod);
	var stdin_exports$257 = {};
	__export$257(stdin_exports$257, { callInterceptor: () => callInterceptor });
	module.exports = __toCommonJS$258(stdin_exports$257);
	var import_basic$1 = require_basic();
	function callInterceptor(interceptor, { args = [], done, canceled, error }) {
		if (interceptor) {
			const returnVal = interceptor.apply(null, args);
			if ((0, import_basic$1.isPromise)(returnVal)) returnVal.then((value) => {
				if (value) done();
				else if (canceled) canceled();
			}).catch(error || import_basic$1.noop);
			else if (returnVal) done();
			else if (canceled) canceled();
		} else done();
	}
}) });

//#endregion
//#region node_modules/vant/lib/utils/with-install.js
var require_with_install = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/with-install.js": ((exports, module) => {
	var __defProp$257 = Object.defineProperty;
	var __getOwnPropDesc$257 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$257 = Object.getOwnPropertyNames;
	var __hasOwnProp$257 = Object.prototype.hasOwnProperty;
	var __export$256 = (target, all) => {
		for (var name$111 in all) __defProp$257(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$257 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$257(from)) if (!__hasOwnProp$257.call(to, key) && key !== except) __defProp$257(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$257(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$257 = (mod) => __copyProps$257(__defProp$257({}, "__esModule", { value: true }), mod);
	var stdin_exports$256 = {};
	__export$256(stdin_exports$256, { withInstall: () => withInstall });
	module.exports = __toCommonJS$257(stdin_exports$256);
	var import_format = require_format();
	function withInstall(options) {
		options.install = (app) => {
			const { name: name$111 } = options;
			if (name$111) {
				app.component(name$111, options);
				app.component((0, import_format.camelize)(`-${name$111}`), options);
			}
		};
		return options;
	}
}) });

//#endregion
//#region node_modules/vant/lib/utils/closest.js
var require_closest = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/closest.js": ((exports, module) => {
	var __defProp$256 = Object.defineProperty;
	var __getOwnPropDesc$256 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$256 = Object.getOwnPropertyNames;
	var __hasOwnProp$256 = Object.prototype.hasOwnProperty;
	var __export$255 = (target, all) => {
		for (var name$111 in all) __defProp$256(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$256 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$256(from)) if (!__hasOwnProp$256.call(to, key) && key !== except) __defProp$256(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$256(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$256 = (mod) => __copyProps$256(__defProp$256({}, "__esModule", { value: true }), mod);
	var stdin_exports$255 = {};
	__export$255(stdin_exports$255, { closest: () => closest });
	module.exports = __toCommonJS$256(stdin_exports$255);
	function closest(arr, target) {
		return arr.reduce((pre, cur) => Math.abs(pre - target) < Math.abs(cur - target) ? pre : cur);
	}
}) });

//#endregion
//#region node_modules/vant/lib/utils/index.js
var require_utils$9 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/index.js": ((exports, module) => {
	var __defProp$255 = Object.defineProperty;
	var __getOwnPropDesc$255 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$255 = Object.getOwnPropertyNames;
	var __hasOwnProp$255 = Object.prototype.hasOwnProperty;
	var __copyProps$255 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$255(from)) if (!__hasOwnProp$255.call(to, key) && key !== except) __defProp$255(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$255(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __reExport$1 = (target, mod, secondTarget) => (__copyProps$255(target, mod, "default"), secondTarget && __copyProps$255(secondTarget, mod, "default"));
	var __toCommonJS$255 = (mod) => __copyProps$255(__defProp$255({}, "__esModule", { value: true }), mod);
	var stdin_exports$254 = {};
	module.exports = __toCommonJS$255(stdin_exports$254);
	__reExport$1(stdin_exports$254, require_basic(), module.exports);
	__reExport$1(stdin_exports$254, require_props(), module.exports);
	__reExport$1(stdin_exports$254, require_dom(), module.exports);
	__reExport$1(stdin_exports$254, require_create(), module.exports);
	__reExport$1(stdin_exports$254, require_format(), module.exports);
	__reExport$1(stdin_exports$254, require_constant(), module.exports);
	__reExport$1(stdin_exports$254, require_interceptor(), module.exports);
	__reExport$1(stdin_exports$254, require_with_install(), module.exports);
	__reExport$1(stdin_exports$254, require_closest(), module.exports);
}) });

//#endregion
//#region node_modules/vant/lib/composables/on-popup-reopen.js
var require_on_popup_reopen = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/on-popup-reopen.js": ((exports, module) => {
	var __defProp$254 = Object.defineProperty;
	var __getOwnPropDesc$254 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$254 = Object.getOwnPropertyNames;
	var __hasOwnProp$254 = Object.prototype.hasOwnProperty;
	var __export$254 = (target, all) => {
		for (var name$111 in all) __defProp$254(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$254 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$254(from)) if (!__hasOwnProp$254.call(to, key) && key !== except) __defProp$254(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$254(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$254 = (mod) => __copyProps$254(__defProp$254({}, "__esModule", { value: true }), mod);
	var stdin_exports$253 = {};
	__export$254(stdin_exports$253, {
		POPUP_TOGGLE_KEY: () => POPUP_TOGGLE_KEY,
		onPopupReopen: () => onPopupReopen
	});
	module.exports = __toCommonJS$254(stdin_exports$253);
	var import_vue$135 = require_vue();
	var POPUP_TOGGLE_KEY = Symbol();
	function onPopupReopen(callback) {
		const popupToggleStatus = (0, import_vue$135.inject)(POPUP_TOGGLE_KEY, null);
		if (popupToggleStatus) (0, import_vue$135.watch)(popupToggleStatus, (show) => {
			if (show) callback();
		});
	}
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-height.js
var require_use_height = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-height.js": ((exports, module) => {
	var __defProp$253 = Object.defineProperty;
	var __getOwnPropDesc$253 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$253 = Object.getOwnPropertyNames;
	var __hasOwnProp$253 = Object.prototype.hasOwnProperty;
	var __export$253 = (target, all) => {
		for (var name$111 in all) __defProp$253(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$253 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$253(from)) if (!__hasOwnProp$253.call(to, key) && key !== except) __defProp$253(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$253(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$253 = (mod) => __copyProps$253(__defProp$253({}, "__esModule", { value: true }), mod);
	var stdin_exports$252 = {};
	__export$253(stdin_exports$252, { useHeight: () => useHeight });
	module.exports = __toCommonJS$253(stdin_exports$252);
	var import_use$66 = require_index_cjs$1();
	var import_vue$134 = require_vue();
	var import_utils$232 = require_utils$9();
	var import_on_popup_reopen$4 = require_on_popup_reopen();
	var useHeight = (element, withSafeArea) => {
		const height$1 = (0, import_vue$134.ref)();
		const setHeight = () => {
			height$1.value = (0, import_use$66.useRect)(element).height;
		};
		(0, import_vue$134.onMounted)(() => {
			(0, import_vue$134.nextTick)(setHeight);
			if (withSafeArea) for (let i = 1; i <= 3; i++) setTimeout(setHeight, 100 * i);
		});
		(0, import_on_popup_reopen$4.onPopupReopen)(() => (0, import_vue$134.nextTick)(setHeight));
		(0, import_vue$134.watch)([import_utils$232.windowWidth, import_utils$232.windowHeight], setHeight);
		return height$1;
	};
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-placeholder.js
var require_use_placeholder = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-placeholder.js": ((exports, module) => {
	var __defProp$252 = Object.defineProperty;
	var __getOwnPropDesc$252 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$252 = Object.getOwnPropertyNames;
	var __hasOwnProp$252 = Object.prototype.hasOwnProperty;
	var __export$252 = (target, all) => {
		for (var name$111 in all) __defProp$252(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$252 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$252(from)) if (!__hasOwnProp$252.call(to, key) && key !== except) __defProp$252(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$252(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$252 = (mod) => __copyProps$252(__defProp$252({}, "__esModule", { value: true }), mod);
	var stdin_exports$251 = {};
	__export$252(stdin_exports$251, { usePlaceholder: () => usePlaceholder });
	module.exports = __toCommonJS$252(stdin_exports$251);
	var import_vue$133 = require_vue();
	var import_use_height$1 = require_use_height();
	function usePlaceholder(contentRef, bem$106) {
		const height$1 = (0, import_use_height$1.useHeight)(contentRef, true);
		return (renderContent) => (0, import_vue$133.createVNode)("div", {
			"class": bem$106("placeholder"),
			"style": { height: height$1.value ? `${height$1.value}px` : void 0 }
		}, [renderContent()]);
	}
}) });

//#endregion
//#region node_modules/vant/lib/action-bar/ActionBar.js
var require_ActionBar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/action-bar/ActionBar.js": ((exports, module) => {
	var __defProp$251 = Object.defineProperty;
	var __getOwnPropDesc$251 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$251 = Object.getOwnPropertyNames;
	var __hasOwnProp$251 = Object.prototype.hasOwnProperty;
	var __export$251 = (target, all) => {
		for (var name2 in all) __defProp$251(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$251 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$251(from)) if (!__hasOwnProp$251.call(to, key) && key !== except) __defProp$251(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$251(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$251 = (mod) => __copyProps$251(__defProp$251({}, "__esModule", { value: true }), mod);
	var stdin_exports$250 = {};
	__export$251(stdin_exports$250, {
		ACTION_BAR_KEY: () => ACTION_BAR_KEY,
		actionBarProps: () => actionBarProps,
		default: () => stdin_default$217
	});
	module.exports = __toCommonJS$251(stdin_exports$250);
	var import_vue$132 = require_vue();
	var import_utils$231 = require_utils$9();
	var import_use$65 = require_index_cjs$1();
	var import_use_placeholder$3 = require_use_placeholder();
	var [name$110, bem$105] = (0, import_utils$231.createNamespace)("action-bar");
	var ACTION_BAR_KEY = Symbol(name$110);
	var actionBarProps = {
		placeholder: Boolean,
		safeAreaInsetBottom: import_utils$231.truthProp
	};
	var stdin_default$217 = (0, import_vue$132.defineComponent)({
		name: name$110,
		props: actionBarProps,
		setup(props$1, { slots }) {
			const root = (0, import_vue$132.ref)();
			const renderPlaceholder = (0, import_use_placeholder$3.usePlaceholder)(root, bem$105);
			const { linkChildren } = (0, import_use$65.useChildren)(ACTION_BAR_KEY);
			linkChildren();
			const renderActionBar = () => {
				var _a;
				return (0, import_vue$132.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/lib/action-bar/index.js
var require_action_bar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/action-bar/index.js": ((exports, module) => {
	var __create$120 = Object.create;
	var __defProp$250 = Object.defineProperty;
	var __getOwnPropDesc$250 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$250 = Object.getOwnPropertyNames;
	var __getProtoOf$120 = Object.getPrototypeOf;
	var __hasOwnProp$250 = Object.prototype.hasOwnProperty;
	var __export$250 = (target, all) => {
		for (var name$111 in all) __defProp$250(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$250 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$250(from)) if (!__hasOwnProp$250.call(to, key) && key !== except) __defProp$250(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$250(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$120 = (mod, isNodeMode, target) => (target = mod != null ? __create$120(__getProtoOf$120(mod)) : {}, __copyProps$250(isNodeMode || !mod || !mod.__esModule ? __defProp$250(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$250 = (mod) => __copyProps$250(__defProp$250({}, "__esModule", { value: true }), mod);
	var stdin_exports$249 = {};
	__export$250(stdin_exports$249, {
		ActionBar: () => ActionBar,
		actionBarProps: () => import_ActionBar2.actionBarProps,
		default: () => stdin_default$216
	});
	module.exports = __toCommonJS$250(stdin_exports$249);
	var import_utils$230 = require_utils$9();
	var import_ActionBar$2 = __toESM$120(require_ActionBar());
	var import_ActionBar2 = require_ActionBar();
	var ActionBar = (0, import_utils$230.withInstall)(import_ActionBar$2.default);
	var stdin_default$216 = ActionBar;
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-expose.js
var require_use_expose = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-expose.js": ((exports, module) => {
	var __defProp$249 = Object.defineProperty;
	var __getOwnPropDesc$249 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$249 = Object.getOwnPropertyNames;
	var __hasOwnProp$249 = Object.prototype.hasOwnProperty;
	var __export$249 = (target, all) => {
		for (var name$111 in all) __defProp$249(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$249 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$249(from)) if (!__hasOwnProp$249.call(to, key) && key !== except) __defProp$249(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$249(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$249 = (mod) => __copyProps$249(__defProp$249({}, "__esModule", { value: true }), mod);
	var stdin_exports$248 = {};
	__export$249(stdin_exports$248, { useExpose: () => useExpose });
	module.exports = __toCommonJS$249(stdin_exports$248);
	var import_vue$131 = require_vue();
	var import_utils$229 = require_utils$9();
	function useExpose(apis) {
		const instance$3 = (0, import_vue$131.getCurrentInstance)();
		if (instance$3) (0, import_utils$229.extend)(instance$3.proxy, apis);
	}
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-route.js
var require_use_route = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-route.js": ((exports, module) => {
	var __defProp$248 = Object.defineProperty;
	var __getOwnPropDesc$248 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$248 = Object.getOwnPropertyNames;
	var __hasOwnProp$248 = Object.prototype.hasOwnProperty;
	var __export$248 = (target, all) => {
		for (var name$111 in all) __defProp$248(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$248 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$248(from)) if (!__hasOwnProp$248.call(to, key) && key !== except) __defProp$248(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$248(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$248 = (mod) => __copyProps$248(__defProp$248({}, "__esModule", { value: true }), mod);
	var stdin_exports$247 = {};
	__export$248(stdin_exports$247, {
		route: () => route,
		routeProps: () => routeProps,
		useRoute: () => useRoute
	});
	module.exports = __toCommonJS$248(stdin_exports$247);
	var import_vue$130 = require_vue();
	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 = (0, import_vue$130.getCurrentInstance)().proxy;
		return () => route(vm);
	}
}) });

//#endregion
//#region node_modules/vant/lib/badge/Badge.js
var require_Badge = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/badge/Badge.js": ((exports, module) => {
	var __defProp$247 = Object.defineProperty;
	var __getOwnPropDesc$247 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$247 = Object.getOwnPropertyNames;
	var __hasOwnProp$247 = Object.prototype.hasOwnProperty;
	var __export$247 = (target, all) => {
		for (var name2 in all) __defProp$247(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$247 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$247(from)) if (!__hasOwnProp$247.call(to, key) && key !== except) __defProp$247(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$247(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$247 = (mod) => __copyProps$247(__defProp$247({}, "__esModule", { value: true }), mod);
	var stdin_exports$246 = {};
	__export$247(stdin_exports$246, {
		badgeProps: () => badgeProps,
		default: () => stdin_default$215
	});
	module.exports = __toCommonJS$247(stdin_exports$246);
	var import_vue$129 = require_vue();
	var import_utils$228 = require_utils$9();
	var [name$109, bem$104] = (0, import_utils$228.createNamespace)("badge");
	var badgeProps = {
		dot: Boolean,
		max: import_utils$228.numericProp,
		tag: (0, import_utils$228.makeStringProp)("div"),
		color: String,
		offset: Array,
		content: import_utils$228.numericProp,
		showZero: import_utils$228.truthProp,
		position: (0, import_utils$228.makeStringProp)("top-right")
	};
	var stdin_default$215 = (0, import_vue$129.defineComponent)({
		name: name$109,
		props: badgeProps,
		setup(props$1, { slots }) {
			const hasContent = () => {
				if (slots.content) return true;
				const { content, showZero } = props$1;
				return (0, import_utils$228.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 ((0, import_utils$228.isDef)(max) && (0, import_utils$228.isNumeric)(content) && +content > +max) return `${max}+`;
					return content;
				}
			};
			const getOffsetWithMinusString = (val) => val.startsWith("-") ? val.replace("-", "") : `-${val}`;
			const style = (0, import_vue$129.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] = (0, import_utils$228.addUnit)(offsetY === "top" ? y : -y);
						else style2[offsetY] = offsetY === "top" ? (0, import_utils$228.addUnit)(y) : getOffsetWithMinusString(y);
						if (typeof x === "number") style2[offsetX] = (0, import_utils$228.addUnit)(offsetX === "left" ? x : -x);
						else style2[offsetX] = offsetX === "left" ? (0, import_utils$228.addUnit)(x) : getOffsetWithMinusString(x);
					} else {
						style2.marginTop = (0, import_utils$228.addUnit)(y);
						style2.marginLeft = (0, import_utils$228.addUnit)(x);
					}
				}
				return style2;
			});
			const renderBadge = () => {
				if (hasContent() || props$1.dot) return (0, import_vue$129.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 (0, import_vue$129.createVNode)(tag, { "class": bem$104("wrapper") }, { default: () => [slots.default(), renderBadge()] });
				}
				return renderBadge();
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/badge/index.js
var require_badge = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/badge/index.js": ((exports, module) => {
	var __create$119 = Object.create;
	var __defProp$246 = Object.defineProperty;
	var __getOwnPropDesc$246 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$246 = Object.getOwnPropertyNames;
	var __getProtoOf$119 = Object.getPrototypeOf;
	var __hasOwnProp$246 = Object.prototype.hasOwnProperty;
	var __export$246 = (target, all) => {
		for (var name$111 in all) __defProp$246(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$246 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$246(from)) if (!__hasOwnProp$246.call(to, key) && key !== except) __defProp$246(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$246(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$119 = (mod, isNodeMode, target) => (target = mod != null ? __create$119(__getProtoOf$119(mod)) : {}, __copyProps$246(isNodeMode || !mod || !mod.__esModule ? __defProp$246(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$246 = (mod) => __copyProps$246(__defProp$246({}, "__esModule", { value: true }), mod);
	var stdin_exports$245 = {};
	__export$246(stdin_exports$245, {
		Badge: () => Badge,
		badgeProps: () => import_Badge2.badgeProps,
		default: () => stdin_default$214
	});
	module.exports = __toCommonJS$246(stdin_exports$245);
	var import_utils$227 = require_utils$9();
	var import_Badge = __toESM$119(require_Badge());
	var import_Badge2 = require_Badge();
	var Badge = (0, import_utils$227.withInstall)(import_Badge.default);
	var stdin_default$214 = Badge;
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-global-z-index.js
var require_use_global_z_index = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-global-z-index.js": ((exports, module) => {
	var __defProp$245 = Object.defineProperty;
	var __getOwnPropDesc$245 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$245 = Object.getOwnPropertyNames;
	var __hasOwnProp$245 = Object.prototype.hasOwnProperty;
	var __export$245 = (target, all) => {
		for (var name$111 in all) __defProp$245(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$245 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$245(from)) if (!__hasOwnProp$245.call(to, key) && key !== except) __defProp$245(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$245(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$245 = (mod) => __copyProps$245(__defProp$245({}, "__esModule", { value: true }), mod);
	var stdin_exports$244 = {};
	__export$245(stdin_exports$244, {
		setGlobalZIndex: () => setGlobalZIndex,
		useGlobalZIndex: () => useGlobalZIndex
	});
	module.exports = __toCommonJS$245(stdin_exports$244);
	var globalZIndex = 2e3;
	var useGlobalZIndex = () => ++globalZIndex;
	var setGlobalZIndex = (val) => {
		globalZIndex = val;
	};
}) });

//#endregion
//#region node_modules/vant/lib/config-provider/ConfigProvider.js
var require_ConfigProvider = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/config-provider/ConfigProvider.js": ((exports, module) => {
	var __defProp$244 = Object.defineProperty;
	var __getOwnPropDesc$244 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$244 = Object.getOwnPropertyNames;
	var __hasOwnProp$244 = Object.prototype.hasOwnProperty;
	var __export$244 = (target, all) => {
		for (var name2 in all) __defProp$244(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$244 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$244(from)) if (!__hasOwnProp$244.call(to, key) && key !== except) __defProp$244(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$244(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$244 = (mod) => __copyProps$244(__defProp$244({}, "__esModule", { value: true }), mod);
	var stdin_exports$243 = {};
	__export$244(stdin_exports$243, {
		CONFIG_PROVIDER_KEY: () => CONFIG_PROVIDER_KEY,
		configProviderProps: () => configProviderProps,
		default: () => stdin_default$213
	});
	module.exports = __toCommonJS$244(stdin_exports$243);
	var import_vue$128 = require_vue();
	var import_utils$226 = require_utils$9();
	var import_use_global_z_index$1 = require_use_global_z_index();
	var [name$108, bem$103] = (0, import_utils$226.createNamespace)("config-provider");
	var CONFIG_PROVIDER_KEY = Symbol(name$108);
	var configProviderProps = {
		tag: (0, import_utils$226.makeStringProp)("div"),
		theme: (0, import_utils$226.makeStringProp)("light"),
		zIndex: Number,
		themeVars: Object,
		themeVarsDark: Object,
		themeVarsLight: Object,
		themeVarsScope: (0, import_utils$226.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((0, import_utils$226.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$213 = (0, import_vue$128.defineComponent)({
		name: name$108,
		props: configProviderProps,
		setup(props$1, { slots }) {
			const style = (0, import_vue$128.computed)(() => mapThemeVarsToCSSVars((0, import_utils$226.extend)({}, props$1.themeVars, props$1.theme === "dark" ? props$1.themeVarsDark : props$1.themeVarsLight)));
			if (import_utils$226.inBrowser) {
				const addTheme = () => {
					document.documentElement.classList.add(`van-theme-${props$1.theme}`);
				};
				const removeTheme = (theme = props$1.theme) => {
					document.documentElement.classList.remove(`van-theme-${theme}`);
				};
				(0, import_vue$128.watch)(() => props$1.theme, (newVal, oldVal) => {
					if (oldVal) removeTheme(oldVal);
					addTheme();
				}, { immediate: true });
				(0, import_vue$128.onActivated)(addTheme);
				(0, import_vue$128.onDeactivated)(removeTheme);
				(0, import_vue$128.onBeforeUnmount)(removeTheme);
				(0, import_vue$128.watch)(style, (newStyle, oldStyle) => {
					if (props$1.themeVarsScope === "global") syncThemeVarsOnRoot(newStyle, oldStyle);
				});
				(0, import_vue$128.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, {});
			}
			(0, import_vue$128.provide)(CONFIG_PROVIDER_KEY, props$1);
			(0, import_vue$128.watchEffect)(() => {
				if (props$1.zIndex !== void 0) (0, import_use_global_z_index$1.setGlobalZIndex)(props$1.zIndex);
			});
			return () => (0, import_vue$128.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/lib/icon/Icon.js
var require_Icon = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/icon/Icon.js": ((exports, module) => {
	var __defProp$243 = Object.defineProperty;
	var __getOwnPropDesc$243 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$243 = Object.getOwnPropertyNames;
	var __hasOwnProp$243 = Object.prototype.hasOwnProperty;
	var __export$243 = (target, all) => {
		for (var name2 in all) __defProp$243(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$243 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$243(from)) if (!__hasOwnProp$243.call(to, key) && key !== except) __defProp$243(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$243(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$243 = (mod) => __copyProps$243(__defProp$243({}, "__esModule", { value: true }), mod);
	var stdin_exports$242 = {};
	__export$243(stdin_exports$242, {
		default: () => stdin_default$212,
		iconProps: () => iconProps
	});
	module.exports = __toCommonJS$243(stdin_exports$242);
	var import_vue$127 = require_vue();
	var import_utils$225 = require_utils$9();
	var import_badge$6 = require_badge();
	var import_ConfigProvider$1 = require_ConfigProvider();
	var [name$107, bem$102] = (0, import_utils$225.createNamespace)("icon");
	var isImage$1 = (name2) => name2 == null ? void 0 : name2.includes("/");
	var iconProps = {
		dot: Boolean,
		tag: (0, import_utils$225.makeStringProp)("i"),
		name: String,
		size: import_utils$225.numericProp,
		badge: import_utils$225.numericProp,
		color: String,
		badgeProps: Object,
		classPrefix: String
	};
	var stdin_default$212 = (0, import_vue$127.defineComponent)({
		name: name$107,
		props: iconProps,
		setup(props$1, { slots }) {
			const config = (0, import_vue$127.inject)(import_ConfigProvider$1.CONFIG_PROVIDER_KEY, null);
			const classPrefix = (0, import_vue$127.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 (0, import_vue$127.createVNode)(import_badge$6.Badge, (0, import_vue$127.mergeProps)({
					"dot": dot,
					"tag": tag,
					"class": [classPrefix.value, isImageIcon ? "" : `${classPrefix.value}-${name2}`],
					"style": {
						color,
						fontSize: (0, import_utils$225.addUnit)(size)
					},
					"content": badge
				}, props$1.badgeProps), { default: () => {
					var _a;
					return [(_a = slots.default) == null ? void 0 : _a.call(slots), isImageIcon && (0, import_vue$127.createVNode)("img", {
						"class": bem$102("image"),
						"src": name2
					}, null)];
				} });
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/icon/index.js
var require_icon = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/icon/index.js": ((exports, module) => {
	var __create$118 = Object.create;
	var __defProp$242 = Object.defineProperty;
	var __getOwnPropDesc$242 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$242 = Object.getOwnPropertyNames;
	var __getProtoOf$118 = Object.getPrototypeOf;
	var __hasOwnProp$242 = Object.prototype.hasOwnProperty;
	var __export$242 = (target, all) => {
		for (var name$111 in all) __defProp$242(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$242 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$242(from)) if (!__hasOwnProp$242.call(to, key) && key !== except) __defProp$242(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$242(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$118 = (mod, isNodeMode, target) => (target = mod != null ? __create$118(__getProtoOf$118(mod)) : {}, __copyProps$242(isNodeMode || !mod || !mod.__esModule ? __defProp$242(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$242 = (mod) => __copyProps$242(__defProp$242({}, "__esModule", { value: true }), mod);
	var stdin_exports$241 = {};
	__export$242(stdin_exports$241, {
		Icon: () => Icon,
		default: () => stdin_default$211,
		iconProps: () => import_Icon2.iconProps
	});
	module.exports = __toCommonJS$242(stdin_exports$241);
	var import_utils$224 = require_utils$9();
	var import_Icon = __toESM$118(require_Icon());
	var import_Icon2 = require_Icon();
	var Icon = (0, import_utils$224.withInstall)(import_Icon.default);
	var stdin_default$211 = Icon;
}) });

//#endregion
//#region node_modules/vant/lib/loading/Loading.js
var require_Loading = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/loading/Loading.js": ((exports, module) => {
	var __defProp$241 = Object.defineProperty;
	var __getOwnPropDesc$241 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$241 = Object.getOwnPropertyNames;
	var __hasOwnProp$241 = Object.prototype.hasOwnProperty;
	var __export$241 = (target, all) => {
		for (var name2 in all) __defProp$241(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$241 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$241(from)) if (!__hasOwnProp$241.call(to, key) && key !== except) __defProp$241(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$241(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$241 = (mod) => __copyProps$241(__defProp$241({}, "__esModule", { value: true }), mod);
	var stdin_exports$240 = {};
	__export$241(stdin_exports$240, {
		default: () => stdin_default$210,
		loadingProps: () => loadingProps
	});
	module.exports = __toCommonJS$241(stdin_exports$240);
	var import_vue$126 = require_vue();
	var import_utils$223 = require_utils$9();
	var [name$106, bem$101] = (0, import_utils$223.createNamespace)("loading");
	var SpinIcon = Array(12).fill(null).map((_, index) => (0, import_vue$126.createVNode)("i", { "class": bem$101("line", String(index + 1)) }, null));
	var CircularIcon = (0, import_vue$126.createVNode)("svg", {
		"class": bem$101("circular"),
		"viewBox": "25 25 50 50"
	}, [(0, import_vue$126.createVNode)("circle", {
		"cx": "50",
		"cy": "50",
		"r": "20",
		"fill": "none"
	}, null)]);
	var loadingProps = {
		size: import_utils$223.numericProp,
		type: (0, import_utils$223.makeStringProp)("circular"),
		color: String,
		vertical: Boolean,
		textSize: import_utils$223.numericProp,
		textColor: String
	};
	var stdin_default$210 = (0, import_vue$126.defineComponent)({
		name: name$106,
		props: loadingProps,
		setup(props$1, { slots }) {
			const spinnerStyle = (0, import_vue$126.computed)(() => (0, import_utils$223.extend)({ color: props$1.color }, (0, import_utils$223.getSizeStyle)(props$1.size)));
			const renderIcon = () => {
				const DefaultIcon = props$1.type === "spinner" ? SpinIcon : CircularIcon;
				return (0, import_vue$126.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 (0, import_vue$126.createVNode)("span", {
					"class": bem$101("text"),
					"style": {
						fontSize: (0, import_utils$223.addUnit)(props$1.textSize),
						color: (_a = props$1.textColor) != null ? _a : props$1.color
					}
				}, [slots.default()]);
			};
			return () => {
				const { type, vertical } = props$1;
				return (0, import_vue$126.createVNode)("div", {
					"class": bem$101([type, { vertical }]),
					"aria-live": "polite",
					"aria-busy": true
				}, [renderIcon(), renderText()]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/loading/index.js
var require_loading = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/loading/index.js": ((exports, module) => {
	var __create$117 = Object.create;
	var __defProp$240 = Object.defineProperty;
	var __getOwnPropDesc$240 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$240 = Object.getOwnPropertyNames;
	var __getProtoOf$117 = Object.getPrototypeOf;
	var __hasOwnProp$240 = Object.prototype.hasOwnProperty;
	var __export$240 = (target, all) => {
		for (var name$111 in all) __defProp$240(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$240 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$240(from)) if (!__hasOwnProp$240.call(to, key) && key !== except) __defProp$240(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$240(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$117 = (mod, isNodeMode, target) => (target = mod != null ? __create$117(__getProtoOf$117(mod)) : {}, __copyProps$240(isNodeMode || !mod || !mod.__esModule ? __defProp$240(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$240 = (mod) => __copyProps$240(__defProp$240({}, "__esModule", { value: true }), mod);
	var stdin_exports$239 = {};
	__export$240(stdin_exports$239, {
		Loading: () => Loading,
		default: () => stdin_default$209,
		loadingProps: () => import_Loading2.loadingProps
	});
	module.exports = __toCommonJS$240(stdin_exports$239);
	var import_utils$222 = require_utils$9();
	var import_Loading = __toESM$117(require_Loading());
	var import_Loading2 = require_Loading();
	var Loading = (0, import_utils$222.withInstall)(import_Loading.default);
	var stdin_default$209 = Loading;
}) });

//#endregion
//#region node_modules/vant/lib/button/Button.js
var require_Button = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/button/Button.js": ((exports, module) => {
	var __defProp$239 = Object.defineProperty;
	var __getOwnPropDesc$239 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$239 = Object.getOwnPropertyNames;
	var __hasOwnProp$239 = Object.prototype.hasOwnProperty;
	var __export$239 = (target, all) => {
		for (var name2 in all) __defProp$239(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$239 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$239(from)) if (!__hasOwnProp$239.call(to, key) && key !== except) __defProp$239(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$239(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$239 = (mod) => __copyProps$239(__defProp$239({}, "__esModule", { value: true }), mod);
	var stdin_exports$238 = {};
	__export$239(stdin_exports$238, {
		buttonProps: () => buttonProps,
		default: () => stdin_default$208
	});
	module.exports = __toCommonJS$239(stdin_exports$238);
	var import_vue$125 = require_vue();
	var import_utils$221 = require_utils$9();
	var import_use_route$8 = require_use_route();
	var import_icon$31 = require_icon();
	var import_loading$10 = require_loading();
	var [name$105, bem$100] = (0, import_utils$221.createNamespace)("button");
	var buttonProps = (0, import_utils$221.extend)({}, import_use_route$8.routeProps, {
		tag: (0, import_utils$221.makeStringProp)("button"),
		text: String,
		icon: String,
		type: (0, import_utils$221.makeStringProp)("default"),
		size: (0, import_utils$221.makeStringProp)("normal"),
		color: String,
		block: Boolean,
		plain: Boolean,
		round: Boolean,
		square: Boolean,
		loading: Boolean,
		hairline: Boolean,
		disabled: Boolean,
		iconPrefix: String,
		nativeType: (0, import_utils$221.makeStringProp)("button"),
		loadingSize: import_utils$221.numericProp,
		loadingText: String,
		loadingType: String,
		iconPosition: (0, import_utils$221.makeStringProp)("left")
	});
	var stdin_default$208 = (0, import_vue$125.defineComponent)({
		name: name$105,
		props: buttonProps,
		emits: ["click"],
		setup(props$1, { emit, slots }) {
			const route$1 = (0, import_use_route$8.useRoute)();
			const renderLoadingIcon = () => {
				if (slots.loading) return slots.loading();
				return (0, import_vue$125.createVNode)(import_loading$10.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 (0, import_vue$125.createVNode)("div", { "class": bem$100("icon") }, [slots.icon()]);
				if (props$1.icon) return (0, import_vue$125.createVNode)(import_icon$31.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 (0, import_vue$125.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) (0, import_utils$221.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
					}
				]), { [import_utils$221.BORDER_SURROUND]: hairline }];
				return (0, import_vue$125.createVNode)(tag, {
					"type": nativeType,
					"class": classes,
					"style": getStyle(),
					"disabled": disabled,
					"onClick": onClick
				}, { default: () => [(0, import_vue$125.createVNode)("div", { "class": bem$100("content") }, [
					iconPosition === "left" && renderIcon(),
					renderText(),
					iconPosition === "right" && renderIcon()
				])] });
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/button/index.js
var require_button = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/button/index.js": ((exports, module) => {
	var __create$116 = Object.create;
	var __defProp$238 = Object.defineProperty;
	var __getOwnPropDesc$238 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$238 = Object.getOwnPropertyNames;
	var __getProtoOf$116 = Object.getPrototypeOf;
	var __hasOwnProp$238 = Object.prototype.hasOwnProperty;
	var __export$238 = (target, all) => {
		for (var name$111 in all) __defProp$238(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$238 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$238(from)) if (!__hasOwnProp$238.call(to, key) && key !== except) __defProp$238(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$238(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$116 = (mod, isNodeMode, target) => (target = mod != null ? __create$116(__getProtoOf$116(mod)) : {}, __copyProps$238(isNodeMode || !mod || !mod.__esModule ? __defProp$238(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$238 = (mod) => __copyProps$238(__defProp$238({}, "__esModule", { value: true }), mod);
	var stdin_exports$237 = {};
	__export$238(stdin_exports$237, {
		Button: () => Button,
		buttonProps: () => import_Button2.buttonProps,
		default: () => stdin_default$207
	});
	module.exports = __toCommonJS$238(stdin_exports$237);
	var import_utils$220 = require_utils$9();
	var import_Button = __toESM$116(require_Button());
	var import_Button2 = require_Button();
	var Button = (0, import_utils$220.withInstall)(import_Button.default);
	var stdin_default$207 = Button;
}) });

//#endregion
//#region node_modules/vant/lib/action-bar-button/ActionBarButton.js
var require_ActionBarButton = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/action-bar-button/ActionBarButton.js": ((exports, module) => {
	var __defProp$237 = Object.defineProperty;
	var __getOwnPropDesc$237 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$237 = Object.getOwnPropertyNames;
	var __hasOwnProp$237 = Object.prototype.hasOwnProperty;
	var __export$237 = (target, all) => {
		for (var name2 in all) __defProp$237(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$237 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$237(from)) if (!__hasOwnProp$237.call(to, key) && key !== except) __defProp$237(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$237(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$237 = (mod) => __copyProps$237(__defProp$237({}, "__esModule", { value: true }), mod);
	var stdin_exports$236 = {};
	__export$237(stdin_exports$236, {
		actionBarButtonProps: () => actionBarButtonProps,
		default: () => stdin_default$206
	});
	module.exports = __toCommonJS$237(stdin_exports$236);
	var import_vue$124 = require_vue();
	var import_utils$219 = require_utils$9();
	var import_ActionBar$1 = require_ActionBar();
	var import_use$64 = require_index_cjs$1();
	var import_use_expose$37 = require_use_expose();
	var import_use_route$7 = require_use_route();
	var import_button$10 = require_button();
	var [name$104, bem$99] = (0, import_utils$219.createNamespace)("action-bar-button");
	var actionBarButtonProps = (0, import_utils$219.extend)({}, import_use_route$7.routeProps, {
		type: String,
		text: String,
		icon: String,
		color: String,
		loading: Boolean,
		disabled: Boolean
	});
	var stdin_default$206 = (0, import_vue$124.defineComponent)({
		name: name$104,
		props: actionBarButtonProps,
		setup(props$1, { slots }) {
			const route$1 = (0, import_use_route$7.useRoute)();
			const { parent, index } = (0, import_use$64.useParent)(import_ActionBar$1.ACTION_BAR_KEY);
			const isFirst = (0, import_vue$124.computed)(() => {
				if (parent) {
					const prev = parent.children[index.value - 1];
					return !(prev && "isButton" in prev);
				}
			});
			const isLast = (0, import_vue$124.computed)(() => {
				if (parent) {
					const next = parent.children[index.value + 1];
					return !(next && "isButton" in next);
				}
			});
			(0, import_use_expose$37.useExpose)({ isButton: true });
			return () => {
				const { type, icon, text, color, loading, disabled } = props$1;
				return (0, import_vue$124.createVNode)(import_button$10.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/lib/action-bar-button/index.js
var require_action_bar_button = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/action-bar-button/index.js": ((exports, module) => {
	var __create$115 = Object.create;
	var __defProp$236 = Object.defineProperty;
	var __getOwnPropDesc$236 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$236 = Object.getOwnPropertyNames;
	var __getProtoOf$115 = Object.getPrototypeOf;
	var __hasOwnProp$236 = Object.prototype.hasOwnProperty;
	var __export$236 = (target, all) => {
		for (var name$111 in all) __defProp$236(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$236 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$236(from)) if (!__hasOwnProp$236.call(to, key) && key !== except) __defProp$236(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$236(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$115 = (mod, isNodeMode, target) => (target = mod != null ? __create$115(__getProtoOf$115(mod)) : {}, __copyProps$236(isNodeMode || !mod || !mod.__esModule ? __defProp$236(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$236 = (mod) => __copyProps$236(__defProp$236({}, "__esModule", { value: true }), mod);
	var stdin_exports$235 = {};
	__export$236(stdin_exports$235, {
		ActionBarButton: () => ActionBarButton,
		actionBarButtonProps: () => import_ActionBarButton2.actionBarButtonProps,
		default: () => stdin_default$205
	});
	module.exports = __toCommonJS$236(stdin_exports$235);
	var import_utils$218 = require_utils$9();
	var import_ActionBarButton = __toESM$115(require_ActionBarButton());
	var import_ActionBarButton2 = require_ActionBarButton();
	var ActionBarButton = (0, import_utils$218.withInstall)(import_ActionBarButton.default);
	var stdin_default$205 = ActionBarButton;
}) });

//#endregion
//#region node_modules/vant/lib/action-bar-icon/ActionBarIcon.js
var require_ActionBarIcon = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/action-bar-icon/ActionBarIcon.js": ((exports, module) => {
	var __defProp$235 = Object.defineProperty;
	var __getOwnPropDesc$235 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$235 = Object.getOwnPropertyNames;
	var __hasOwnProp$235 = Object.prototype.hasOwnProperty;
	var __export$235 = (target, all) => {
		for (var name2 in all) __defProp$235(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$235 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$235(from)) if (!__hasOwnProp$235.call(to, key) && key !== except) __defProp$235(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$235(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$235 = (mod) => __copyProps$235(__defProp$235({}, "__esModule", { value: true }), mod);
	var stdin_exports$234 = {};
	__export$235(stdin_exports$234, {
		actionBarIconProps: () => actionBarIconProps,
		default: () => stdin_default$204
	});
	module.exports = __toCommonJS$235(stdin_exports$234);
	var import_vue$123 = require_vue();
	var import_utils$217 = require_utils$9();
	var import_ActionBar = require_ActionBar();
	var import_use$63 = require_index_cjs$1();
	var import_use_route$6 = require_use_route();
	var import_icon$30 = require_icon();
	var import_badge$5 = require_badge();
	var [name$103, bem$98] = (0, import_utils$217.createNamespace)("action-bar-icon");
	var actionBarIconProps = (0, import_utils$217.extend)({}, import_use_route$6.routeProps, {
		dot: Boolean,
		text: String,
		icon: String,
		color: String,
		badge: import_utils$217.numericProp,
		iconClass: import_utils$217.unknownProp,
		badgeProps: Object,
		iconPrefix: String
	});
	var stdin_default$204 = (0, import_vue$123.defineComponent)({
		name: name$103,
		props: actionBarIconProps,
		setup(props$1, { slots }) {
			const route$1 = (0, import_use_route$6.useRoute)();
			(0, import_use$63.useParent)(import_ActionBar.ACTION_BAR_KEY);
			const renderIcon = () => {
				const { dot, badge, icon, color, iconClass, badgeProps: badgeProps$1, iconPrefix } = props$1;
				if (slots.icon) return (0, import_vue$123.createVNode)(import_badge$5.Badge, (0, import_vue$123.mergeProps)({
					"dot": dot,
					"class": bem$98("icon"),
					"content": badge
				}, badgeProps$1), { default: slots.icon });
				return (0, import_vue$123.createVNode)(import_icon$30.Icon, {
					"tag": "div",
					"dot": dot,
					"name": icon,
					"badge": badge,
					"color": color,
					"class": [bem$98("icon"), iconClass],
					"badgeProps": badgeProps$1,
					"classPrefix": iconPrefix
				}, null);
			};
			return () => (0, import_vue$123.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/lib/action-bar-icon/index.js
var require_action_bar_icon = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/action-bar-icon/index.js": ((exports, module) => {
	var __create$114 = Object.create;
	var __defProp$234 = Object.defineProperty;
	var __getOwnPropDesc$234 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$234 = Object.getOwnPropertyNames;
	var __getProtoOf$114 = Object.getPrototypeOf;
	var __hasOwnProp$234 = Object.prototype.hasOwnProperty;
	var __export$234 = (target, all) => {
		for (var name$111 in all) __defProp$234(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$234 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$234(from)) if (!__hasOwnProp$234.call(to, key) && key !== except) __defProp$234(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$234(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$114 = (mod, isNodeMode, target) => (target = mod != null ? __create$114(__getProtoOf$114(mod)) : {}, __copyProps$234(isNodeMode || !mod || !mod.__esModule ? __defProp$234(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$234 = (mod) => __copyProps$234(__defProp$234({}, "__esModule", { value: true }), mod);
	var stdin_exports$233 = {};
	__export$234(stdin_exports$233, {
		ActionBarIcon: () => ActionBarIcon,
		actionBarIconProps: () => import_ActionBarIcon2.actionBarIconProps,
		default: () => stdin_default$203
	});
	module.exports = __toCommonJS$234(stdin_exports$233);
	var import_utils$216 = require_utils$9();
	var import_ActionBarIcon = __toESM$114(require_ActionBarIcon());
	var import_ActionBarIcon2 = require_ActionBarIcon();
	var ActionBarIcon = (0, import_utils$216.withInstall)(import_ActionBarIcon.default);
	var stdin_default$203 = ActionBarIcon;
}) });

//#endregion
//#region node_modules/vant/lib/popup/shared.js
var require_shared = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/popup/shared.js": ((exports, module) => {
	var __defProp$233 = Object.defineProperty;
	var __getOwnPropDesc$233 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$233 = Object.getOwnPropertyNames;
	var __hasOwnProp$233 = Object.prototype.hasOwnProperty;
	var __export$233 = (target, all) => {
		for (var name$111 in all) __defProp$233(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$233 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$233(from)) if (!__hasOwnProp$233.call(to, key) && key !== except) __defProp$233(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$233(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$233 = (mod) => __copyProps$233(__defProp$233({}, "__esModule", { value: true }), mod);
	var stdin_exports$232 = {};
	__export$233(stdin_exports$232, {
		popupSharedPropKeys: () => popupSharedPropKeys,
		popupSharedProps: () => popupSharedProps
	});
	module.exports = __toCommonJS$233(stdin_exports$232);
	var import_utils$215 = require_utils$9();
	var popupSharedProps = {
		show: Boolean,
		zIndex: import_utils$215.numericProp,
		overlay: import_utils$215.truthProp,
		duration: import_utils$215.numericProp,
		teleport: [String, Object],
		lockScroll: import_utils$215.truthProp,
		lazyRender: import_utils$215.truthProp,
		beforeClose: Function,
		overlayProps: Object,
		overlayStyle: Object,
		overlayClass: import_utils$215.unknownProp,
		transitionAppear: Boolean,
		closeOnClickOverlay: import_utils$215.truthProp
	};
	var popupSharedPropKeys = Object.keys(popupSharedProps);
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-touch.js
var require_use_touch = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-touch.js": ((exports, module) => {
	var __defProp$232 = Object.defineProperty;
	var __getOwnPropDesc$232 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$232 = Object.getOwnPropertyNames;
	var __hasOwnProp$232 = Object.prototype.hasOwnProperty;
	var __export$232 = (target, all) => {
		for (var name$111 in all) __defProp$232(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$232 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$232(from)) if (!__hasOwnProp$232.call(to, key) && key !== except) __defProp$232(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$232(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$232 = (mod) => __copyProps$232(__defProp$232({}, "__esModule", { value: true }), mod);
	var stdin_exports$231 = {};
	__export$232(stdin_exports$231, { useTouch: () => useTouch });
	module.exports = __toCommonJS$232(stdin_exports$231);
	var import_vue$122 = require_vue();
	var import_utils$214 = require_utils$9();
	function getDirection(x, y) {
		if (x > y) return "horizontal";
		if (y > x) return "vertical";
		return "";
	}
	function useTouch() {
		const startX = (0, import_vue$122.ref)(0);
		const startY = (0, import_vue$122.ref)(0);
		const deltaX = (0, import_vue$122.ref)(0);
		const deltaY = (0, import_vue$122.ref)(0);
		const offsetX = (0, import_vue$122.ref)(0);
		const offsetY = (0, import_vue$122.ref)(0);
		const direction = (0, import_vue$122.ref)("");
		const isTap = (0, import_vue$122.ref)(true);
		const isVertical = () => direction.value === "vertical";
		const isHorizontal = () => direction.value === "horizontal";
		const reset$1 = () => {
			deltaX.value = 0;
			deltaY.value = 0;
			offsetX.value = 0;
			offsetY.value = 0;
			direction.value = "";
			isTap.value = true;
		};
		const start$1 = (event) => {
			reset$1();
			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 > import_utils$214.TAP_OFFSET || offsetY.value > import_utils$214.TAP_OFFSET)) isTap.value = false;
		};
		return {
			move,
			start: start$1,
			reset: reset$1,
			startX,
			startY,
			deltaX,
			deltaY,
			offsetX,
			offsetY,
			direction,
			isVertical,
			isHorizontal,
			isTap
		};
	}
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-lock-scroll.js
var require_use_lock_scroll = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-lock-scroll.js": ((exports, module) => {
	var __defProp$231 = Object.defineProperty;
	var __getOwnPropDesc$231 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$231 = Object.getOwnPropertyNames;
	var __hasOwnProp$231 = Object.prototype.hasOwnProperty;
	var __export$231 = (target, all) => {
		for (var name$111 in all) __defProp$231(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$231 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$231(from)) if (!__hasOwnProp$231.call(to, key) && key !== except) __defProp$231(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$231(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$231 = (mod) => __copyProps$231(__defProp$231({}, "__esModule", { value: true }), mod);
	var stdin_exports$230 = {};
	__export$231(stdin_exports$230, { useLockScroll: () => useLockScroll });
	module.exports = __toCommonJS$231(stdin_exports$230);
	var import_vue$121 = require_vue();
	var import_use$62 = require_index_cjs$1();
	var import_use_touch$11 = require_use_touch();
	var import_utils$213 = require_utils$9();
	var totalLockCount = 0;
	var BODY_LOCK_CLASS = "van-overflow-hidden";
	function useLockScroll(rootRef, shouldLock) {
		const touch = (0, import_use_touch$11.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 } = (0, import_use$62.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))) (0, import_utils$213.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();
		(0, import_use$62.onMountedOrActivated)(init);
		(0, import_vue$121.onDeactivated)(destroy);
		(0, import_vue$121.onBeforeUnmount)(destroy);
		(0, import_vue$121.watch)(shouldLock, (value) => {
			value ? lock() : unlock();
		});
	}
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-lazy-render.js
var require_use_lazy_render = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-lazy-render.js": ((exports, module) => {
	var __defProp$230 = Object.defineProperty;
	var __getOwnPropDesc$230 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$230 = Object.getOwnPropertyNames;
	var __hasOwnProp$230 = Object.prototype.hasOwnProperty;
	var __export$230 = (target, all) => {
		for (var name$111 in all) __defProp$230(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$230 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$230(from)) if (!__hasOwnProp$230.call(to, key) && key !== except) __defProp$230(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$230(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$230 = (mod) => __copyProps$230(__defProp$230({}, "__esModule", { value: true }), mod);
	var stdin_exports$229 = {};
	__export$230(stdin_exports$229, { useLazyRender: () => useLazyRender });
	module.exports = __toCommonJS$230(stdin_exports$229);
	var import_vue$120 = require_vue();
	function useLazyRender(show) {
		const inited = (0, import_vue$120.ref)(false);
		(0, import_vue$120.watch)(show, (value) => {
			if (value) inited.value = value;
		}, { immediate: true });
		return (render) => () => inited.value ? render() : null;
	}
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-scope-id.js
var require_use_scope_id = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-scope-id.js": ((exports, module) => {
	var __defProp$229 = Object.defineProperty;
	var __getOwnPropDesc$229 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$229 = Object.getOwnPropertyNames;
	var __hasOwnProp$229 = Object.prototype.hasOwnProperty;
	var __export$229 = (target, all) => {
		for (var name$111 in all) __defProp$229(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$229 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$229(from)) if (!__hasOwnProp$229.call(to, key) && key !== except) __defProp$229(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$229(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$229 = (mod) => __copyProps$229(__defProp$229({}, "__esModule", { value: true }), mod);
	var stdin_exports$228 = {};
	__export$229(stdin_exports$228, { useScopeId: () => useScopeId });
	module.exports = __toCommonJS$229(stdin_exports$228);
	var import_vue$119 = require_vue();
	var useScopeId = () => {
		var _a;
		const { scopeId } = ((_a = (0, import_vue$119.getCurrentInstance)()) == null ? void 0 : _a.vnode) || {};
		return scopeId ? { [scopeId]: "" } : null;
	};
}) });

//#endregion
//#region node_modules/vant/lib/overlay/Overlay.js
var require_Overlay = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/overlay/Overlay.js": ((exports, module) => {
	var __defProp$228 = Object.defineProperty;
	var __getOwnPropDesc$228 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$228 = Object.getOwnPropertyNames;
	var __hasOwnProp$228 = Object.prototype.hasOwnProperty;
	var __export$228 = (target, all) => {
		for (var name2 in all) __defProp$228(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$228 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$228(from)) if (!__hasOwnProp$228.call(to, key) && key !== except) __defProp$228(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$228(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$228 = (mod) => __copyProps$228(__defProp$228({}, "__esModule", { value: true }), mod);
	var stdin_exports$227 = {};
	__export$228(stdin_exports$227, {
		default: () => stdin_default$202,
		overlayProps: () => overlayProps
	});
	module.exports = __toCommonJS$228(stdin_exports$227);
	var import_vue$118 = require_vue();
	var import_utils$212 = require_utils$9();
	var import_use$61 = require_index_cjs$1();
	var import_use_lazy_render$2 = require_use_lazy_render();
	var [name$102, bem$97] = (0, import_utils$212.createNamespace)("overlay");
	var overlayProps = {
		show: Boolean,
		zIndex: import_utils$212.numericProp,
		duration: import_utils$212.numericProp,
		className: import_utils$212.unknownProp,
		lockScroll: import_utils$212.truthProp,
		lazyRender: import_utils$212.truthProp,
		customStyle: Object,
		teleport: [String, Object]
	};
	var stdin_default$202 = (0, import_vue$118.defineComponent)({
		name: name$102,
		inheritAttrs: false,
		props: overlayProps,
		setup(props$1, { attrs, slots }) {
			const root = (0, import_vue$118.ref)();
			const lazyRender = (0, import_use_lazy_render$2.useLazyRender)(() => props$1.show || !props$1.lazyRender);
			const onTouchMove = (event) => {
				if (props$1.lockScroll) (0, import_utils$212.preventDefault)(event, true);
			};
			const renderOverlay = lazyRender(() => {
				var _a;
				const style = (0, import_utils$212.extend)((0, import_utils$212.getZIndexStyle)(props$1.zIndex), props$1.customStyle);
				if ((0, import_utils$212.isDef)(props$1.duration)) style.animationDuration = `${props$1.duration}s`;
				return (0, import_vue$118.withDirectives)((0, import_vue$118.createVNode)("div", (0, import_vue$118.mergeProps)({
					"ref": root,
					"style": style,
					"class": [bem$97(), props$1.className]
				}, attrs), [(_a = slots.default) == null ? void 0 : _a.call(slots)]), [[import_vue$118.vShow, props$1.show]]);
			});
			(0, import_use$61.useEventListener)("touchmove", onTouchMove, { target: root });
			return () => {
				const Content = (0, import_vue$118.createVNode)(import_vue$118.Transition, {
					"name": "van-fade",
					"appear": true
				}, { default: renderOverlay });
				if (props$1.teleport) return (0, import_vue$118.createVNode)(import_vue$118.Teleport, { "to": props$1.teleport }, { default: () => [Content] });
				return Content;
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/overlay/index.js
var require_overlay = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/overlay/index.js": ((exports, module) => {
	var __create$113 = Object.create;
	var __defProp$227 = Object.defineProperty;
	var __getOwnPropDesc$227 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$227 = Object.getOwnPropertyNames;
	var __getProtoOf$113 = Object.getPrototypeOf;
	var __hasOwnProp$227 = Object.prototype.hasOwnProperty;
	var __export$227 = (target, all) => {
		for (var name$111 in all) __defProp$227(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$227 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$227(from)) if (!__hasOwnProp$227.call(to, key) && key !== except) __defProp$227(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$227(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$113 = (mod, isNodeMode, target) => (target = mod != null ? __create$113(__getProtoOf$113(mod)) : {}, __copyProps$227(isNodeMode || !mod || !mod.__esModule ? __defProp$227(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$227 = (mod) => __copyProps$227(__defProp$227({}, "__esModule", { value: true }), mod);
	var stdin_exports$226 = {};
	__export$227(stdin_exports$226, {
		Overlay: () => Overlay,
		default: () => stdin_default$201,
		overlayProps: () => import_Overlay2.overlayProps
	});
	module.exports = __toCommonJS$227(stdin_exports$226);
	var import_utils$211 = require_utils$9();
	var import_Overlay = __toESM$113(require_Overlay());
	var import_Overlay2 = require_Overlay();
	var Overlay = (0, import_utils$211.withInstall)(import_Overlay.default);
	var stdin_default$201 = Overlay;
}) });

//#endregion
//#region node_modules/vant/lib/popup/Popup.js
var require_Popup = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/popup/Popup.js": ((exports, module) => {
	var __defProp$226 = Object.defineProperty;
	var __getOwnPropDesc$226 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$226 = Object.getOwnPropertyNames;
	var __hasOwnProp$226 = Object.prototype.hasOwnProperty;
	var __export$226 = (target, all) => {
		for (var name2 in all) __defProp$226(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$226 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$226(from)) if (!__hasOwnProp$226.call(to, key) && key !== except) __defProp$226(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$226(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$226 = (mod) => __copyProps$226(__defProp$226({}, "__esModule", { value: true }), mod);
	var stdin_exports$225 = {};
	__export$226(stdin_exports$225, {
		default: () => stdin_default$200,
		popupProps: () => popupProps$2
	});
	module.exports = __toCommonJS$226(stdin_exports$225);
	var import_vue$117 = require_vue();
	var import_shared$5 = require_shared();
	var import_utils$210 = require_utils$9();
	var import_use$60 = require_index_cjs$1();
	var import_use_expose$36 = require_use_expose();
	var import_use_lock_scroll$1 = require_use_lock_scroll();
	var import_use_lazy_render$1 = require_use_lazy_render();
	var import_on_popup_reopen$3 = require_on_popup_reopen();
	var import_use_global_z_index = require_use_global_z_index();
	var import_use_scope_id$2 = require_use_scope_id();
	var import_icon$29 = require_icon();
	var import_overlay$1 = require_overlay();
	var popupProps$2 = (0, import_utils$210.extend)({}, import_shared$5.popupSharedProps, {
		round: Boolean,
		position: (0, import_utils$210.makeStringProp)("center"),
		closeIcon: (0, import_utils$210.makeStringProp)("cross"),
		closeable: Boolean,
		transition: String,
		iconPrefix: String,
		closeOnPopstate: Boolean,
		closeIconPosition: (0, import_utils$210.makeStringProp)("top-right"),
		destroyOnClose: Boolean,
		safeAreaInsetTop: Boolean,
		safeAreaInsetBottom: Boolean
	});
	var [name$101, bem$96] = (0, import_utils$210.createNamespace)("popup");
	var stdin_default$200 = (0, import_vue$117.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 = (0, import_vue$117.ref)();
			const popupRef = (0, import_vue$117.ref)();
			const lazyRender = (0, import_use_lazy_render$1.useLazyRender)(() => props$1.show || !props$1.lazyRender);
			const style = (0, import_vue$117.computed)(() => {
				const style2 = { zIndex: zIndex.value };
				if ((0, import_utils$210.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 : (0, import_use_global_z_index.useGlobalZIndex)();
					emit("open");
				}
			};
			const close = () => {
				if (opened) (0, import_utils$210.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) {
					const overlayProps$1 = (0, import_utils$210.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);
					return (0, import_vue$117.createVNode)(import_overlay$1.Overlay, (0, import_vue$117.mergeProps)(overlayProps$1, (0, import_use_scope_id$2.useScopeId)(), { "onClick": onClickOverlay }), { default: slots["overlay-content"] });
				}
			};
			const onClickCloseIcon = (event) => {
				emit("clickCloseIcon", event);
				close();
			};
			const renderCloseIcon = () => {
				if (props$1.closeable) return (0, import_vue$117.createVNode)(import_icon$29.Icon, {
					"role": "button",
					"tabindex": 0,
					"name": props$1.closeIcon,
					"class": [bem$96("close-icon", props$1.closeIconPosition), import_utils$210.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 (0, import_vue$117.withDirectives)((0, import_vue$117.createVNode)("div", (0, import_vue$117.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, (0, import_use_scope_id$2.useScopeId)()), [(_a = slots.default) == null ? void 0 : _a.call(slots), renderCloseIcon()]), [[import_vue$117.vShow, show]]);
			});
			const renderTransition = () => {
				const { position, transition, transitionAppear } = props$1;
				const name2 = position === "center" ? "van-fade" : `van-popup-slide-${position}`;
				return (0, import_vue$117.createVNode)(import_vue$117.Transition, {
					"name": transition || name2,
					"appear": transitionAppear,
					"onAfterEnter": onOpened,
					"onAfterLeave": onClosed
				}, { default: renderPopup });
			};
			(0, import_vue$117.watch)(() => props$1.show, (show) => {
				if (show && !opened) {
					open();
					if (attrs.tabindex === 0) (0, import_vue$117.nextTick)(() => {
						var _a;
						(_a = popupRef.value) == null || _a.focus();
					});
				}
				if (!show && opened) {
					opened = false;
					emit("close");
				}
			});
			(0, import_use_expose$36.useExpose)({ popupRef });
			(0, import_use_lock_scroll$1.useLockScroll)(popupRef, () => props$1.show && props$1.lockScroll);
			(0, import_use$60.useEventListener)("popstate", () => {
				if (props$1.closeOnPopstate) {
					close();
					shouldReopen = false;
				}
			});
			(0, import_vue$117.onMounted)(() => {
				if (props$1.show) open();
			});
			(0, import_vue$117.onActivated)(() => {
				if (shouldReopen) {
					emit("update:show", true);
					shouldReopen = false;
				}
			});
			(0, import_vue$117.onDeactivated)(() => {
				if (props$1.show && props$1.teleport) {
					close();
					shouldReopen = true;
				}
			});
			(0, import_vue$117.provide)(import_on_popup_reopen$3.POPUP_TOGGLE_KEY, () => props$1.show);
			return () => {
				if (props$1.teleport) return (0, import_vue$117.createVNode)(import_vue$117.Teleport, { "to": props$1.teleport }, { default: () => [renderOverlay(), renderTransition()] });
				return (0, import_vue$117.createVNode)(import_vue$117.Fragment, null, [renderOverlay(), renderTransition()]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/popup/index.js
var require_popup = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/popup/index.js": ((exports, module) => {
	var __create$112 = Object.create;
	var __defProp$225 = Object.defineProperty;
	var __getOwnPropDesc$225 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$225 = Object.getOwnPropertyNames;
	var __getProtoOf$112 = Object.getPrototypeOf;
	var __hasOwnProp$225 = Object.prototype.hasOwnProperty;
	var __export$225 = (target, all) => {
		for (var name$111 in all) __defProp$225(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$225 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$225(from)) if (!__hasOwnProp$225.call(to, key) && key !== except) __defProp$225(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$225(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$112 = (mod, isNodeMode, target) => (target = mod != null ? __create$112(__getProtoOf$112(mod)) : {}, __copyProps$225(isNodeMode || !mod || !mod.__esModule ? __defProp$225(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$225 = (mod) => __copyProps$225(__defProp$225({}, "__esModule", { value: true }), mod);
	var stdin_exports$224 = {};
	__export$225(stdin_exports$224, {
		Popup: () => Popup,
		default: () => stdin_default$199,
		popupProps: () => import_Popup2.popupProps
	});
	module.exports = __toCommonJS$225(stdin_exports$224);
	var import_utils$209 = require_utils$9();
	var import_Popup = __toESM$112(require_Popup());
	var import_Popup2 = require_Popup();
	var Popup = (0, import_utils$209.withInstall)(import_Popup.default);
	var stdin_default$199 = Popup;
}) });

//#endregion
//#region node_modules/vant/lib/action-sheet/ActionSheet.js
var require_ActionSheet = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/action-sheet/ActionSheet.js": ((exports, module) => {
	var __defProp$224 = Object.defineProperty;
	var __getOwnPropDesc$224 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$224 = Object.getOwnPropertyNames;
	var __hasOwnProp$224 = Object.prototype.hasOwnProperty;
	var __export$224 = (target, all) => {
		for (var name2 in all) __defProp$224(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$224 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$224(from)) if (!__hasOwnProp$224.call(to, key) && key !== except) __defProp$224(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$224(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$224 = (mod) => __copyProps$224(__defProp$224({}, "__esModule", { value: true }), mod);
	var stdin_exports$223 = {};
	__export$224(stdin_exports$223, {
		actionSheetProps: () => actionSheetProps,
		default: () => stdin_default$198
	});
	module.exports = __toCommonJS$224(stdin_exports$223);
	var import_vue$116 = require_vue();
	var import_utils$208 = require_utils$9();
	var import_icon$28 = require_icon();
	var import_popup$10 = require_popup();
	var import_loading$9 = require_loading();
	var import_shared$4 = require_shared();
	var [name$100, bem$95] = (0, import_utils$208.createNamespace)("action-sheet");
	var actionSheetProps = (0, import_utils$208.extend)({}, import_shared$4.popupSharedProps, {
		title: String,
		round: import_utils$208.truthProp,
		actions: (0, import_utils$208.makeArrayProp)(),
		closeIcon: (0, import_utils$208.makeStringProp)("cross"),
		closeable: import_utils$208.truthProp,
		cancelText: String,
		description: String,
		closeOnPopstate: import_utils$208.truthProp,
		closeOnClickAction: Boolean,
		safeAreaInsetBottom: import_utils$208.truthProp
	});
	var popupInheritKeys$2 = [
		...import_shared$4.popupSharedPropKeys,
		"round",
		"closeOnPopstate",
		"safeAreaInsetBottom"
	];
	var stdin_default$198 = (0, import_vue$116.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 (0, import_vue$116.createVNode)("div", { "class": bem$95("header") }, [props$1.title, props$1.closeable && (0, import_vue$116.createVNode)(import_icon$28.Icon, {
					"name": props$1.closeIcon,
					"class": [bem$95("close"), import_utils$208.HAPTICS_FEEDBACK],
					"onClick": onCancel
				}, null)]);
			};
			const renderCancel = () => {
				if (slots.cancel || props$1.cancelText) return [(0, import_vue$116.createVNode)("div", { "class": bem$95("gap") }, null), (0, import_vue$116.createVNode)("button", {
					"type": "button",
					"class": bem$95("cancel"),
					"onClick": onCancel
				}, [slots.cancel ? slots.cancel() : props$1.cancelText])];
			};
			const renderIcon = (action) => {
				if (action.icon) return (0, import_vue$116.createVNode)(import_icon$28.Icon, {
					"class": bem$95("item-icon"),
					"name": action.icon
				}, null);
			};
			const renderActionContent = (action, index) => {
				if (action.loading) return (0, import_vue$116.createVNode)(import_loading$9.Loading, { "class": bem$95("loading-icon") }, null);
				if (slots.action) return slots.action({
					action,
					index
				});
				return [(0, import_vue$116.createVNode)("span", { "class": bem$95("name") }, [action.name]), action.subname && (0, import_vue$116.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);
					(0, import_vue$116.nextTick)(() => emit("select", action, index));
				};
				return (0, import_vue$116.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 (0, import_vue$116.createVNode)("div", { "class": bem$95("description") }, [content]);
				}
			};
			return () => (0, import_vue$116.createVNode)(import_popup$10.Popup, (0, import_vue$116.mergeProps)({
				"class": bem$95(),
				"position": "bottom",
				"onUpdate:show": updateShow
			}, (0, import_utils$208.pick)(props$1, popupInheritKeys$2)), { default: () => {
				var _a;
				return [
					renderHeader(),
					renderDescription(),
					(0, import_vue$116.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/lib/action-sheet/index.js
var require_action_sheet = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/action-sheet/index.js": ((exports, module) => {
	var __create$111 = Object.create;
	var __defProp$223 = Object.defineProperty;
	var __getOwnPropDesc$223 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$223 = Object.getOwnPropertyNames;
	var __getProtoOf$111 = Object.getPrototypeOf;
	var __hasOwnProp$223 = Object.prototype.hasOwnProperty;
	var __export$223 = (target, all) => {
		for (var name$111 in all) __defProp$223(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$223 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$223(from)) if (!__hasOwnProp$223.call(to, key) && key !== except) __defProp$223(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$223(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$111 = (mod, isNodeMode, target) => (target = mod != null ? __create$111(__getProtoOf$111(mod)) : {}, __copyProps$223(isNodeMode || !mod || !mod.__esModule ? __defProp$223(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$223 = (mod) => __copyProps$223(__defProp$223({}, "__esModule", { value: true }), mod);
	var stdin_exports$222 = {};
	__export$223(stdin_exports$222, {
		ActionSheet: () => ActionSheet,
		actionSheetProps: () => import_ActionSheet2.actionSheetProps,
		default: () => stdin_default$197
	});
	module.exports = __toCommonJS$223(stdin_exports$222);
	var import_utils$207 = require_utils$9();
	var import_ActionSheet = __toESM$111(require_ActionSheet());
	var import_ActionSheet2 = require_ActionSheet();
	var ActionSheet = (0, import_utils$207.withInstall)(import_ActionSheet.default);
	var stdin_default$197 = ActionSheet;
}) });

//#endregion
//#region node_modules/vant/lib/picker/utils.js
var require_utils$8 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/picker/utils.js": ((exports, module) => {
	var __defProp$222 = Object.defineProperty;
	var __getOwnPropDesc$222 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$222 = Object.getOwnPropertyNames;
	var __hasOwnProp$222 = Object.prototype.hasOwnProperty;
	var __export$222 = (target, all) => {
		for (var name2 in all) __defProp$222(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$222 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$222(from)) if (!__hasOwnProp$222.call(to, key) && key !== except) __defProp$222(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$222(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$222 = (mod) => __copyProps$222(__defProp$222({}, "__esModule", { value: true }), mod);
	var stdin_exports$221 = {};
	__export$222(stdin_exports$221, {
		assignDefaultFields: () => assignDefaultFields,
		bem: () => bem$94,
		findIndexOfEnabledOption: () => findIndexOfEnabledOption,
		findOptionByValue: () => findOptionByValue,
		formatCascadeColumns: () => formatCascadeColumns,
		getColumnsType: () => getColumnsType,
		getElementTranslateY: () => getElementTranslateY,
		getFirstEnabledOption: () => getFirstEnabledOption,
		isOptionExist: () => isOptionExist,
		name: () => name$99,
		t: () => t$20
	});
	module.exports = __toCommonJS$222(stdin_exports$221);
	var import_utils$206 = require_utils$9();
	var [name$99, bem$94, t$20] = (0, import_utils$206.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 = (0, import_utils$206.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 = (0, import_utils$206.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: transform$1 } = window.getComputedStyle(element);
		const translateY = transform$1.slice(7, transform$1.length - 1).split(", ")[5];
		return Number(translateY);
	}
	function assignDefaultFields(fields) {
		return (0, import_utils$206.extend)({
			text: "text",
			value: "value",
			children: "children"
		}, fields);
	}
}) });

//#endregion
//#region node_modules/vant/lib/picker/PickerColumn.js
var require_PickerColumn = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/picker/PickerColumn.js": ((exports, module) => {
	var __defProp$221 = Object.defineProperty;
	var __getOwnPropDesc$221 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$221 = Object.getOwnPropertyNames;
	var __hasOwnProp$221 = Object.prototype.hasOwnProperty;
	var __export$221 = (target, all) => {
		for (var name2 in all) __defProp$221(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$221 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$221(from)) if (!__hasOwnProp$221.call(to, key) && key !== except) __defProp$221(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$221(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$221 = (mod) => __copyProps$221(__defProp$221({}, "__esModule", { value: true }), mod);
	var stdin_exports$220 = {};
	__export$221(stdin_exports$220, {
		PICKER_KEY: () => PICKER_KEY,
		default: () => stdin_default$196
	});
	module.exports = __toCommonJS$221(stdin_exports$220);
	var import_vue$115 = require_vue();
	var import_utils$205 = require_utils$9();
	var import_utils2$16 = require_utils$8();
	var import_use$59 = require_index_cjs$1();
	var import_use_touch$10 = require_use_touch();
	var import_use_expose$35 = require_use_expose();
	var DEFAULT_DURATION = 200;
	var MOMENTUM_TIME = 300;
	var MOMENTUM_DISTANCE = 15;
	var [name$98, bem$93] = (0, import_utils$205.createNamespace)("picker-column");
	var PICKER_KEY = Symbol(name$98);
	var stdin_default$196 = (0, import_vue$115.defineComponent)({
		name: name$98,
		props: {
			value: import_utils$205.numericProp,
			fields: (0, import_utils$205.makeRequiredProp)(Object),
			options: (0, import_utils$205.makeArrayProp)(),
			readonly: Boolean,
			allowHtml: Boolean,
			optionHeight: (0, import_utils$205.makeRequiredProp)(Number),
			swipeDuration: (0, import_utils$205.makeRequiredProp)(import_utils$205.numericProp),
			visibleOptionNum: (0, import_utils$205.makeRequiredProp)(import_utils$205.numericProp)
		},
		emits: [
			"change",
			"clickOption",
			"scrollInto"
		],
		setup(props$1, { emit, slots }) {
			let moving;
			let startOffset;
			let touchStartTime;
			let momentumOffset;
			let transitionEndTrigger;
			const root = (0, import_vue$115.ref)();
			const wrapper = (0, import_vue$115.ref)();
			const currentOffset = (0, import_vue$115.ref)(0);
			const currentDuration = (0, import_vue$115.ref)(0);
			const touch = (0, import_use_touch$10.useTouch)();
			const count = () => props$1.options.length;
			const baseOffset = () => props$1.optionHeight * (+props$1.visibleOptionNum - 1) / 2;
			const updateValueByIndex = (index) => {
				let enabledIndex = (0, import_utils2$16.findIndexOfEnabledOption)(props$1.options, index);
				const offset$1 = -enabledIndex * props$1.optionHeight;
				const trigger = () => {
					if (enabledIndex > count() - 1) enabledIndex = (0, import_utils2$16.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) => (0, import_utils$205.clamp)(Math.round(-offset$1 / props$1.optionHeight), 0, count() - 1);
			const currentIndex = (0, import_vue$115.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 = (0, import_utils2$16.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;
					(0, import_utils$205.preventDefault)(event, true);
				}
				const newOffset = (0, import_utils$205.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$93("item", {
							disabled,
							selected: value === props$1.value
						}), option.className],
						onClick: () => onClickOption(index)
					};
					const childData = {
						class: "van-ellipsis",
						[props$1.allowHtml ? "innerHTML" : "textContent"]: text
					};
					return (0, import_vue$115.createVNode)("li", data, [slots.option ? slots.option(option, index) : (0, import_vue$115.createVNode)("div", childData, null)]);
				});
			};
			(0, import_use$59.useParent)(PICKER_KEY);
			(0, import_use_expose$35.useExpose)({ stopMomentum });
			(0, import_vue$115.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 = (0, import_utils2$16.findIndexOfEnabledOption)(props$1.options, index);
				const offset$1 = -enabledIndex * props$1.optionHeight;
				if (moving && enabledIndex < index) stopMomentum();
				currentOffset.value = offset$1;
			});
			(0, import_use$59.useEventListener)("touchmove", onTouchMove, { target: root });
			return () => (0, import_vue$115.createVNode)("div", {
				"ref": root,
				"class": bem$93(),
				"onTouchstartPassive": onTouchStart,
				"onTouchend": onTouchEnd,
				"onTouchcancel": onTouchEnd
			}, [(0, import_vue$115.createVNode)("ul", {
				"ref": wrapper,
				"style": {
					transform: `translate3d(0, ${currentOffset.value + baseOffset()}px, 0)`,
					transitionDuration: `${currentDuration.value}ms`,
					transitionProperty: currentDuration.value ? "all" : "none"
				},
				"class": bem$93("wrapper"),
				"onTransitionend": stopMomentum
			}, [renderOptions()])]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/picker/PickerToolbar.js
var require_PickerToolbar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/picker/PickerToolbar.js": ((exports, module) => {
	var __defProp$220 = Object.defineProperty;
	var __getOwnPropDesc$220 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$220 = Object.getOwnPropertyNames;
	var __hasOwnProp$220 = Object.prototype.hasOwnProperty;
	var __export$220 = (target, all) => {
		for (var name2 in all) __defProp$220(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$220 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$220(from)) if (!__hasOwnProp$220.call(to, key) && key !== except) __defProp$220(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$220(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$220 = (mod) => __copyProps$220(__defProp$220({}, "__esModule", { value: true }), mod);
	var stdin_exports$219 = {};
	__export$220(stdin_exports$219, {
		default: () => stdin_default$195,
		pickerToolbarPropKeys: () => pickerToolbarPropKeys,
		pickerToolbarProps: () => pickerToolbarProps,
		pickerToolbarSlots: () => pickerToolbarSlots
	});
	module.exports = __toCommonJS$220(stdin_exports$219);
	var import_vue$114 = require_vue();
	var import_utils$204 = require_utils$8();
	var import_utils2$15 = require_utils$9();
	var [name$97] = (0, import_utils2$15.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$195 = (0, import_vue$114.defineComponent)({
		name: name$97,
		props: pickerToolbarProps,
		emits: ["confirm", "cancel"],
		setup(props$1, { emit, slots }) {
			const renderTitle = () => {
				if (slots.title) return slots.title();
				if (props$1.title) return (0, import_vue$114.createVNode)("div", { "class": [(0, import_utils$204.bem)("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 : (0, import_utils$204.t)("cancel");
				if (!slots.cancel && !text) return;
				return (0, import_vue$114.createVNode)("button", {
					"type": "button",
					"class": [(0, import_utils$204.bem)("cancel"), import_utils2$15.HAPTICS_FEEDBACK],
					"onClick": onCancel
				}, [slots.cancel ? slots.cancel() : text]);
			};
			const renderConfirm = () => {
				var _a;
				const text = (_a = props$1.confirmButtonText) != null ? _a : (0, import_utils$204.t)("confirm");
				if (!slots.confirm && !text) return;
				return (0, import_vue$114.createVNode)("button", {
					"type": "button",
					"class": [(0, import_utils$204.bem)("confirm"), import_utils2$15.HAPTICS_FEEDBACK],
					"onClick": onConfirm
				}, [slots.confirm ? slots.confirm() : text]);
			};
			return () => (0, import_vue$114.createVNode)("div", { "class": (0, import_utils$204.bem)("toolbar") }, [slots.toolbar ? slots.toolbar() : [
				renderCancel(),
				renderTitle(),
				renderConfirm()
			]]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-sync-prop-ref.js
var require_use_sync_prop_ref = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-sync-prop-ref.js": ((exports, module) => {
	var __defProp$219 = Object.defineProperty;
	var __getOwnPropDesc$219 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$219 = Object.getOwnPropertyNames;
	var __hasOwnProp$219 = Object.prototype.hasOwnProperty;
	var __export$219 = (target, all) => {
		for (var name$111 in all) __defProp$219(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$219 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$219(from)) if (!__hasOwnProp$219.call(to, key) && key !== except) __defProp$219(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$219(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$219 = (mod) => __copyProps$219(__defProp$219({}, "__esModule", { value: true }), mod);
	var stdin_exports$218 = {};
	__export$219(stdin_exports$218, { useSyncPropRef: () => useSyncPropRef });
	module.exports = __toCommonJS$219(stdin_exports$218);
	var import_vue$113 = require_vue();
	var useSyncPropRef = (getProp, setProp) => {
		const propRef = (0, import_vue$113.ref)(getProp());
		(0, import_vue$113.watch)(getProp, (value) => {
			if (value !== propRef.value) propRef.value = value;
		});
		(0, import_vue$113.watch)(propRef, (value) => {
			if (value !== getProp()) setProp(value);
		});
		return propRef;
	};
}) });

//#endregion
//#region node_modules/vant/lib/tabs/utils.js
var require_utils$7 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tabs/utils.js": ((exports, module) => {
	var __defProp$218 = Object.defineProperty;
	var __getOwnPropDesc$218 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$218 = Object.getOwnPropertyNames;
	var __hasOwnProp$218 = Object.prototype.hasOwnProperty;
	var __export$218 = (target, all) => {
		for (var name$111 in all) __defProp$218(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$218 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$218(from)) if (!__hasOwnProp$218.call(to, key) && key !== except) __defProp$218(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$218(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$218 = (mod) => __copyProps$218(__defProp$218({}, "__esModule", { value: true }), mod);
	var stdin_exports$217 = {};
	__export$218(stdin_exports$217, {
		scrollLeftTo: () => scrollLeftTo,
		scrollTopTo: () => scrollTopTo
	});
	module.exports = __toCommonJS$218(stdin_exports$217);
	var import_use$58 = require_index_cjs$1();
	var import_utils$203 = require_utils$9();
	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() {
			(0, import_use$58.cancelRaf)(rafId);
		}
		function animate() {
			scrollLeft += (to - from) / frames;
			scroller.scrollLeft = scrollLeft;
			if (++count < frames) rafId = (0, import_use$58.raf)(animate);
		}
		animate();
		return cancel;
	}
	function scrollTopTo(scroller, to, duration, callback) {
		let rafId;
		let current$1 = (0, import_utils$203.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() {
			(0, import_use$58.cancelRaf)(rafId);
		}
		function animate() {
			current$1 += step;
			if (isDown && current$1 > to || !isDown && current$1 < to) current$1 = to;
			(0, import_utils$203.setScrollTop)(scroller, current$1);
			if (isDown && current$1 < to || !isDown && current$1 > to) rafId = (0, import_use$58.raf)(animate);
			else if (callback) rafId = (0, import_use$58.raf)(callback);
		}
		animate();
		return cancel;
	}
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-id.js
var require_use_id = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-id.js": ((exports, module) => {
	var __defProp$217 = Object.defineProperty;
	var __getOwnPropDesc$217 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$217 = Object.getOwnPropertyNames;
	var __hasOwnProp$217 = Object.prototype.hasOwnProperty;
	var __export$217 = (target, all) => {
		for (var name$111 in all) __defProp$217(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$217 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$217(from)) if (!__hasOwnProp$217.call(to, key) && key !== except) __defProp$217(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$217(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$217 = (mod) => __copyProps$217(__defProp$217({}, "__esModule", { value: true }), mod);
	var stdin_exports$216 = {};
	__export$217(stdin_exports$216, { useId: () => useId });
	module.exports = __toCommonJS$217(stdin_exports$216);
	var import_vue$112 = require_vue();
	var current = 0;
	function useId() {
		const vm = (0, import_vue$112.getCurrentInstance)();
		const { name: name$111 = "unknown" } = (vm == null ? void 0 : vm.type) || {};
		return `${name$111}-${++current}`;
	}
}) });

//#endregion
//#region node_modules/vant/lib/composables/use-refs.js
var require_use_refs = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-refs.js": ((exports, module) => {
	var __defProp$216 = Object.defineProperty;
	var __getOwnPropDesc$216 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$216 = Object.getOwnPropertyNames;
	var __hasOwnProp$216 = Object.prototype.hasOwnProperty;
	var __export$216 = (target, all) => {
		for (var name$111 in all) __defProp$216(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$216 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$216(from)) if (!__hasOwnProp$216.call(to, key) && key !== except) __defProp$216(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$216(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$216 = (mod) => __copyProps$216(__defProp$216({}, "__esModule", { value: true }), mod);
	var stdin_exports$215 = {};
	__export$216(stdin_exports$215, { useRefs: () => useRefs });
	module.exports = __toCommonJS$216(stdin_exports$215);
	var import_vue$111 = require_vue();
	function useRefs() {
		const refs = (0, import_vue$111.ref)([]);
		const cache = [];
		(0, import_vue$111.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/lib/composables/use-visibility-change.js
var require_use_visibility_change = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-visibility-change.js": ((exports, module) => {
	var __defProp$215 = Object.defineProperty;
	var __getOwnPropDesc$215 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$215 = Object.getOwnPropertyNames;
	var __hasOwnProp$215 = Object.prototype.hasOwnProperty;
	var __export$215 = (target, all) => {
		for (var name$111 in all) __defProp$215(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$215 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$215(from)) if (!__hasOwnProp$215.call(to, key) && key !== except) __defProp$215(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$215(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$215 = (mod) => __copyProps$215(__defProp$215({}, "__esModule", { value: true }), mod);
	var stdin_exports$214 = {};
	__export$215(stdin_exports$214, { useVisibilityChange: () => useVisibilityChange });
	module.exports = __toCommonJS$215(stdin_exports$214);
	var import_utils$202 = require_utils$9();
	var import_vue$110 = require_vue();
	var import_use$57 = require_index_cjs$1();
	function useVisibilityChange(target, onChange) {
		if (!import_utils$202.inBrowser || !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);
		};
		(0, import_vue$110.onDeactivated)(unobserve);
		(0, import_vue$110.onBeforeUnmount)(unobserve);
		(0, import_use$57.onMountedOrActivated)(observe);
	}
}) });

//#endregion
//#region node_modules/vant/lib/sticky/Sticky.js
var require_Sticky = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/sticky/Sticky.js": ((exports, module) => {
	var __defProp$214 = Object.defineProperty;
	var __getOwnPropDesc$214 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$214 = Object.getOwnPropertyNames;
	var __hasOwnProp$214 = Object.prototype.hasOwnProperty;
	var __export$214 = (target, all) => {
		for (var name2 in all) __defProp$214(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$214 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$214(from)) if (!__hasOwnProp$214.call(to, key) && key !== except) __defProp$214(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$214(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$214 = (mod) => __copyProps$214(__defProp$214({}, "__esModule", { value: true }), mod);
	var stdin_exports$213 = {};
	__export$214(stdin_exports$213, {
		default: () => stdin_default$194,
		stickyProps: () => stickyProps
	});
	module.exports = __toCommonJS$214(stdin_exports$213);
	var import_vue$109 = require_vue();
	var import_utils$201 = require_utils$9();
	var import_use$56 = require_index_cjs$1();
	var import_use_visibility_change$1 = require_use_visibility_change();
	var [name$96, bem$92] = (0, import_utils$201.createNamespace)("sticky");
	var stickyProps = {
		zIndex: import_utils$201.numericProp,
		position: (0, import_utils$201.makeStringProp)("top"),
		container: Object,
		offsetTop: (0, import_utils$201.makeNumericProp)(0),
		offsetBottom: (0, import_utils$201.makeNumericProp)(0)
	};
	var stdin_default$194 = (0, import_vue$109.defineComponent)({
		name: name$96,
		props: stickyProps,
		emits: ["scroll", "change"],
		setup(props$1, { emit, slots }) {
			const root = (0, import_vue$109.ref)();
			const scrollParent = (0, import_use$56.useScrollParent)(root);
			const state = (0, import_vue$109.reactive)({
				fixed: false,
				width: 0,
				height: 0,
				transform: 0
			});
			const isReset = (0, import_vue$109.ref)(false);
			const offset$1 = (0, import_vue$109.computed)(() => (0, import_utils$201.unitToPx)(props$1.position === "top" ? props$1.offsetTop : props$1.offsetBottom));
			const rootStyle = (0, import_vue$109.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 = (0, import_vue$109.computed)(() => {
				if (!state.fixed || isReset.value) return;
				const style = (0, import_utils$201.extend)((0, import_utils$201.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 || (0, import_utils$201.isHidden)(root)) return;
				const { container, position } = props$1;
				const rootRect = (0, import_use$56.useRect)(root);
				const scrollTop = (0, import_utils$201.getScrollTop)(window);
				state.width = rootRect.width;
				state.height = rootRect.height;
				if (position === "top") if (container) {
					const containerRect = (0, import_use$56.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 = (0, import_use$56.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);
			};
			(0, import_vue$109.watch)(() => state.fixed, (value) => emit("change", value));
			(0, import_use$56.useEventListener)("scroll", onScroll, {
				target: scrollParent,
				passive: true
			});
			(0, import_use_visibility_change$1.useVisibilityChange)(root, onScroll);
			(0, import_vue$109.watch)([import_utils$201.windowWidth, import_utils$201.windowHeight], () => {
				if (!root.value || (0, import_utils$201.isHidden)(root) || !state.fixed) return;
				isReset.value = true;
				(0, import_vue$109.nextTick)(() => {
					const rootRect = (0, import_use$56.useRect)(root);
					state.width = rootRect.width;
					state.height = rootRect.height;
					isReset.value = false;
				});
			});
			return () => {
				var _a;
				return (0, import_vue$109.createVNode)("div", {
					"ref": root,
					"style": rootStyle.value
				}, [(0, import_vue$109.createVNode)("div", {
					"class": bem$92({ fixed: state.fixed && !isReset.value }),
					"style": stickyStyle.value
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/sticky/index.js
var require_sticky = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/sticky/index.js": ((exports, module) => {
	var __create$110 = Object.create;
	var __defProp$213 = Object.defineProperty;
	var __getOwnPropDesc$213 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$213 = Object.getOwnPropertyNames;
	var __getProtoOf$110 = Object.getPrototypeOf;
	var __hasOwnProp$213 = Object.prototype.hasOwnProperty;
	var __export$213 = (target, all) => {
		for (var name$111 in all) __defProp$213(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$213 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$213(from)) if (!__hasOwnProp$213.call(to, key) && key !== except) __defProp$213(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$213(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$110 = (mod, isNodeMode, target) => (target = mod != null ? __create$110(__getProtoOf$110(mod)) : {}, __copyProps$213(isNodeMode || !mod || !mod.__esModule ? __defProp$213(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$213 = (mod) => __copyProps$213(__defProp$213({}, "__esModule", { value: true }), mod);
	var stdin_exports$212 = {};
	__export$213(stdin_exports$212, {
		Sticky: () => Sticky,
		default: () => stdin_default$193,
		stickyProps: () => import_Sticky2.stickyProps
	});
	module.exports = __toCommonJS$213(stdin_exports$212);
	var import_utils$200 = require_utils$9();
	var import_Sticky = __toESM$110(require_Sticky());
	var import_Sticky2 = require_Sticky();
	var Sticky = (0, import_utils$200.withInstall)(import_Sticky.default);
	var stdin_default$193 = Sticky;
}) });

//#endregion
//#region node_modules/vant/lib/swipe/Swipe.js
var require_Swipe = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/swipe/Swipe.js": ((exports, module) => {
	var __defProp$212 = Object.defineProperty;
	var __getOwnPropDesc$212 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$212 = Object.getOwnPropertyNames;
	var __hasOwnProp$212 = Object.prototype.hasOwnProperty;
	var __export$212 = (target, all) => {
		for (var name2 in all) __defProp$212(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$212 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$212(from)) if (!__hasOwnProp$212.call(to, key) && key !== except) __defProp$212(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$212(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$212 = (mod) => __copyProps$212(__defProp$212({}, "__esModule", { value: true }), mod);
	var stdin_exports$211 = {};
	__export$212(stdin_exports$211, {
		SWIPE_KEY: () => SWIPE_KEY,
		default: () => stdin_default$192,
		swipeProps: () => swipeProps
	});
	module.exports = __toCommonJS$212(stdin_exports$211);
	var import_vue$108 = require_vue();
	var import_utils$199 = require_utils$9();
	var import_use$55 = require_index_cjs$1();
	var import_use_touch$9 = require_use_touch();
	var import_use_expose$34 = require_use_expose();
	var import_on_popup_reopen$2 = require_on_popup_reopen();
	var [name$95, bem$91] = (0, import_utils$199.createNamespace)("swipe");
	var swipeProps = {
		loop: import_utils$199.truthProp,
		width: import_utils$199.numericProp,
		height: import_utils$199.numericProp,
		vertical: Boolean,
		autoplay: (0, import_utils$199.makeNumericProp)(0),
		duration: (0, import_utils$199.makeNumericProp)(500),
		touchable: import_utils$199.truthProp,
		lazyRender: Boolean,
		initialSwipe: (0, import_utils$199.makeNumericProp)(0),
		indicatorColor: String,
		showIndicators: import_utils$199.truthProp,
		stopPropagation: import_utils$199.truthProp
	};
	var SWIPE_KEY = Symbol(name$95);
	var stdin_default$192 = (0, import_vue$108.defineComponent)({
		name: name$95,
		props: swipeProps,
		emits: [
			"change",
			"dragStart",
			"dragEnd"
		],
		setup(props$1, { emit, slots }) {
			const root = (0, import_vue$108.ref)();
			const track = (0, import_vue$108.ref)();
			const state = (0, import_vue$108.reactive)({
				rect: null,
				width: 0,
				height: 0,
				offset: 0,
				active: 0,
				swiping: false
			});
			let dragging = false;
			const touch = (0, import_use_touch$9.useTouch)();
			const { children, linkChildren } = (0, import_use$55.useChildren)(SWIPE_KEY);
			const count = (0, import_vue$108.computed)(() => children.length);
			const size = (0, import_vue$108.computed)(() => state[props$1.vertical ? "height" : "width"]);
			const delta = (0, import_vue$108.computed)(() => props$1.vertical ? touch.deltaY.value : touch.deltaX.value);
			const minOffset = (0, import_vue$108.computed)(() => {
				if (state.rect) return (props$1.vertical ? state.rect.height : state.rect.width) - size.value * count.value;
				return 0;
			});
			const maxCount = (0, import_vue$108.computed)(() => size.value ? Math.ceil(Math.abs(minOffset.value) / size.value) : count.value);
			const trackSize = (0, import_vue$108.computed)(() => count.value * size.value);
			const activeIndicator = (0, import_vue$108.computed)(() => (state.active + count.value) % count.value);
			const isCorrectDirection = (0, import_vue$108.computed)(() => {
				const expect = props$1.vertical ? "vertical" : "horizontal";
				return touch.direction.value === expect;
			});
			const trackStyle = (0, import_vue$108.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 (0, import_utils$199.clamp)(active + pace, -1, count.value);
					return (0, import_utils$199.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 = (0, import_utils$199.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();
				(0, import_use$55.doubleRaf)(() => {
					state.swiping = false;
					move({
						pace: -1,
						emitChange: true
					});
				});
			};
			const next = () => {
				correctPosition();
				touch.reset();
				(0, import_use$55.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 (!(0, import_utils$199.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 ((0, import_utils$199.isHidden)(root)) (0, import_vue$108.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))) {
							(0, import_utils$199.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();
				(0, import_use$55.doubleRaf)(() => {
					let targetIndex;
					if (props$1.loop && index === count.value) targetIndex = state.active === 0 ? 0 : index;
					else targetIndex = index % count.value;
					if (options.immediate) (0, import_use$55.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 (0, import_vue$108.createVNode)("i", {
					"style": style,
					"class": bem$91("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 (0, import_vue$108.createVNode)("div", { "class": bem$91("indicators", { vertical: props$1.vertical }) }, [Array(count.value).fill("").map(renderDot)]);
			};
			(0, import_use_expose$34.useExpose)({
				prev,
				next,
				state,
				resize,
				swipeTo
			});
			linkChildren({
				size,
				props: props$1,
				count,
				activeIndicator
			});
			(0, import_vue$108.watch)(() => props$1.initialSwipe, (value) => initialize(+value));
			(0, import_vue$108.watch)(count, () => initialize(state.active));
			(0, import_vue$108.watch)(() => props$1.autoplay, autoplay);
			(0, import_vue$108.watch)([
				import_utils$199.windowWidth,
				import_utils$199.windowHeight,
				() => props$1.width,
				() => props$1.height
			], resize);
			(0, import_vue$108.watch)((0, import_use$55.usePageVisibility)(), (visible) => {
				if (visible === "visible") autoplay();
				else stopAutoplay();
			});
			(0, import_vue$108.onMounted)(initialize);
			(0, import_vue$108.onActivated)(() => initialize(state.active));
			(0, import_on_popup_reopen$2.onPopupReopen)(() => initialize(state.active));
			(0, import_vue$108.onDeactivated)(stopAutoplay);
			(0, import_vue$108.onBeforeUnmount)(stopAutoplay);
			(0, import_use$55.useEventListener)("touchmove", onTouchMove, { target: track });
			return () => {
				var _a;
				return (0, import_vue$108.createVNode)("div", {
					"ref": root,
					"class": bem$91()
				}, [(0, import_vue$108.createVNode)("div", {
					"ref": track,
					"style": trackStyle.value,
					"class": bem$91("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/lib/swipe/index.js
var require_swipe = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/swipe/index.js": ((exports, module) => {
	var __create$109 = Object.create;
	var __defProp$211 = Object.defineProperty;
	var __getOwnPropDesc$211 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$211 = Object.getOwnPropertyNames;
	var __getProtoOf$109 = Object.getPrototypeOf;
	var __hasOwnProp$211 = Object.prototype.hasOwnProperty;
	var __export$211 = (target, all) => {
		for (var name$111 in all) __defProp$211(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$211 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$211(from)) if (!__hasOwnProp$211.call(to, key) && key !== except) __defProp$211(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$211(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$109 = (mod, isNodeMode, target) => (target = mod != null ? __create$109(__getProtoOf$109(mod)) : {}, __copyProps$211(isNodeMode || !mod || !mod.__esModule ? __defProp$211(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$211 = (mod) => __copyProps$211(__defProp$211({}, "__esModule", { value: true }), mod);
	var stdin_exports$210 = {};
	__export$211(stdin_exports$210, {
		Swipe: () => Swipe,
		default: () => stdin_default$191,
		swipeProps: () => import_Swipe2.swipeProps
	});
	module.exports = __toCommonJS$211(stdin_exports$210);
	var import_utils$198 = require_utils$9();
	var import_Swipe$1 = __toESM$109(require_Swipe());
	var import_Swipe2 = require_Swipe();
	var Swipe = (0, import_utils$198.withInstall)(import_Swipe$1.default);
	var stdin_default$191 = Swipe;
}) });

//#endregion
//#region node_modules/vant/lib/tabs/TabsContent.js
var require_TabsContent = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tabs/TabsContent.js": ((exports, module) => {
	var __defProp$210 = Object.defineProperty;
	var __getOwnPropDesc$210 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$210 = Object.getOwnPropertyNames;
	var __hasOwnProp$210 = Object.prototype.hasOwnProperty;
	var __export$210 = (target, all) => {
		for (var name2 in all) __defProp$210(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$210 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$210(from)) if (!__hasOwnProp$210.call(to, key) && key !== except) __defProp$210(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$210(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$210 = (mod) => __copyProps$210(__defProp$210({}, "__esModule", { value: true }), mod);
	var stdin_exports$209 = {};
	__export$210(stdin_exports$209, { default: () => stdin_default$190 });
	module.exports = __toCommonJS$210(stdin_exports$209);
	var import_vue$107 = require_vue();
	var import_utils$197 = require_utils$9();
	var import_swipe$2 = require_swipe();
	var import_use_expose$33 = require_use_expose();
	var [name$94, bem$90] = (0, import_utils$197.createNamespace)("tabs");
	var stdin_default$190 = (0, import_vue$107.defineComponent)({
		name: name$94,
		props: {
			count: (0, import_utils$197.makeRequiredProp)(Number),
			inited: Boolean,
			animated: Boolean,
			duration: (0, import_utils$197.makeRequiredProp)(import_utils$197.numericProp),
			swipeable: Boolean,
			lazyRender: Boolean,
			currentIndex: (0, import_utils$197.makeRequiredProp)(Number)
		},
		emits: ["change"],
		setup(props$1, { emit, slots }) {
			const swipeRef = (0, import_vue$107.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 (0, import_vue$107.createVNode)(import_swipe$2.Swipe, {
					"ref": swipeRef,
					"loop": false,
					"class": bem$90("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 });
			};
			(0, import_vue$107.watch)(() => props$1.currentIndex, swipeToCurrentTab);
			(0, import_vue$107.onMounted)(() => {
				swipeToCurrentTab(props$1.currentIndex);
			});
			(0, import_use_expose$33.useExpose)({ swipeRef });
			return () => (0, import_vue$107.createVNode)("div", { "class": bem$90("content", { animated: props$1.animated || props$1.swipeable }) }, [renderChildren()]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/tabs/Tabs.js
var require_Tabs = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tabs/Tabs.js": ((exports, module) => {
	var __create$108 = Object.create;
	var __defProp$209 = Object.defineProperty;
	var __getOwnPropDesc$209 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$209 = Object.getOwnPropertyNames;
	var __getProtoOf$108 = Object.getPrototypeOf;
	var __hasOwnProp$209 = Object.prototype.hasOwnProperty;
	var __export$209 = (target, all) => {
		for (var name2 in all) __defProp$209(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$209 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$209(from)) if (!__hasOwnProp$209.call(to, key) && key !== except) __defProp$209(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$209(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$108 = (mod, isNodeMode, target) => (target = mod != null ? __create$108(__getProtoOf$108(mod)) : {}, __copyProps$209(isNodeMode || !mod || !mod.__esModule ? __defProp$209(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$209 = (mod) => __copyProps$209(__defProp$209({}, "__esModule", { value: true }), mod);
	var stdin_exports$208 = {};
	__export$209(stdin_exports$208, {
		TABS_KEY: () => TABS_KEY,
		default: () => stdin_default$189,
		tabsProps: () => tabsProps
	});
	module.exports = __toCommonJS$209(stdin_exports$208);
	var import_vue$106 = require_vue();
	var import_utils$196 = require_utils$9();
	var import_utils2$14 = require_utils$7();
	var import_use$54 = require_index_cjs$1();
	var import_use_id$5 = require_use_id();
	var import_use_route$5 = require_use_route();
	var import_use_refs$4 = require_use_refs();
	var import_use_expose$32 = require_use_expose();
	var import_on_popup_reopen$1 = require_on_popup_reopen();
	var import_use_visibility_change = require_use_visibility_change();
	var import_sticky$1 = require_sticky();
	var import_TabsContent = __toESM$108(require_TabsContent());
	var [name$93, bem$89] = (0, import_utils$196.createNamespace)("tabs");
	var tabsProps = {
		type: (0, import_utils$196.makeStringProp)("line"),
		color: String,
		border: Boolean,
		sticky: Boolean,
		shrink: Boolean,
		active: (0, import_utils$196.makeNumericProp)(0),
		duration: (0, import_utils$196.makeNumericProp)(.3),
		animated: Boolean,
		ellipsis: import_utils$196.truthProp,
		swipeable: Boolean,
		scrollspy: Boolean,
		offsetTop: (0, import_utils$196.makeNumericProp)(0),
		background: String,
		lazyRender: import_utils$196.truthProp,
		showHeader: import_utils$196.truthProp,
		lineWidth: import_utils$196.numericProp,
		lineHeight: import_utils$196.numericProp,
		beforeChange: Function,
		swipeThreshold: (0, import_utils$196.makeNumericProp)(5),
		titleActiveColor: String,
		titleInactiveColor: String
	};
	var TABS_KEY = Symbol(name$93);
	var stdin_default$189 = (0, import_vue$106.defineComponent)({
		name: name$93,
		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 = (0, import_vue$106.ref)();
			const navRef = (0, import_vue$106.ref)();
			const wrapRef = (0, import_vue$106.ref)();
			const contentRef = (0, import_vue$106.ref)();
			const id = (0, import_use_id$5.useId)();
			const scroller = (0, import_use$54.useScrollParent)(root);
			const [titleRefs, setTitleRefs] = (0, import_use_refs$4.useRefs)();
			const { children, linkChildren } = (0, import_use$54.useChildren)(TABS_KEY);
			const state = (0, import_vue$106.reactive)({
				inited: false,
				position: "",
				lineStyle: {},
				currentIndex: -1
			});
			const scrollable = (0, import_vue$106.computed)(() => children.length > +props$1.swipeThreshold || !props$1.ellipsis || props$1.shrink);
			const navStyle = (0, import_vue$106.computed)(() => ({
				borderColor: props$1.color,
				background: props$1.background
			}));
			const getTabName = (tab, index) => {
				var _a;
				return (_a = tab.name) != null ? _a : index;
			};
			const currentName = (0, import_vue$106.computed)(() => {
				const activeTab = children[state.currentIndex];
				if (activeTab) return getTabName(activeTab, state.currentIndex);
			});
			const offsetTopPx = (0, import_vue$106.computed)(() => (0, import_utils$196.unitToPx)(props$1.offsetTop));
			const scrollOffset = (0, import_vue$106.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 = (0, import_utils2$14.scrollLeftTo)(nav, to, immediate ? 0 : +props$1.duration);
			};
			const setLine = () => {
				const shouldAnimate = state.inited;
				(0, import_vue$106.nextTick)(() => {
					const titles = titleRefs.value;
					if (!titles || !titles[state.currentIndex] || props$1.type !== "line" || (0, import_utils$196.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: (0, import_utils$196.addUnit)(lineWidth),
						backgroundColor: props$1.color,
						transform: `translateX(${left$1}px) translateX(-50%)`
					};
					if (shouldAnimate) lineStyle.transitionDuration = `${props$1.duration}s`;
					if ((0, import_utils$196.isDef)(lineHeight)) {
						const height$1 = (0, import_utils$196.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 (!(0, import_utils$196.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) (0, import_utils$196.setRootScrollTop)(Math.ceil((0, import_utils$196.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 = (0, import_utils$196.getElementTop)(target, scroller.value) - scrollOffset.value;
						lockScroll = true;
						if (cancelScrollTopToRaf) cancelScrollTopToRaf();
						cancelScrollTopToRaf = (0, import_utils2$14.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) {
					(0, import_utils$196.callInterceptor)(props$1.beforeChange, {
						args: [name2],
						done: () => {
							setCurrentIndex(index);
							scrollToCurrentContent();
						}
					});
					(0, import_use_route$5.route)(item);
				}
				emit("clickTab", {
					name: name2,
					title,
					event,
					disabled
				});
			};
			const onStickyScroll = (params) => {
				stickyFixed = params.isFixed;
				emit("scroll", params);
			};
			const scrollTo = (name2) => {
				(0, import_vue$106.nextTick)(() => {
					setCurrentIndexByName(name2);
					scrollToCurrentContent(true);
				});
			};
			const getCurrentIndexOnScroll = () => {
				for (let index = 0; index < children.length; index++) {
					const { top: top$1 } = (0, import_use$54.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 (0, import_vue$106.createVNode)("div", {
					"class": bem$89("line"),
					"style": state.lineStyle
				}, null);
			};
			const renderHeader = () => {
				var _a, _b, _c;
				const { type, border, sticky } = props$1;
				const Header = [(0, import_vue$106.createVNode)("div", {
					"ref": sticky ? void 0 : wrapRef,
					"class": [bem$89("wrap"), { [import_utils$196.BORDER_TOP_BOTTOM]: type === "line" && border }]
				}, [(0, import_vue$106.createVNode)("div", {
					"ref": navRef,
					"role": "tablist",
					"class": bem$89("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 (0, import_vue$106.createVNode)("div", { "ref": wrapRef }, [Header]);
				return Header;
			};
			const resize = () => {
				setLine();
				(0, import_vue$106.nextTick)(() => {
					var _a, _b;
					scrollIntoView(true);
					(_b = (_a = contentRef.value) == null ? void 0 : _a.swipeRef.value) == null || _b.resize();
				});
			};
			(0, import_vue$106.watch)(() => [
				props$1.color,
				props$1.duration,
				props$1.lineWidth,
				props$1.lineHeight
			], setLine);
			(0, import_vue$106.watch)(import_utils$196.windowWidth, resize);
			(0, import_vue$106.watch)(() => props$1.active, (value) => {
				if (value !== currentName.value) setCurrentIndexByName(value);
			});
			(0, import_vue$106.watch)(() => children.length, () => {
				if (state.inited) {
					setCurrentIndexByName(props$1.active);
					setLine();
					(0, import_vue$106.nextTick)(() => {
						scrollIntoView(true);
					});
				}
			});
			const init = () => {
				setCurrentIndexByName(props$1.active, true);
				(0, import_vue$106.nextTick)(() => {
					state.inited = true;
					if (wrapRef.value) tabHeight = (0, import_use$54.useRect)(wrapRef.value).height;
					scrollIntoView(true);
				});
			};
			const onRendered = (name2, title) => emit("rendered", name2, title);
			(0, import_use_expose$32.useExpose)({
				resize,
				scrollTo
			});
			(0, import_vue$106.onActivated)(setLine);
			(0, import_on_popup_reopen$1.onPopupReopen)(setLine);
			(0, import_use$54.onMountedOrActivated)(init);
			(0, import_use_visibility_change.useVisibilityChange)(root, setLine);
			(0, import_use$54.useEventListener)("scroll", onScroll, {
				target: scroller,
				passive: true
			});
			linkChildren({
				id,
				props: props$1,
				setLine,
				scrollable,
				onRendered,
				currentName,
				setTitleRefs,
				scrollIntoView
			});
			return () => (0, import_vue$106.createVNode)("div", {
				"ref": root,
				"class": bem$89([props$1.type])
			}, [props$1.showHeader ? props$1.sticky ? (0, import_vue$106.createVNode)(import_sticky$1.Sticky, {
				"container": root.value,
				"offsetTop": offsetTopPx.value,
				"onScroll": onStickyScroll
			}, { default: () => [renderHeader()] }) : renderHeader() : null, (0, import_vue$106.createVNode)(import_TabsContent.default, {
				"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/lib/composables/use-tab-status.js
var require_use_tab_status = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/composables/use-tab-status.js": ((exports, module) => {
	var __defProp$208 = Object.defineProperty;
	var __getOwnPropDesc$208 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$208 = Object.getOwnPropertyNames;
	var __hasOwnProp$208 = Object.prototype.hasOwnProperty;
	var __export$208 = (target, all) => {
		for (var name$111 in all) __defProp$208(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$208 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$208(from)) if (!__hasOwnProp$208.call(to, key) && key !== except) __defProp$208(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$208(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$208 = (mod) => __copyProps$208(__defProp$208({}, "__esModule", { value: true }), mod);
	var stdin_exports$207 = {};
	__export$208(stdin_exports$207, {
		ALL_TAB_STATUS_KEY: () => ALL_TAB_STATUS_KEY,
		TAB_STATUS_KEY: () => TAB_STATUS_KEY,
		useAllTabStatus: () => useAllTabStatus,
		useProvideTabStatus: () => useProvideTabStatus,
		useTabStatus: () => useTabStatus
	});
	module.exports = __toCommonJS$208(stdin_exports$207);
	var import_vue$105 = require_vue();
	var TAB_STATUS_KEY = Symbol();
	var ALL_TAB_STATUS_KEY = Symbol();
	var useTabStatus = () => (0, import_vue$105.inject)(TAB_STATUS_KEY, null);
	var useAllTabStatus = () => (0, import_vue$105.inject)(ALL_TAB_STATUS_KEY, null);
	var useProvideTabStatus = (status) => {
		const allTabStatus = useAllTabStatus();
		(0, import_vue$105.provide)(TAB_STATUS_KEY, status);
		(0, import_vue$105.provide)(ALL_TAB_STATUS_KEY, (0, import_vue$105.computed)(() => {
			return (allTabStatus == null || allTabStatus.value) && status.value;
		}));
	};
}) });

//#endregion
//#region node_modules/vant/lib/tab/TabTitle.js
var require_TabTitle = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tab/TabTitle.js": ((exports, module) => {
	var __defProp$207 = Object.defineProperty;
	var __getOwnPropDesc$207 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$207 = Object.getOwnPropertyNames;
	var __hasOwnProp$207 = Object.prototype.hasOwnProperty;
	var __export$207 = (target, all) => {
		for (var name2 in all) __defProp$207(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$207 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$207(from)) if (!__hasOwnProp$207.call(to, key) && key !== except) __defProp$207(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$207(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$207 = (mod) => __copyProps$207(__defProp$207({}, "__esModule", { value: true }), mod);
	var stdin_exports$206 = {};
	__export$207(stdin_exports$206, { TabTitle: () => TabTitle });
	module.exports = __toCommonJS$207(stdin_exports$206);
	var import_vue$104 = require_vue();
	var import_utils$195 = require_utils$9();
	var import_badge$4 = require_badge();
	var [name$92, bem$88] = (0, import_utils$195.createNamespace)("tab");
	var TabTitle = (0, import_vue$104.defineComponent)({
		name: name$92,
		props: {
			id: String,
			dot: Boolean,
			type: String,
			color: String,
			title: String,
			badge: import_utils$195.numericProp,
			shrink: Boolean,
			isActive: Boolean,
			disabled: Boolean,
			controls: String,
			scrollable: Boolean,
			activeColor: String,
			inactiveColor: String,
			showZeroBadge: import_utils$195.truthProp
		},
		setup(props$1, { slots }) {
			const style = (0, import_vue$104.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 = (0, import_vue$104.createVNode)("span", { "class": bem$88("text", { ellipsis: !props$1.scrollable }) }, [slots.title ? slots.title() : props$1.title]);
				if (props$1.dot || (0, import_utils$195.isDef)(props$1.badge) && props$1.badge !== "") return (0, import_vue$104.createVNode)(import_badge$4.Badge, {
					"dot": props$1.dot,
					"content": props$1.badge,
					"showZero": props$1.showZeroBadge
				}, { default: () => [Text] });
				return Text;
			};
			return () => (0, import_vue$104.createVNode)("div", {
				"id": props$1.id,
				"role": "tab",
				"class": [bem$88([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/lib/swipe-item/SwipeItem.js
var require_SwipeItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/swipe-item/SwipeItem.js": ((exports, module) => {
	var __defProp$206 = Object.defineProperty;
	var __getOwnPropDesc$206 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$206 = Object.getOwnPropertyNames;
	var __hasOwnProp$206 = Object.prototype.hasOwnProperty;
	var __export$206 = (target, all) => {
		for (var name2 in all) __defProp$206(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$206 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$206(from)) if (!__hasOwnProp$206.call(to, key) && key !== except) __defProp$206(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$206(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$206 = (mod) => __copyProps$206(__defProp$206({}, "__esModule", { value: true }), mod);
	var stdin_exports$205 = {};
	__export$206(stdin_exports$205, { default: () => stdin_default$188 });
	module.exports = __toCommonJS$206(stdin_exports$205);
	var import_vue$103 = require_vue();
	var import_utils$194 = require_utils$9();
	var import_Swipe = require_Swipe();
	var import_use$53 = require_index_cjs$1();
	var import_use_expose$31 = require_use_expose();
	var [name$91, bem$87] = (0, import_utils$194.createNamespace)("swipe-item");
	var stdin_default$188 = (0, import_vue$103.defineComponent)({
		name: name$91,
		setup(props$1, { slots }) {
			let rendered;
			const state = (0, import_vue$103.reactive)({
				offset: 0,
				inited: false,
				mounted: false
			});
			const { parent, index } = (0, import_use$53.useParent)(import_Swipe.SWIPE_KEY);
			if (!parent) {
				console.error("[Vant] <SwipeItem> must be a child component of <Swipe>.");
				return;
			}
			const style = (0, import_vue$103.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 = (0, import_vue$103.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;
			};
			(0, import_vue$103.onMounted)(() => {
				(0, import_vue$103.nextTick)(() => {
					state.mounted = true;
				});
			});
			(0, import_use_expose$31.useExpose)({ setOffset });
			return () => {
				var _a;
				return (0, import_vue$103.createVNode)("div", {
					"class": bem$87(),
					"style": style.value
				}, [shouldRender.value ? (_a = slots.default) == null ? void 0 : _a.call(slots) : null]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/swipe-item/index.js
var require_swipe_item = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/swipe-item/index.js": ((exports, module) => {
	var __create$107 = Object.create;
	var __defProp$205 = Object.defineProperty;
	var __getOwnPropDesc$205 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$205 = Object.getOwnPropertyNames;
	var __getProtoOf$107 = Object.getPrototypeOf;
	var __hasOwnProp$205 = Object.prototype.hasOwnProperty;
	var __export$205 = (target, all) => {
		for (var name$111 in all) __defProp$205(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$205 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$205(from)) if (!__hasOwnProp$205.call(to, key) && key !== except) __defProp$205(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$205(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$107 = (mod, isNodeMode, target) => (target = mod != null ? __create$107(__getProtoOf$107(mod)) : {}, __copyProps$205(isNodeMode || !mod || !mod.__esModule ? __defProp$205(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$205 = (mod) => __copyProps$205(__defProp$205({}, "__esModule", { value: true }), mod);
	var stdin_exports$204 = {};
	__export$205(stdin_exports$204, {
		SwipeItem: () => SwipeItem,
		default: () => stdin_default$187
	});
	module.exports = __toCommonJS$205(stdin_exports$204);
	var import_utils$193 = require_utils$9();
	var import_SwipeItem = __toESM$107(require_SwipeItem());
	var SwipeItem = (0, import_utils$193.withInstall)(import_SwipeItem.default);
	var stdin_default$187 = SwipeItem;
}) });

//#endregion
//#region node_modules/vant/lib/tab/Tab.js
var require_Tab = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tab/Tab.js": ((exports, module) => {
	var __defProp$204 = Object.defineProperty;
	var __getOwnPropDesc$204 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$204 = Object.getOwnPropertyNames;
	var __hasOwnProp$204 = Object.prototype.hasOwnProperty;
	var __export$204 = (target, all) => {
		for (var name2 in all) __defProp$204(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$204 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$204(from)) if (!__hasOwnProp$204.call(to, key) && key !== except) __defProp$204(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$204(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$204 = (mod) => __copyProps$204(__defProp$204({}, "__esModule", { value: true }), mod);
	var stdin_exports$203 = {};
	__export$204(stdin_exports$203, {
		default: () => stdin_default$186,
		tabProps: () => tabProps
	});
	module.exports = __toCommonJS$204(stdin_exports$203);
	var import_vue$102 = require_vue();
	var import_shared$3 = (init_shared_esm_bundler(), __toCommonJS$269(shared_esm_bundler_exports));
	var import_utils$192 = require_utils$9();
	var import_Tabs$1 = require_Tabs();
	var import_use$52 = require_index_cjs$1();
	var import_use_id$4 = require_use_id();
	var import_use_expose$30 = require_use_expose();
	var import_use_route$4 = require_use_route();
	var import_use_tab_status$2 = require_use_tab_status();
	var import_TabTitle = require_TabTitle();
	var import_swipe_item$2 = require_swipe_item();
	var [name$90, bem$86] = (0, import_utils$192.createNamespace)("tab");
	var tabProps = (0, import_utils$192.extend)({}, import_use_route$4.routeProps, {
		dot: Boolean,
		name: import_utils$192.numericProp,
		badge: import_utils$192.numericProp,
		title: String,
		disabled: Boolean,
		titleClass: import_utils$192.unknownProp,
		titleStyle: [String, Object],
		showZeroBadge: import_utils$192.truthProp
	});
	var stdin_default$186 = (0, import_vue$102.defineComponent)({
		name: name$90,
		props: tabProps,
		setup(props$1, { slots }) {
			const id = (0, import_use_id$4.useId)();
			const inited = (0, import_vue$102.ref)(false);
			const instance$3 = (0, import_vue$102.getCurrentInstance)();
			const { parent, index } = (0, import_use$52.useParent)(import_Tabs$1.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) (0, import_vue$102.nextTick)(() => {
					parent.onRendered(getName(), props$1.title);
				});
			};
			const active = (0, import_vue$102.computed)(() => {
				const isActive = getName() === parent.currentName.value;
				if (isActive && !inited.value) init();
				return isActive;
			});
			const parsedClass = (0, import_vue$102.ref)("");
			const parsedStyle = (0, import_vue$102.ref)("");
			(0, import_vue$102.watchEffect)(() => {
				const { titleClass, titleStyle } = props$1;
				parsedClass.value = titleClass ? (0, import_shared$3.normalizeClass)(titleClass) : "";
				parsedStyle.value = titleStyle && typeof titleStyle !== "string" ? (0, import_shared$3.stringifyStyle)((0, import_shared$3.normalizeStyle)(titleStyle)) : titleStyle;
			});
			const renderTitle = (onClickTab) => (0, import_vue$102.createVNode)(import_TabTitle.TabTitle, (0, import_vue$102.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)
			}, (0, import_utils$192.pick)(parent.props, [
				"type",
				"color",
				"shrink"
			]), (0, import_utils$192.pick)(props$1, [
				"dot",
				"badge",
				"title",
				"disabled",
				"showZeroBadge"
			])), { title: slots.title });
			const hasInactiveClass = (0, import_vue$102.ref)(!active.value);
			(0, import_vue$102.watch)(active, (val) => {
				if (val) hasInactiveClass.value = false;
				else (0, import_use$52.doubleRaf)(() => {
					hasInactiveClass.value = true;
				});
			});
			(0, import_vue$102.watch)(() => props$1.title, () => {
				parent.setLine();
				parent.scrollIntoView();
			});
			(0, import_use_tab_status$2.useProvideTabStatus)(active);
			(0, import_use_expose$30.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 (0, import_vue$102.createVNode)(import_swipe_item$2.SwipeItem, {
					"id": id,
					"role": "tabpanel",
					"class": bem$86("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 [(0, import_vue$102.createVNode)("div", { "class": bem$86("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 (0, import_vue$102.withDirectives)((0, import_vue$102.createVNode)("div", {
					"id": id,
					"role": "tabpanel",
					"class": bem$86("panel"),
					"tabindex": show ? 0 : -1,
					"aria-labelledby": label,
					"data-allow-mismatch": "attribute"
				}, [Content]), [[import_vue$102.vShow, show]]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/tab/index.js
var require_tab = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tab/index.js": ((exports, module) => {
	var __create$106 = Object.create;
	var __defProp$203 = Object.defineProperty;
	var __getOwnPropDesc$203 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$203 = Object.getOwnPropertyNames;
	var __getProtoOf$106 = Object.getPrototypeOf;
	var __hasOwnProp$203 = Object.prototype.hasOwnProperty;
	var __export$203 = (target, all) => {
		for (var name$111 in all) __defProp$203(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$203 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$203(from)) if (!__hasOwnProp$203.call(to, key) && key !== except) __defProp$203(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$203(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$106 = (mod, isNodeMode, target) => (target = mod != null ? __create$106(__getProtoOf$106(mod)) : {}, __copyProps$203(isNodeMode || !mod || !mod.__esModule ? __defProp$203(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$203 = (mod) => __copyProps$203(__defProp$203({}, "__esModule", { value: true }), mod);
	var stdin_exports$202 = {};
	__export$203(stdin_exports$202, {
		Tab: () => Tab,
		default: () => stdin_default$185,
		tabProps: () => import_Tab2.tabProps,
		useAllTabStatus: () => import_use_tab_status$1.useAllTabStatus,
		useTabStatus: () => import_use_tab_status$1.useTabStatus
	});
	module.exports = __toCommonJS$203(stdin_exports$202);
	var import_utils$191 = require_utils$9();
	var import_Tab = __toESM$106(require_Tab());
	var import_Tab2 = require_Tab();
	var import_use_tab_status$1 = require_use_tab_status();
	var Tab = (0, import_utils$191.withInstall)(import_Tab.default);
	var stdin_default$185 = Tab;
}) });

//#endregion
//#region node_modules/vant/lib/tabs/index.js
var require_tabs = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tabs/index.js": ((exports, module) => {
	var __create$105 = Object.create;
	var __defProp$202 = Object.defineProperty;
	var __getOwnPropDesc$202 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$202 = Object.getOwnPropertyNames;
	var __getProtoOf$105 = Object.getPrototypeOf;
	var __hasOwnProp$202 = Object.prototype.hasOwnProperty;
	var __export$202 = (target, all) => {
		for (var name$111 in all) __defProp$202(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$202 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$202(from)) if (!__hasOwnProp$202.call(to, key) && key !== except) __defProp$202(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$202(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$105 = (mod, isNodeMode, target) => (target = mod != null ? __create$105(__getProtoOf$105(mod)) : {}, __copyProps$202(isNodeMode || !mod || !mod.__esModule ? __defProp$202(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$202 = (mod) => __copyProps$202(__defProp$202({}, "__esModule", { value: true }), mod);
	var stdin_exports$201 = {};
	__export$202(stdin_exports$201, {
		Tabs: () => Tabs,
		default: () => stdin_default$184,
		tabsProps: () => import_Tabs2.tabsProps
	});
	module.exports = __toCommonJS$202(stdin_exports$201);
	var import_utils$190 = require_utils$9();
	var import_Tabs = __toESM$105(require_Tabs());
	var import_Tabs2 = require_Tabs();
	var Tabs = (0, import_utils$190.withInstall)(import_Tabs.default);
	var stdin_default$184 = Tabs;
}) });

//#endregion
//#region node_modules/vant/lib/picker-group/PickerGroup.js
var require_PickerGroup = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/picker-group/PickerGroup.js": ((exports, module) => {
	var __create$104 = Object.create;
	var __defProp$201 = Object.defineProperty;
	var __getOwnPropDesc$201 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$201 = Object.getOwnPropertyNames;
	var __getProtoOf$104 = Object.getPrototypeOf;
	var __hasOwnProp$201 = Object.prototype.hasOwnProperty;
	var __export$201 = (target, all) => {
		for (var name2 in all) __defProp$201(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$201 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$201(from)) if (!__hasOwnProp$201.call(to, key) && key !== except) __defProp$201(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$201(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$104 = (mod, isNodeMode, target) => (target = mod != null ? __create$104(__getProtoOf$104(mod)) : {}, __copyProps$201(isNodeMode || !mod || !mod.__esModule ? __defProp$201(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$201 = (mod) => __copyProps$201(__defProp$201({}, "__esModule", { value: true }), mod);
	var stdin_exports$200 = {};
	__export$201(stdin_exports$200, {
		PICKER_GROUP_KEY: () => PICKER_GROUP_KEY,
		default: () => stdin_default$183,
		pickerGroupProps: () => pickerGroupProps
	});
	module.exports = __toCommonJS$201(stdin_exports$200);
	var import_vue$101 = require_vue();
	var import_utils$189 = require_utils$9();
	var import_use$51 = require_index_cjs$1();
	var import_use_sync_prop_ref$2 = require_use_sync_prop_ref();
	var import_tab$3 = require_tab();
	var import_tabs$3 = require_tabs();
	var import_PickerToolbar$1 = __toESM$104(require_PickerToolbar());
	var [name$89, bem$85] = (0, import_utils$189.createNamespace)("picker-group");
	var PICKER_GROUP_KEY = Symbol(name$89);
	var pickerGroupProps = (0, import_utils$189.extend)({
		tabs: (0, import_utils$189.makeArrayProp)(),
		activeTab: (0, import_utils$189.makeNumericProp)(0),
		nextStepText: String,
		showToolbar: import_utils$189.truthProp
	}, import_PickerToolbar$1.pickerToolbarProps);
	var stdin_default$183 = (0, import_vue$101.defineComponent)({
		name: name$89,
		props: pickerGroupProps,
		emits: [
			"confirm",
			"cancel",
			"update:activeTab"
		],
		setup(props$1, { emit, slots }) {
			const activeTab = (0, import_use_sync_prop_ref$2.useSyncPropRef)(() => props$1.activeTab, (value) => emit("update:activeTab", value));
			const { children, linkChildren } = (0, import_use$51.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 !== import_vue$101.Comment).map((node) => {
					if (node.type === import_vue$101.Fragment) return node.children;
					return node;
				});
				if (childNodes) childNodes = (0, import_utils$189.flat)(childNodes);
				const confirmButtonText = showNextButton() ? props$1.nextStepText : props$1.confirmButtonText;
				return (0, import_vue$101.createVNode)("div", { "class": bem$85() }, [props$1.showToolbar ? (0, import_vue$101.createVNode)(import_PickerToolbar$1.default, {
					"title": props$1.title,
					"cancelButtonText": props$1.cancelButtonText,
					"confirmButtonText": confirmButtonText,
					"onConfirm": onConfirm,
					"onCancel": onCancel
				}, (0, import_utils$189.pick)(slots, import_PickerToolbar$1.pickerToolbarSlots)) : null, (0, import_vue$101.createVNode)(import_tabs$3.Tabs, {
					"active": activeTab.value,
					"onUpdate:active": ($event) => activeTab.value = $event,
					"class": bem$85("tabs"),
					"shrink": true,
					"animated": true,
					"lazyRender": false
				}, { default: () => [props$1.tabs.map((title, index) => (0, import_vue$101.createVNode)(import_tab$3.Tab, {
					"title": title,
					"titleClass": bem$85("tab-title")
				}, { default: () => [childNodes == null ? void 0 : childNodes[index]] }))] })]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/picker/Picker.js
var require_Picker = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/picker/Picker.js": ((exports, module) => {
	var __create$103 = Object.create;
	var __defProp$200 = Object.defineProperty;
	var __getOwnPropDesc$200 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$200 = Object.getOwnPropertyNames;
	var __getProtoOf$103 = Object.getPrototypeOf;
	var __hasOwnProp$200 = Object.prototype.hasOwnProperty;
	var __export$200 = (target, all) => {
		for (var name2 in all) __defProp$200(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$200 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$200(from)) if (!__hasOwnProp$200.call(to, key) && key !== except) __defProp$200(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$200(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$103 = (mod, isNodeMode, target) => (target = mod != null ? __create$103(__getProtoOf$103(mod)) : {}, __copyProps$200(isNodeMode || !mod || !mod.__esModule ? __defProp$200(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$200 = (mod) => __copyProps$200(__defProp$200({}, "__esModule", { value: true }), mod);
	var stdin_exports$199 = {};
	__export$200(stdin_exports$199, {
		default: () => stdin_default$182,
		pickerProps: () => pickerProps,
		pickerSharedProps: () => pickerSharedProps
	});
	module.exports = __toCommonJS$200(stdin_exports$199);
	var import_vue$100 = require_vue();
	var import_utils$188 = require_utils$9();
	var import_utils2$13 = require_utils$8();
	var import_use$50 = require_index_cjs$1();
	var import_use_expose$29 = require_use_expose();
	var import_loading$8 = require_loading();
	var import_PickerColumn = __toESM$103(require_PickerColumn());
	var import_PickerToolbar = __toESM$103(require_PickerToolbar());
	var import_PickerGroup$1 = require_PickerGroup();
	var pickerSharedProps = (0, import_utils$188.extend)({
		loading: Boolean,
		readonly: Boolean,
		allowHtml: Boolean,
		optionHeight: (0, import_utils$188.makeNumericProp)(44),
		showToolbar: import_utils$188.truthProp,
		swipeDuration: (0, import_utils$188.makeNumericProp)(1e3),
		visibleOptionNum: (0, import_utils$188.makeNumericProp)(6)
	}, import_PickerToolbar.pickerToolbarProps);
	var pickerProps = (0, import_utils$188.extend)({}, pickerSharedProps, {
		columns: (0, import_utils$188.makeArrayProp)(),
		modelValue: (0, import_utils$188.makeArrayProp)(),
		toolbarPosition: (0, import_utils$188.makeStringProp)("top"),
		columnsFieldNames: Object
	});
	var stdin_default$182 = (0, import_vue$100.defineComponent)({
		name: import_utils2$13.name,
		props: pickerProps,
		emits: [
			"confirm",
			"cancel",
			"change",
			"scrollInto",
			"clickOption",
			"update:modelValue"
		],
		setup(props$1, { emit, slots }) {
			const columnsRef = (0, import_vue$100.ref)();
			const selectedValues = (0, import_vue$100.ref)(props$1.modelValue.slice(0));
			const { parent } = (0, import_use$50.useParent)(import_PickerGroup$1.PICKER_GROUP_KEY);
			const { children, linkChildren } = (0, import_use$50.useChildren)(import_PickerColumn.PICKER_KEY);
			linkChildren();
			const fields = (0, import_vue$100.computed)(() => (0, import_utils2$13.assignDefaultFields)(props$1.columnsFieldNames));
			const optionHeight = (0, import_vue$100.computed)(() => (0, import_utils$188.unitToPx)(props$1.optionHeight));
			const columnsType = (0, import_vue$100.computed)(() => (0, import_utils2$13.getColumnsType)(props$1.columns, fields.value));
			const currentColumns = (0, import_vue$100.computed)(() => {
				const { columns } = props$1;
				switch (columnsType.value) {
					case "multiple": return columns;
					case "cascade": return (0, import_utils2$13.formatCascadeColumns)(columns, fields.value, selectedValues);
					default: return [columns];
				}
			});
			const hasOptions = (0, import_vue$100.computed)(() => currentColumns.value.some((options) => options.length));
			const selectedOptions = (0, import_vue$100.computed)(() => currentColumns.value.map((options, index) => (0, import_utils2$13.findOptionByValue)(options, selectedValues.value[index], fields.value)));
			const selectedIndexes = (0, import_vue$100.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 (!(0, import_utils2$13.isOptionExist)(options, value2, fields.value)) setValue(index, options.length ? options[0][fields.value.value] : void 0);
				});
				(0, import_vue$100.nextTick)(() => {
					emit("change", (0, import_utils$188.extend)({ columnIndex }, getEventParams()));
				});
			};
			const onClickOption = (currentOption, columnIndex) => {
				const params = {
					columnIndex,
					currentOption
				};
				emit("clickOption", (0, import_utils$188.extend)(getEventParams(), params));
				emit("scrollInto", params);
			};
			const confirm = () => {
				children.forEach((child) => child.stopMomentum());
				const params = getEventParams();
				(0, import_vue$100.nextTick)(() => {
					emit("confirm", getEventParams());
				});
				return params;
			};
			const cancel = () => emit("cancel", getEventParams());
			const renderColumnItems = () => currentColumns.value.map((options, columnIndex) => (0, import_vue$100.createVNode)(import_PickerColumn.default, {
				"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 [(0, import_vue$100.createVNode)("div", {
						"class": (0, import_utils2$13.bem)("mask"),
						"style": maskStyle
					}, null), (0, import_vue$100.createVNode)("div", {
						"class": [import_utils$188.BORDER_UNSET_TOP_BOTTOM, (0, import_utils2$13.bem)("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 (0, import_vue$100.createVNode)("div", {
					"ref": columnsRef,
					"class": (0, import_utils2$13.bem)("columns"),
					"style": columnsStyle
				}, [renderColumnItems(), renderMask(wrapHeight)]);
			};
			const renderToolbar = () => {
				if (props$1.showToolbar && !parent) return (0, import_vue$100.createVNode)(import_PickerToolbar.default, (0, import_vue$100.mergeProps)((0, import_utils$188.pick)(props$1, import_PickerToolbar.pickerToolbarPropKeys), {
					"onConfirm": confirm,
					"onCancel": cancel
				}), (0, import_utils$188.pick)(slots, import_PickerToolbar.pickerToolbarSlots));
			};
			const resetSelectedValues = (columns) => {
				columns.forEach((options, index) => {
					if (options.length && !(0, import_utils2$13.isOptionExist)(options, selectedValues.value[index], fields.value)) setValue(index, (0, import_utils2$13.getFirstEnabledOption)(options)[fields.value.value]);
				});
			};
			(0, import_vue$100.watch)(currentColumns, (columns) => resetSelectedValues(columns), { immediate: true });
			let lastEmittedModelValue;
			(0, import_vue$100.watch)(() => props$1.modelValue, (newValues) => {
				if (!(0, import_utils$188.isSameValue)(newValues, selectedValues.value) && !(0, import_utils$188.isSameValue)(newValues, lastEmittedModelValue)) {
					selectedValues.value = newValues.slice(0);
					lastEmittedModelValue = newValues.slice(0);
				}
				if (props$1.modelValue.length === 0) resetSelectedValues(currentColumns.value);
			}, { deep: true });
			(0, import_vue$100.watch)(selectedValues, (newValues) => {
				if (!(0, import_utils$188.isSameValue)(newValues, props$1.modelValue)) {
					lastEmittedModelValue = newValues.slice(0);
					emit("update:modelValue", lastEmittedModelValue);
				}
			}, { immediate: true });
			(0, import_use$50.useEventListener)("touchmove", import_utils$188.preventDefault, { target: columnsRef });
			const getSelectedOptions = () => selectedOptions.value;
			(0, import_use_expose$29.useExpose)({
				confirm,
				getSelectedOptions
			});
			return () => {
				var _a, _b;
				return (0, import_vue$100.createVNode)("div", { "class": (0, import_utils2$13.bem)() }, [
					props$1.toolbarPosition === "top" ? renderToolbar() : null,
					props$1.loading ? (0, import_vue$100.createVNode)(import_loading$8.Loading, { "class": (0, import_utils2$13.bem)("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/lib/area/utils.js
var require_utils$6 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/area/utils.js": ((exports, module) => {
	var __defProp$199 = Object.defineProperty;
	var __getOwnPropDesc$199 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$199 = Object.getOwnPropertyNames;
	var __hasOwnProp$199 = Object.prototype.hasOwnProperty;
	var __export$199 = (target, all) => {
		for (var name$111 in all) __defProp$199(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$199 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$199(from)) if (!__hasOwnProp$199.call(to, key) && key !== except) __defProp$199(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$199(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$199 = (mod) => __copyProps$199(__defProp$199({}, "__esModule", { value: true }), mod);
	var stdin_exports$198 = {};
	__export$199(stdin_exports$198, {
		AREA_EMPTY_CODE: () => AREA_EMPTY_CODE,
		INHERIT_PROPS: () => INHERIT_PROPS,
		INHERIT_SLOTS: () => INHERIT_SLOTS,
		formatDataForCascade: () => formatDataForCascade
	});
	module.exports = __toCommonJS$199(stdin_exports$198);
	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/lib/picker/index.js
var require_picker = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/picker/index.js": ((exports, module) => {
	var __create$102 = Object.create;
	var __defProp$198 = Object.defineProperty;
	var __getOwnPropDesc$198 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$198 = Object.getOwnPropertyNames;
	var __getProtoOf$102 = Object.getPrototypeOf;
	var __hasOwnProp$198 = Object.prototype.hasOwnProperty;
	var __export$198 = (target, all) => {
		for (var name$111 in all) __defProp$198(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$198 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$198(from)) if (!__hasOwnProp$198.call(to, key) && key !== except) __defProp$198(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$198(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$102 = (mod, isNodeMode, target) => (target = mod != null ? __create$102(__getProtoOf$102(mod)) : {}, __copyProps$198(isNodeMode || !mod || !mod.__esModule ? __defProp$198(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$198 = (mod) => __copyProps$198(__defProp$198({}, "__esModule", { value: true }), mod);
	var stdin_exports$197 = {};
	__export$198(stdin_exports$197, {
		Picker: () => Picker,
		default: () => stdin_default$181,
		pickerProps: () => import_Picker2.pickerProps
	});
	module.exports = __toCommonJS$198(stdin_exports$197);
	var import_utils$187 = require_utils$9();
	var import_Picker$2 = __toESM$102(require_Picker());
	var import_Picker2 = require_Picker();
	var Picker = (0, import_utils$187.withInstall)(import_Picker$2.default);
	var stdin_default$181 = Picker;
}) });

//#endregion
//#region node_modules/vant/lib/area/Area.js
var require_Area = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/area/Area.js": ((exports, module) => {
	var __defProp$197 = Object.defineProperty;
	var __getOwnPropDesc$197 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$197 = Object.getOwnPropertyNames;
	var __hasOwnProp$197 = Object.prototype.hasOwnProperty;
	var __export$197 = (target, all) => {
		for (var name2 in all) __defProp$197(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$197 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$197(from)) if (!__hasOwnProp$197.call(to, key) && key !== except) __defProp$197(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$197(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$197 = (mod) => __copyProps$197(__defProp$197({}, "__esModule", { value: true }), mod);
	var stdin_exports$196 = {};
	__export$197(stdin_exports$196, {
		areaProps: () => areaProps,
		default: () => stdin_default$180
	});
	module.exports = __toCommonJS$197(stdin_exports$196);
	var import_vue$99 = require_vue();
	var import_utils$186 = require_utils$9();
	var import_Picker$1 = require_Picker();
	var import_utils2$12 = require_utils$6();
	var import_use_expose$28 = require_use_expose();
	var import_picker$3 = require_picker();
	var [name$88, bem$84] = (0, import_utils$186.createNamespace)("area");
	var areaProps = (0, import_utils$186.extend)({}, (0, import_utils$186.pick)(import_Picker$1.pickerSharedProps, import_utils2$12.INHERIT_PROPS), {
		modelValue: String,
		columnsNum: (0, import_utils$186.makeNumericProp)(3),
		columnsPlaceholder: (0, import_utils$186.makeArrayProp)(),
		areaList: {
			type: Object,
			default: () => ({})
		}
	});
	var stdin_default$180 = (0, import_vue$99.defineComponent)({
		name: name$88,
		props: areaProps,
		emits: [
			"change",
			"confirm",
			"cancel",
			"update:modelValue"
		],
		setup(props$1, { emit, slots }) {
			const codes = (0, import_vue$99.ref)([]);
			const picker = (0, import_vue$99.ref)();
			const columns = (0, import_vue$99.computed)(() => (0, import_utils2$12.formatDataForCascade)(props$1));
			const onChange = (...args) => emit("change", ...args);
			const onCancel = (...args) => emit("cancel", ...args);
			const onConfirm = (...args) => emit("confirm", ...args);
			(0, import_vue$99.watch)(codes, (newCodes) => {
				const lastCode = newCodes.length ? newCodes[newCodes.length - 1] : "";
				if (lastCode && lastCode !== props$1.modelValue) emit("update:modelValue", lastCode);
			}, { deep: true });
			(0, import_vue$99.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 });
			(0, import_use_expose$28.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 () => (0, import_vue$99.createVNode)(import_picker$3.Picker, (0, import_vue$99.mergeProps)({
				"ref": picker,
				"modelValue": codes.value,
				"onUpdate:modelValue": ($event) => codes.value = $event,
				"class": bem$84(),
				"columns": columns.value,
				"onChange": onChange,
				"onCancel": onCancel,
				"onConfirm": onConfirm
			}, (0, import_utils$186.pick)(props$1, import_utils2$12.INHERIT_PROPS)), (0, import_utils$186.pick)(slots, import_utils2$12.INHERIT_SLOTS));
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/area/index.js
var require_area = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/area/index.js": ((exports, module) => {
	var __create$101 = Object.create;
	var __defProp$196 = Object.defineProperty;
	var __getOwnPropDesc$196 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$196 = Object.getOwnPropertyNames;
	var __getProtoOf$101 = Object.getPrototypeOf;
	var __hasOwnProp$196 = Object.prototype.hasOwnProperty;
	var __export$196 = (target, all) => {
		for (var name$111 in all) __defProp$196(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$196 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$196(from)) if (!__hasOwnProp$196.call(to, key) && key !== except) __defProp$196(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$196(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$101 = (mod, isNodeMode, target) => (target = mod != null ? __create$101(__getProtoOf$101(mod)) : {}, __copyProps$196(isNodeMode || !mod || !mod.__esModule ? __defProp$196(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$196 = (mod) => __copyProps$196(__defProp$196({}, "__esModule", { value: true }), mod);
	var stdin_exports$195 = {};
	__export$196(stdin_exports$195, {
		Area: () => Area,
		areaProps: () => import_Area2.areaProps,
		default: () => stdin_default$179
	});
	module.exports = __toCommonJS$196(stdin_exports$195);
	var import_utils$185 = require_utils$9();
	var import_Area = __toESM$101(require_Area());
	var import_Area2 = require_Area();
	var Area = (0, import_utils$185.withInstall)(import_Area.default);
	var stdin_default$179 = Area;
}) });

//#endregion
//#region node_modules/vant/lib/cell/Cell.js
var require_Cell = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/cell/Cell.js": ((exports, module) => {
	var __defProp$195 = Object.defineProperty;
	var __getOwnPropDesc$195 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$195 = Object.getOwnPropertyNames;
	var __hasOwnProp$195 = Object.prototype.hasOwnProperty;
	var __export$195 = (target, all) => {
		for (var name2 in all) __defProp$195(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$195 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$195(from)) if (!__hasOwnProp$195.call(to, key) && key !== except) __defProp$195(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$195(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$195 = (mod) => __copyProps$195(__defProp$195({}, "__esModule", { value: true }), mod);
	var stdin_exports$194 = {};
	__export$195(stdin_exports$194, {
		cellProps: () => cellProps,
		cellSharedProps: () => cellSharedProps,
		default: () => stdin_default$178
	});
	module.exports = __toCommonJS$195(stdin_exports$194);
	var import_vue$98 = require_vue();
	var import_utils$184 = require_utils$9();
	var import_use_route$3 = require_use_route();
	var import_icon$27 = require_icon();
	var [name$87, bem$83] = (0, import_utils$184.createNamespace)("cell");
	var cellSharedProps = {
		tag: (0, import_utils$184.makeStringProp)("div"),
		icon: String,
		size: String,
		title: import_utils$184.numericProp,
		value: import_utils$184.numericProp,
		label: import_utils$184.numericProp,
		center: Boolean,
		isLink: Boolean,
		border: import_utils$184.truthProp,
		iconPrefix: String,
		valueClass: import_utils$184.unknownProp,
		labelClass: import_utils$184.unknownProp,
		titleClass: import_utils$184.unknownProp,
		titleStyle: null,
		arrowDirection: String,
		required: {
			type: [Boolean, String],
			default: null
		},
		clickable: {
			type: Boolean,
			default: null
		}
	};
	var cellProps = (0, import_utils$184.extend)({}, cellSharedProps, import_use_route$3.routeProps);
	var stdin_default$178 = (0, import_vue$98.defineComponent)({
		name: name$87,
		props: cellProps,
		setup(props$1, { slots }) {
			const route$1 = (0, import_use_route$3.useRoute)();
			const renderLabel = () => {
				if (slots.label || (0, import_utils$184.isDef)(props$1.label)) return (0, import_vue$98.createVNode)("div", { "class": [bem$83("label"), props$1.labelClass] }, [slots.label ? slots.label() : props$1.label]);
			};
			const renderTitle = () => {
				var _a;
				if (slots.title || (0, import_utils$184.isDef)(props$1.title)) {
					const titleSlot = (_a = slots.title) == null ? void 0 : _a.call(slots);
					if (Array.isArray(titleSlot) && titleSlot.length === 0) return;
					return (0, import_vue$98.createVNode)("div", {
						"class": [bem$83("title"), props$1.titleClass],
						"style": props$1.titleStyle
					}, [titleSlot || (0, import_vue$98.createVNode)("span", null, [props$1.title]), renderLabel()]);
				}
			};
			const renderValue = () => {
				const slot = slots.value || slots.default;
				if (slot || (0, import_utils$184.isDef)(props$1.value)) return (0, import_vue$98.createVNode)("div", { "class": [bem$83("value"), props$1.valueClass] }, [slot ? slot() : (0, import_vue$98.createVNode)("span", null, [props$1.value])]);
			};
			const renderLeftIcon = () => {
				if (slots.icon) return slots.icon();
				if (props$1.icon) return (0, import_vue$98.createVNode)(import_icon$27.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 (0, import_vue$98.createVNode)(import_icon$27.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 (0, import_vue$98.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/lib/cell/index.js
var require_cell = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/cell/index.js": ((exports, module) => {
	var __create$100 = Object.create;
	var __defProp$194 = Object.defineProperty;
	var __getOwnPropDesc$194 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$194 = Object.getOwnPropertyNames;
	var __getProtoOf$100 = Object.getPrototypeOf;
	var __hasOwnProp$194 = Object.prototype.hasOwnProperty;
	var __export$194 = (target, all) => {
		for (var name$111 in all) __defProp$194(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$194 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$194(from)) if (!__hasOwnProp$194.call(to, key) && key !== except) __defProp$194(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$194(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$100 = (mod, isNodeMode, target) => (target = mod != null ? __create$100(__getProtoOf$100(mod)) : {}, __copyProps$194(isNodeMode || !mod || !mod.__esModule ? __defProp$194(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$194 = (mod) => __copyProps$194(__defProp$194({}, "__esModule", { value: true }), mod);
	var stdin_exports$193 = {};
	__export$194(stdin_exports$193, {
		Cell: () => Cell,
		cellProps: () => import_Cell2.cellProps,
		default: () => stdin_default$177
	});
	module.exports = __toCommonJS$194(stdin_exports$193);
	var import_utils$183 = require_utils$9();
	var import_Cell$2 = __toESM$100(require_Cell());
	var import_Cell2 = require_Cell();
	var Cell = (0, import_utils$183.withInstall)(import_Cell$2.default);
	var stdin_default$177 = Cell;
}) });

//#endregion
//#region node_modules/vant/lib/form/Form.js
var require_Form = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/form/Form.js": ((exports, module) => {
	var __defProp$193 = Object.defineProperty;
	var __getOwnPropDesc$193 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$193 = Object.getOwnPropertyNames;
	var __hasOwnProp$193 = Object.prototype.hasOwnProperty;
	var __export$193 = (target, all) => {
		for (var name2 in all) __defProp$193(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$193 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$193(from)) if (!__hasOwnProp$193.call(to, key) && key !== except) __defProp$193(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$193(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$193 = (mod) => __copyProps$193(__defProp$193({}, "__esModule", { value: true }), mod);
	var stdin_exports$192 = {};
	__export$193(stdin_exports$192, {
		default: () => stdin_default$176,
		formProps: () => formProps
	});
	module.exports = __toCommonJS$193(stdin_exports$192);
	var import_vue$97 = require_vue();
	var import_utils$182 = require_utils$9();
	var import_use$49 = require_index_cjs$1();
	var import_use_expose$27 = require_use_expose();
	var [name$86, bem$82] = (0, import_utils$182.createNamespace)("form");
	var formProps = {
		colon: Boolean,
		disabled: Boolean,
		readonly: Boolean,
		required: [Boolean, String],
		showError: Boolean,
		labelWidth: import_utils$182.numericProp,
		labelAlign: String,
		inputAlign: String,
		scrollToError: Boolean,
		scrollToErrorPosition: String,
		validateFirst: Boolean,
		submitOnEnter: import_utils$182.truthProp,
		showErrorMessage: import_utils$182.truthProp,
		errorMessageAlign: String,
		validateTrigger: {
			type: [String, Array],
			default: "onBlur"
		}
	};
	var stdin_default$176 = (0, import_vue$97.defineComponent)({
		name: name$86,
		props: formProps,
		emits: ["submit", "failed"],
		setup(props$1, { emit, slots }) {
			const { children, linkChildren } = (0, import_use$49.useChildren)(import_utils$182.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) => {
				(0, import_utils$182.preventDefault)(event);
				submit();
			};
			linkChildren({ props: props$1 });
			(0, import_use_expose$27.useExpose)({
				submit,
				validate,
				getValues,
				scrollToField,
				resetValidation,
				getValidationStatus
			});
			return () => {
				var _a;
				return (0, import_vue$97.createVNode)("form", {
					"class": bem$82(),
					"onSubmit": onSubmit
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/form/index.js
var require_form = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/form/index.js": ((exports, module) => {
	var __create$99 = Object.create;
	var __defProp$192 = Object.defineProperty;
	var __getOwnPropDesc$192 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$192 = Object.getOwnPropertyNames;
	var __getProtoOf$99 = Object.getPrototypeOf;
	var __hasOwnProp$192 = Object.prototype.hasOwnProperty;
	var __export$192 = (target, all) => {
		for (var name$111 in all) __defProp$192(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$192 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$192(from)) if (!__hasOwnProp$192.call(to, key) && key !== except) __defProp$192(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$192(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$99 = (mod, isNodeMode, target) => (target = mod != null ? __create$99(__getProtoOf$99(mod)) : {}, __copyProps$192(isNodeMode || !mod || !mod.__esModule ? __defProp$192(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$192 = (mod) => __copyProps$192(__defProp$192({}, "__esModule", { value: true }), mod);
	var stdin_exports$191 = {};
	__export$192(stdin_exports$191, {
		Form: () => Form,
		default: () => stdin_default$175,
		formProps: () => import_Form2.formProps
	});
	module.exports = __toCommonJS$192(stdin_exports$191);
	var import_utils$181 = require_utils$9();
	var import_Form = __toESM$99(require_Form());
	var import_Form2 = require_Form();
	var Form = (0, import_utils$181.withInstall)(import_Form.default);
	var stdin_default$175 = Form;
}) });

//#endregion
//#region node_modules/vant/lib/field/utils.js
var require_utils$5 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/field/utils.js": ((exports, module) => {
	var __defProp$191 = Object.defineProperty;
	var __getOwnPropDesc$191 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$191 = Object.getOwnPropertyNames;
	var __hasOwnProp$191 = Object.prototype.hasOwnProperty;
	var __export$191 = (target, all) => {
		for (var name$111 in all) __defProp$191(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$191 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$191(from)) if (!__hasOwnProp$191.call(to, key) && key !== except) __defProp$191(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$191(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$191 = (mod) => __copyProps$191(__defProp$191({}, "__esModule", { value: true }), mod);
	var stdin_exports$190 = {};
	__export$191(stdin_exports$190, {
		cutString: () => cutString,
		endComposing: () => endComposing,
		getRuleMessage: () => getRuleMessage,
		getStringLength: () => getStringLength,
		isEmptyValue: () => isEmptyValue,
		mapInputType: () => mapInputType,
		resizeTextarea: () => resizeTextarea,
		runRuleValidator: () => runRuleValidator,
		runSyncRule: () => runSyncRule,
		startComposing: () => startComposing
	});
	module.exports = __toCommonJS$191(stdin_exports$190);
	var import_utils$180 = require_utils$9();
	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 ((0, import_utils$180.isPromise)(returnVal)) {
				returnVal.then(resolve);
				return;
			}
			resolve(returnVal);
		});
	}
	function getRuleMessage(value, rule) {
		const { message } = rule;
		if ((0, import_utils$180.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 = (0, import_utils$180.getRootScrollTop)();
		input.style.height = "auto";
		let height$1 = input.scrollHeight;
		if ((0, import_utils$180.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`;
			(0, import_utils$180.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/lib/field/Field.js
var require_Field = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/field/Field.js": ((exports, module) => {
	var __defProp$190 = Object.defineProperty;
	var __getOwnPropDesc$190 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$190 = Object.getOwnPropertyNames;
	var __hasOwnProp$190 = Object.prototype.hasOwnProperty;
	var __export$190 = (target, all) => {
		for (var name2 in all) __defProp$190(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$190 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$190(from)) if (!__hasOwnProp$190.call(to, key) && key !== except) __defProp$190(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$190(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$190 = (mod) => __copyProps$190(__defProp$190({}, "__esModule", { value: true }), mod);
	var stdin_exports$189 = {};
	__export$190(stdin_exports$189, {
		default: () => stdin_default$174,
		fieldProps: () => fieldProps,
		fieldSharedProps: () => fieldSharedProps
	});
	module.exports = __toCommonJS$190(stdin_exports$189);
	var import_vue$96 = require_vue();
	var import_utils$179 = require_utils$9();
	var import_utils2$11 = require_utils$5();
	var import_Cell$1 = require_Cell();
	var import_use$48 = require_index_cjs$1();
	var import_use_id$3 = require_use_id();
	var import_use_expose$26 = require_use_expose();
	var import_icon$26 = require_icon();
	var import_cell$10 = require_cell();
	var [name$85, bem$81] = (0, import_utils$179.createNamespace)("field");
	var fieldSharedProps = {
		id: String,
		name: String,
		leftIcon: String,
		rightIcon: String,
		autofocus: Boolean,
		clearable: Boolean,
		maxlength: import_utils$179.numericProp,
		max: Number,
		min: Number,
		formatter: Function,
		clearIcon: (0, import_utils$179.makeStringProp)("clear"),
		modelValue: (0, import_utils$179.makeNumericProp)(""),
		inputAlign: String,
		placeholder: String,
		autocomplete: String,
		autocapitalize: String,
		autocorrect: String,
		errorMessage: String,
		enterkeyhint: String,
		clearTrigger: (0, import_utils$179.makeStringProp)("focus"),
		formatTrigger: (0, import_utils$179.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 = (0, import_utils$179.extend)({}, import_Cell$1.cellSharedProps, fieldSharedProps, {
		rows: import_utils$179.numericProp,
		type: (0, import_utils$179.makeStringProp)("text"),
		rules: Array,
		autosize: [Boolean, Object],
		labelWidth: import_utils$179.numericProp,
		labelClass: import_utils$179.unknownProp,
		labelAlign: String,
		showWordLimit: Boolean,
		errorMessageAlign: String,
		colon: {
			type: Boolean,
			default: null
		}
	});
	var stdin_default$174 = (0, import_vue$96.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 = (0, import_use_id$3.useId)();
			const state = (0, import_vue$96.reactive)({
				status: "unvalidated",
				focused: false,
				validateMessage: ""
			});
			const inputRef = (0, import_vue$96.ref)();
			const clearIconRef = (0, import_vue$96.ref)();
			const customValue = (0, import_vue$96.ref)();
			const { parent: form } = (0, import_use$48.useParent)(import_utils$179.FORM_KEY);
			const getModelValue = () => {
				var _a;
				return String((_a = props$1.modelValue) != null ? _a : "");
			};
			const getProp = (key) => {
				if ((0, import_utils$179.isDef)(props$1[key])) return props$1[key];
				if (form && (0, import_utils$179.isDef)(form.props[key])) return form.props[key];
			};
			const showClear = (0, import_vue$96.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 = (0, import_vue$96.computed)(() => {
				if (customValue.value && slots.input) return customValue.value();
				return props$1.modelValue;
			});
			const showRequiredMark = (0, import_vue$96.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 (!(0, import_utils2$11.runSyncRule)(value, rule)) {
					state.status = "failed";
					state.validateMessage = (0, import_utils2$11.getRuleMessage)(value, rule);
					return;
				}
				if (rule.validator) {
					if ((0, import_utils2$11.isEmptyValue)(value) && rule.validateEmpty === false) return;
					return (0, import_utils2$11.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 = (0, import_utils2$11.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 = (0, import_utils$179.toArray)(validateTrigger).includes(trigger);
					const rules = props$1.rules.filter((rule) => {
						if (rule.trigger) return (0, import_utils$179.toArray)(rule.trigger).includes(trigger);
						return defaultTrigger;
					});
					if (rules.length) validate(rules);
				}
			};
			const limitValueLength = (value) => {
				var _a;
				const { maxlength } = props$1;
				if ((0, import_utils$179.isDef)(maxlength) && (0, import_utils2$11.getStringLength)(value) > +maxlength) {
					const modelValue = getModelValue();
					if (modelValue && (0, import_utils2$11.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 (0, import_utils2$11.cutString)(value, +maxlength);
				}
				return value;
			};
			const updateValue = (value, trigger = "onChange") => {
				var _a, _b;
				const originalValue = value;
				value = limitValueLength(value);
				const limitDiffLen = (0, import_utils2$11.getStringLength)(originalValue) - (0, import_utils2$11.getStringLength)(value);
				if (props$1.type === "number" || props$1.type === "digit") {
					const isNumber = props$1.type === "number";
					value = (0, import_utils$179.formatNumber)(value, isNumber, isNumber);
					if (trigger === "onBlur" && value !== "" && (props$1.min !== void 0 || props$1.max !== void 0)) {
						const adjustedValue = (0, import_utils$179.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 ((0, import_utils$179.isDef)(maxlength) && (0, import_utils2$11.getStringLength)(value) > +maxlength) value = (0, import_utils2$11.cutString)(value, +maxlength);
					if (inputRef.value && state.focused) {
						const { selectionEnd } = inputRef.value;
						const bcoVal = (0, import_utils2$11.cutString)(originalValue, selectionEnd);
						formatterDiffLen = (0, import_utils2$11.getStringLength)(formatter(bcoVal)) - (0, import_utils2$11.getStringLength)(bcoVal);
					}
				}
				if (inputRef.value && inputRef.value.value !== value) if (state.focused) {
					let { selectionStart, selectionEnd } = inputRef.value;
					inputRef.value.value = value;
					if ((0, import_utils$179.isDef)(selectionStart) && (0, import_utils$179.isDef)(selectionEnd)) {
						const valueLen = (0, import_utils2$11.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) (0, import_utils2$11.resizeTextarea)(input, props$1.autosize);
			};
			const onFocus = (event) => {
				state.focused = true;
				emit("focus", event);
				(0, import_vue$96.nextTick)(adjustTextareaSize);
				if (getProp("readonly")) blur();
			};
			const onBlur = (event) => {
				state.focused = false;
				updateValue(getModelValue(), "onBlur");
				emit("blur", event);
				if (getProp("readonly")) return;
				validateWithTrigger("onBlur");
				(0, import_vue$96.nextTick)(adjustTextareaSize);
				(0, import_utils$179.resetScroll)();
			};
			const onClickInput = (event) => emit("clickInput", event);
			const onClickLeftIcon = (event) => emit("clickLeftIcon", event);
			const onClickRightIcon = (event) => emit("clickRightIcon", event);
			const onClear = (event) => {
				(0, import_utils$179.preventDefault)(event);
				emit("update:modelValue", "");
				emit("clear", event);
			};
			const showError = (0, import_vue$96.computed)(() => {
				if (typeof props$1.error === "boolean") return props$1.error;
				if (form && form.props.showError && state.status === "failed") return true;
			});
			const labelStyle = (0, import_vue$96.computed)(() => {
				const labelWidth = getProp("labelWidth");
				const labelAlign = getProp("labelAlign");
				if (labelWidth && labelAlign !== "top") return { width: (0, import_utils$179.addUnit)(labelWidth) };
			});
			const onKeypress = (event) => {
				if (event.keyCode === 13) {
					if (!(form && form.props.submitOnEnter) && props$1.type !== "textarea") (0, import_utils$179.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 (0, import_vue$96.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: import_utils2$11.endComposing,
					onKeypress,
					onCompositionend: import_utils2$11.endComposing,
					onCompositionstart: import_utils2$11.startComposing
				};
				if (props$1.type === "textarea") return (0, import_vue$96.createVNode)("textarea", (0, import_vue$96.mergeProps)(inputAttrs, { "inputmode": props$1.inputmode }), null);
				return (0, import_vue$96.createVNode)("input", (0, import_vue$96.mergeProps)((0, import_utils2$11.mapInputType)(props$1.type, props$1.inputmode), inputAttrs), null);
			};
			const renderLeftIcon = () => {
				const leftIconSlot = slots["left-icon"];
				if (props$1.leftIcon || leftIconSlot) return (0, import_vue$96.createVNode)("div", {
					"class": bem$81("left-icon"),
					"onClick": onClickLeftIcon
				}, [leftIconSlot ? leftIconSlot() : (0, import_vue$96.createVNode)(import_icon$26.Icon, {
					"name": props$1.leftIcon,
					"classPrefix": props$1.iconPrefix
				}, null)]);
			};
			const renderRightIcon = () => {
				const rightIconSlot = slots["right-icon"];
				if (props$1.rightIcon || rightIconSlot) return (0, import_vue$96.createVNode)("div", {
					"class": bem$81("right-icon"),
					"onClick": onClickRightIcon
				}, [rightIconSlot ? rightIconSlot() : (0, import_vue$96.createVNode)(import_icon$26.Icon, {
					"name": props$1.rightIcon,
					"classPrefix": props$1.iconPrefix
				}, null)]);
			};
			const renderWordLimit = () => {
				if (props$1.showWordLimit && props$1.maxlength) {
					const count = (0, import_utils2$11.getStringLength)(getModelValue());
					return (0, import_vue$96.createVNode)("div", { "class": bem$81("word-limit") }, [
						(0, import_vue$96.createVNode)("span", { "class": bem$81("word-num") }, [count]),
						(0, import_vue$96.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 (0, import_vue$96.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 (0, import_vue$96.createVNode)("label", {
					"id": `${id}-label`,
					"for": slots.input ? void 0 : getInputId(),
					"data-allow-mismatch": "attribute",
					"onClick": (event) => {
						(0, import_utils$179.preventDefault)(event);
						focus();
					},
					"style": labelAlign === "top" && labelWidth ? { width: (0, import_utils$179.addUnit)(labelWidth) } : void 0
				}, [props$1.label + colon]);
			};
			const renderFieldBody = () => [
				(0, import_vue$96.createVNode)("div", { "class": bem$81("body") }, [
					renderInput(),
					showClear.value && (0, import_vue$96.createVNode)(import_icon$26.Icon, {
						"ref": clearIconRef,
						"name": props$1.clearIcon,
						"class": bem$81("clear")
					}, null),
					renderRightIcon(),
					slots.button && (0, import_vue$96.createVNode)("div", { "class": bem$81("button") }, [slots.button()])
				]),
				renderWordLimit(),
				renderMessage()
			];
			(0, import_use_expose$26.useExpose)({
				blur,
				focus,
				validate,
				formValue,
				resetValidation,
				getValidationStatus
			});
			(0, import_vue$96.provide)(import_use$48.CUSTOM_FIELD_INJECTION_KEY, {
				customValue,
				resetValidation,
				validateWithTrigger
			});
			(0, import_vue$96.watch)(() => props$1.modelValue, () => {
				updateValue(getModelValue());
				resetValidation();
				validateWithTrigger("onChange");
				(0, import_vue$96.nextTick)(adjustTextareaSize);
			});
			(0, import_vue$96.onMounted)(() => {
				updateValue(getModelValue(), props$1.formatTrigger);
				(0, import_vue$96.nextTick)(adjustTextareaSize);
			});
			(0, import_use$48.useEventListener)("touchstart", onClear, { target: (0, import_vue$96.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 (0, import_vue$96.createVNode)(import_cell$10.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/lib/field/index.js
var require_field = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/field/index.js": ((exports, module) => {
	var __create$98 = Object.create;
	var __defProp$189 = Object.defineProperty;
	var __getOwnPropDesc$189 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$189 = Object.getOwnPropertyNames;
	var __getProtoOf$98 = Object.getPrototypeOf;
	var __hasOwnProp$189 = Object.prototype.hasOwnProperty;
	var __export$189 = (target, all) => {
		for (var name$111 in all) __defProp$189(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$189 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$189(from)) if (!__hasOwnProp$189.call(to, key) && key !== except) __defProp$189(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$189(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$98 = (mod, isNodeMode, target) => (target = mod != null ? __create$98(__getProtoOf$98(mod)) : {}, __copyProps$189(isNodeMode || !mod || !mod.__esModule ? __defProp$189(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$189 = (mod) => __copyProps$189(__defProp$189({}, "__esModule", { value: true }), mod);
	var stdin_exports$188 = {};
	__export$189(stdin_exports$188, {
		Field: () => Field,
		default: () => stdin_default$173,
		fieldProps: () => import_Field2.fieldProps
	});
	module.exports = __toCommonJS$189(stdin_exports$188);
	var import_utils$178 = require_utils$9();
	var import_Field$1 = __toESM$98(require_Field());
	var import_Field2 = require_Field();
	var Field = (0, import_utils$178.withInstall)(import_Field$1.default);
	var stdin_default$173 = Field;
}) });

//#endregion
//#region node_modules/vant/lib/toast/lock-click.js
var require_lock_click = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/toast/lock-click.js": ((exports, module) => {
	var __defProp$188 = Object.defineProperty;
	var __getOwnPropDesc$188 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$188 = Object.getOwnPropertyNames;
	var __hasOwnProp$188 = Object.prototype.hasOwnProperty;
	var __export$188 = (target, all) => {
		for (var name$111 in all) __defProp$188(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$188 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$188(from)) if (!__hasOwnProp$188.call(to, key) && key !== except) __defProp$188(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$188(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$188 = (mod) => __copyProps$188(__defProp$188({}, "__esModule", { value: true }), mod);
	var stdin_exports$187 = {};
	__export$188(stdin_exports$187, { lockClick: () => lockClick });
	module.exports = __toCommonJS$188(stdin_exports$187);
	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/lib/toast/Toast.js
var require_Toast = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/toast/Toast.js": ((exports, module) => {
	var __defProp$187 = Object.defineProperty;
	var __getOwnPropDesc$187 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$187 = Object.getOwnPropertyNames;
	var __hasOwnProp$187 = Object.prototype.hasOwnProperty;
	var __export$187 = (target, all) => {
		for (var name2 in all) __defProp$187(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$187 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$187(from)) if (!__hasOwnProp$187.call(to, key) && key !== except) __defProp$187(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$187(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$187 = (mod) => __copyProps$187(__defProp$187({}, "__esModule", { value: true }), mod);
	var stdin_exports$186 = {};
	__export$187(stdin_exports$186, {
		default: () => stdin_default$172,
		toastProps: () => toastProps
	});
	module.exports = __toCommonJS$187(stdin_exports$186);
	var import_vue$95 = require_vue();
	var import_utils$177 = require_utils$9();
	var import_lock_click = require_lock_click();
	var import_icon$25 = require_icon();
	var import_popup$9 = require_popup();
	var import_loading$7 = require_loading();
	var [name$84, bem$80] = (0, import_utils$177.createNamespace)("toast");
	var popupInheritProps$1 = [
		"show",
		"overlay",
		"teleport",
		"transition",
		"overlayClass",
		"overlayStyle",
		"closeOnClickOverlay",
		"zIndex"
	];
	var toastProps = {
		icon: String,
		show: Boolean,
		type: (0, import_utils$177.makeStringProp)("text"),
		overlay: Boolean,
		message: import_utils$177.numericProp,
		iconSize: import_utils$177.numericProp,
		duration: (0, import_utils$177.makeNumberProp)(2e3),
		position: (0, import_utils$177.makeStringProp)("middle"),
		teleport: [String, Object],
		wordBreak: String,
		className: import_utils$177.unknownProp,
		iconPrefix: String,
		transition: (0, import_utils$177.makeStringProp)("van-fade"),
		loadingType: String,
		forbidClick: Boolean,
		overlayClass: import_utils$177.unknownProp,
		overlayStyle: Object,
		closeOnClick: Boolean,
		closeOnClickOverlay: Boolean,
		zIndex: import_utils$177.numericProp
	};
	var stdin_default$172 = (0, import_vue$95.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;
					(0, import_lock_click.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 (0, import_vue$95.createVNode)(import_icon$25.Icon, {
					"name": icon || type,
					"size": iconSize,
					"class": bem$80("icon"),
					"classPrefix": iconPrefix
				}, null);
				if (type === "loading") return (0, import_vue$95.createVNode)(import_loading$7.Loading, {
					"class": bem$80("loading"),
					"size": iconSize,
					"type": loadingType
				}, null);
			};
			const renderMessage = () => {
				const { type, message } = props$1;
				if (slots.message) return (0, import_vue$95.createVNode)("div", { "class": bem$80("text") }, [slots.message()]);
				if ((0, import_utils$177.isDef)(message) && message !== "") return type === "html" ? (0, import_vue$95.createVNode)("div", {
					"key": 0,
					"class": bem$80("text"),
					"innerHTML": String(message)
				}, null) : (0, import_vue$95.createVNode)("div", { "class": bem$80("text") }, [message]);
			};
			(0, import_vue$95.watch)(() => [props$1.show, props$1.forbidClick], toggleClickable);
			(0, import_vue$95.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);
			});
			(0, import_vue$95.onMounted)(toggleClickable);
			(0, import_vue$95.onUnmounted)(toggleClickable);
			return () => (0, import_vue$95.createVNode)(import_popup$9.Popup, (0, import_vue$95.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
			}, (0, import_utils$177.pick)(props$1, popupInheritProps$1)), { default: () => [renderIcon(), renderMessage()] });
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/utils/mount-component.js
var require_mount_component = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/utils/mount-component.js": ((exports, module) => {
	var __defProp$186 = Object.defineProperty;
	var __getOwnPropDesc$186 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$186 = Object.getOwnPropertyNames;
	var __hasOwnProp$186 = Object.prototype.hasOwnProperty;
	var __export$186 = (target, all) => {
		for (var name$111 in all) __defProp$186(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$186 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$186(from)) if (!__hasOwnProp$186.call(to, key) && key !== except) __defProp$186(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$186(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$186 = (mod) => __copyProps$186(__defProp$186({}, "__esModule", { value: true }), mod);
	var stdin_exports$185 = {};
	__export$186(stdin_exports$185, {
		mountComponent: () => mountComponent,
		usePopupState: () => usePopupState
	});
	module.exports = __toCommonJS$186(stdin_exports$185);
	var import_vue$94 = require_vue();
	var import_basic = require_basic();
	var import_use_expose$25 = require_use_expose();
	function usePopupState() {
		const state = (0, import_vue$94.reactive)({ show: false });
		const toggle = (show) => {
			state.show = show;
		};
		const open = (props$1) => {
			(0, import_basic.extend)(state, props$1, { transitionAppear: true });
			toggle(true);
		};
		const close = () => toggle(false);
		(0, import_use_expose$25.useExpose)({
			open,
			close,
			toggle
		});
		return {
			open,
			close,
			state,
			toggle
		};
	}
	function mountComponent(RootComponent) {
		const app = (0, import_vue$94.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/lib/toast/function-call.js
var require_function_call$3 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/toast/function-call.js": ((exports, module) => {
	var __create$97 = Object.create;
	var __defProp$185 = Object.defineProperty;
	var __getOwnPropDesc$185 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$185 = Object.getOwnPropertyNames;
	var __getProtoOf$97 = Object.getPrototypeOf;
	var __hasOwnProp$185 = Object.prototype.hasOwnProperty;
	var __export$185 = (target, all) => {
		for (var name$111 in all) __defProp$185(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$185 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$185(from)) if (!__hasOwnProp$185.call(to, key) && key !== except) __defProp$185(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$185(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$97 = (mod, isNodeMode, target) => (target = mod != null ? __create$97(__getProtoOf$97(mod)) : {}, __copyProps$185(isNodeMode || !mod || !mod.__esModule ? __defProp$185(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$185 = (mod) => __copyProps$185(__defProp$185({}, "__esModule", { value: true }), mod);
	var stdin_exports$184 = {};
	__export$185(stdin_exports$184, {
		allowMultipleToast: () => allowMultipleToast,
		closeToast: () => closeToast,
		resetToastDefaultOptions: () => resetToastDefaultOptions,
		setToastDefaultOptions: () => setToastDefaultOptions,
		showFailToast: () => showFailToast,
		showLoadingToast: () => showLoadingToast,
		showSuccessToast: () => showSuccessToast,
		showToast: () => showToast
	});
	module.exports = __toCommonJS$185(stdin_exports$184);
	var import_vue$93 = require_vue();
	var import_utils$176 = require_utils$9();
	var import_mount_component$3 = require_mount_component();
	var import_Toast$1 = __toESM$97(require_Toast());
	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 = (0, import_utils$176.extend)({}, defaultOptions$1);
	var defaultOptionsMap = /* @__PURE__ */ new Map();
	function parseOptions$1(message) {
		if ((0, import_utils$176.isObject)(message)) return message;
		return { message };
	}
	function createInstance() {
		const { instance: instance$3, unmount } = (0, import_mount_component$3.mountComponent)({ setup() {
			const message = (0, import_vue$93.ref)("");
			const { open, state, close, toggle } = (0, import_mount_component$3.usePopupState)();
			const onClosed = () => {
				if (allowMultiple) {
					queue = queue.filter((item) => item !== instance$3);
					unmount();
				}
			};
			const render = () => {
				const attrs = {
					onClosed,
					"onUpdate:show": toggle
				};
				return (0, import_vue$93.createVNode)(import_Toast$1.default, (0, import_vue$93.mergeProps)(state, attrs), null);
			};
			(0, import_vue$93.watch)(message, (val) => {
				state.message = val;
			});
			(0, import_vue$93.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 (!import_utils$176.inBrowser) return {};
		const toast = getInstance();
		const parsedOptions = parseOptions$1(options);
		toast.open((0, import_utils$176.extend)({}, currentOptions$2, defaultOptionsMap.get(parsedOptions.type || currentOptions$2.type), parsedOptions));
		return toast;
	}
	var createMethod = (type) => (options) => showToast((0, import_utils$176.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 (0, import_utils$176.extend)(currentOptions$2, type);
	}
	var resetToastDefaultOptions = (type) => {
		if (typeof type === "string") defaultOptionsMap.delete(type);
		else {
			currentOptions$2 = (0, import_utils$176.extend)({}, defaultOptions$1);
			defaultOptionsMap.clear();
		}
	};
	var allowMultipleToast = (value = true) => {
		allowMultiple = value;
	};
}) });

//#endregion
//#region node_modules/vant/lib/toast/index.js
var require_toast = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/toast/index.js": ((exports, module) => {
	var __create$96 = Object.create;
	var __defProp$184 = Object.defineProperty;
	var __getOwnPropDesc$184 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$184 = Object.getOwnPropertyNames;
	var __getProtoOf$96 = Object.getPrototypeOf;
	var __hasOwnProp$184 = Object.prototype.hasOwnProperty;
	var __export$184 = (target, all) => {
		for (var name$111 in all) __defProp$184(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$184 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$184(from)) if (!__hasOwnProp$184.call(to, key) && key !== except) __defProp$184(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$184(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$96 = (mod, isNodeMode, target) => (target = mod != null ? __create$96(__getProtoOf$96(mod)) : {}, __copyProps$184(isNodeMode || !mod || !mod.__esModule ? __defProp$184(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$184 = (mod) => __copyProps$184(__defProp$184({}, "__esModule", { value: true }), mod);
	var stdin_exports$183 = {};
	__export$184(stdin_exports$183, {
		Toast: () => Toast,
		allowMultipleToast: () => import_function_call$3.allowMultipleToast,
		closeToast: () => import_function_call$3.closeToast,
		default: () => stdin_default$171,
		resetToastDefaultOptions: () => import_function_call$3.resetToastDefaultOptions,
		setToastDefaultOptions: () => import_function_call$3.setToastDefaultOptions,
		showFailToast: () => import_function_call$3.showFailToast,
		showLoadingToast: () => import_function_call$3.showLoadingToast,
		showSuccessToast: () => import_function_call$3.showSuccessToast,
		showToast: () => import_function_call$3.showToast,
		toastProps: () => import_Toast2.toastProps
	});
	module.exports = __toCommonJS$184(stdin_exports$183);
	var import_utils$175 = require_utils$9();
	var import_Toast = __toESM$96(require_Toast());
	var import_Toast2 = require_Toast();
	var import_function_call$3 = require_function_call$3();
	var Toast = (0, import_utils$175.withInstall)(import_Toast.default);
	var stdin_default$171 = Toast;
}) });

//#endregion
//#region node_modules/vant/lib/switch/Switch.js
var require_Switch = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/switch/Switch.js": ((exports, module) => {
	var __defProp$183 = Object.defineProperty;
	var __getOwnPropDesc$183 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$183 = Object.getOwnPropertyNames;
	var __hasOwnProp$183 = Object.prototype.hasOwnProperty;
	var __export$183 = (target, all) => {
		for (var name2 in all) __defProp$183(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$183 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$183(from)) if (!__hasOwnProp$183.call(to, key) && key !== except) __defProp$183(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$183(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$183 = (mod) => __copyProps$183(__defProp$183({}, "__esModule", { value: true }), mod);
	var stdin_exports$182 = {};
	__export$183(stdin_exports$182, {
		default: () => stdin_default$170,
		switchProps: () => switchProps
	});
	module.exports = __toCommonJS$183(stdin_exports$182);
	var import_vue$92 = require_vue();
	var import_utils$174 = require_utils$9();
	var import_use$47 = require_index_cjs$1();
	var import_loading$6 = require_loading();
	var [name$83, bem$79] = (0, import_utils$174.createNamespace)("switch");
	var switchProps = {
		size: import_utils$174.numericProp,
		loading: Boolean,
		disabled: Boolean,
		modelValue: import_utils$174.unknownProp,
		activeColor: String,
		inactiveColor: String,
		activeValue: {
			type: import_utils$174.unknownProp,
			default: true
		},
		inactiveValue: {
			type: import_utils$174.unknownProp,
			default: false
		}
	};
	var stdin_default$170 = (0, import_vue$92.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 (0, import_vue$92.createVNode)(import_loading$6.Loading, {
						"class": bem$79("loading"),
						"color": color
					}, null);
				}
				if (slots.node) return slots.node();
			};
			(0, import_use$47.useCustomFieldValue)(() => props$1.modelValue);
			return () => {
				var _a;
				const { size, loading, disabled, activeColor, inactiveColor } = props$1;
				const checked = isChecked();
				const style = {
					fontSize: (0, import_utils$174.addUnit)(size),
					backgroundColor: checked ? activeColor : inactiveColor
				};
				return (0, import_vue$92.createVNode)("div", {
					"role": "switch",
					"class": bem$79({
						on: checked,
						loading,
						disabled
					}),
					"style": style,
					"tabindex": disabled ? void 0 : 0,
					"aria-checked": checked,
					"onClick": onClick
				}, [(0, import_vue$92.createVNode)("div", { "class": bem$79("node") }, [renderLoading()]), (_a = slots.background) == null ? void 0 : _a.call(slots)]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/switch/index.js
var require_switch = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/switch/index.js": ((exports, module) => {
	var __create$95 = Object.create;
	var __defProp$182 = Object.defineProperty;
	var __getOwnPropDesc$182 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$182 = Object.getOwnPropertyNames;
	var __getProtoOf$95 = Object.getPrototypeOf;
	var __hasOwnProp$182 = Object.prototype.hasOwnProperty;
	var __export$182 = (target, all) => {
		for (var name$111 in all) __defProp$182(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$182 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$182(from)) if (!__hasOwnProp$182.call(to, key) && key !== except) __defProp$182(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$182(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$95 = (mod, isNodeMode, target) => (target = mod != null ? __create$95(__getProtoOf$95(mod)) : {}, __copyProps$182(isNodeMode || !mod || !mod.__esModule ? __defProp$182(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$182 = (mod) => __copyProps$182(__defProp$182({}, "__esModule", { value: true }), mod);
	var stdin_exports$181 = {};
	__export$182(stdin_exports$181, {
		Switch: () => Switch,
		default: () => stdin_default$169,
		switchProps: () => import_Switch2.switchProps
	});
	module.exports = __toCommonJS$182(stdin_exports$181);
	var import_utils$173 = require_utils$9();
	var import_Switch = __toESM$95(require_Switch());
	var import_Switch2 = require_Switch();
	var Switch = (0, import_utils$173.withInstall)(import_Switch.default);
	var stdin_default$169 = Switch;
}) });

//#endregion
//#region node_modules/vant/lib/address-edit/AddressEditDetail.js
var require_AddressEditDetail = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/address-edit/AddressEditDetail.js": ((exports, module) => {
	var __defProp$181 = Object.defineProperty;
	var __getOwnPropDesc$181 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$181 = Object.getOwnPropertyNames;
	var __hasOwnProp$181 = Object.prototype.hasOwnProperty;
	var __export$181 = (target, all) => {
		for (var name2 in all) __defProp$181(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$181 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$181(from)) if (!__hasOwnProp$181.call(to, key) && key !== except) __defProp$181(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$181(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$181 = (mod) => __copyProps$181(__defProp$181({}, "__esModule", { value: true }), mod);
	var stdin_exports$180 = {};
	__export$181(stdin_exports$180, { default: () => stdin_default$168 });
	module.exports = __toCommonJS$181(stdin_exports$180);
	var import_vue$91 = require_vue();
	var import_utils$172 = require_utils$9();
	var import_cell$9 = require_cell();
	var import_field$5 = require_field();
	var [name$82, bem$78] = (0, import_utils$172.createNamespace)("address-edit-detail");
	var t$19 = (0, import_utils$172.createNamespace)("address-edit")[2];
	var stdin_default$168 = (0, import_vue$91.defineComponent)({
		name: name$82,
		props: {
			show: Boolean,
			rows: import_utils$172.numericProp,
			value: String,
			rules: Array,
			focused: Boolean,
			maxlength: import_utils$172.numericProp,
			searchResult: Array,
			showSearchResult: Boolean
		},
		emits: [
			"blur",
			"focus",
			"input",
			"selectSearch"
		],
		setup(props$1, { emit }) {
			const field = (0, import_vue$91.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) => (0, import_vue$91.createVNode)(import_cell$9.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 (0, import_vue$91.createVNode)(import_vue$91.Fragment, null, [(0, import_vue$91.createVNode)(import_field$5.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/lib/address-edit/AddressEdit.js
var require_AddressEdit = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/address-edit/AddressEdit.js": ((exports, module) => {
	var __create$94 = Object.create;
	var __defProp$180 = Object.defineProperty;
	var __getOwnPropDesc$180 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$180 = Object.getOwnPropertyNames;
	var __getProtoOf$94 = Object.getPrototypeOf;
	var __hasOwnProp$180 = Object.prototype.hasOwnProperty;
	var __export$180 = (target, all) => {
		for (var name2 in all) __defProp$180(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$180 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$180(from)) if (!__hasOwnProp$180.call(to, key) && key !== except) __defProp$180(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$180(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$94 = (mod, isNodeMode, target) => (target = mod != null ? __create$94(__getProtoOf$94(mod)) : {}, __copyProps$180(isNodeMode || !mod || !mod.__esModule ? __defProp$180(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$180 = (mod) => __copyProps$180(__defProp$180({}, "__esModule", { value: true }), mod);
	var stdin_exports$179 = {};
	__export$180(stdin_exports$179, {
		addressEditProps: () => addressEditProps,
		default: () => stdin_default$167
	});
	module.exports = __toCommonJS$180(stdin_exports$179);
	var import_vue$90 = require_vue();
	var import_utils$171 = require_utils$9();
	var import_use_expose$24 = require_use_expose();
	var import_area$1 = require_area();
	var import_cell$8 = require_cell();
	var import_form$2 = require_form();
	var import_field$4 = require_field();
	var import_popup$8 = require_popup();
	var import_toast$2 = require_toast();
	var import_button$9 = require_button();
	var import_switch$2 = require_switch();
	var import_AddressEditDetail = __toESM$94(require_AddressEditDetail());
	var import_utils2$10 = require_utils$6();
	var [name$81, bem$77, t$18] = (0, import_utils$171.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: import_utils$171.truthProp,
		showDetail: import_utils$171.truthProp,
		showDelete: Boolean,
		disableArea: Boolean,
		searchResult: Array,
		telMaxlength: import_utils$171.numericProp,
		showSetDefault: Boolean,
		saveButtonText: String,
		areaPlaceholder: String,
		deleteButtonText: String,
		showSearchResult: Boolean,
		detailRows: (0, import_utils$171.makeNumericProp)(1),
		detailMaxlength: (0, import_utils$171.makeNumericProp)(200),
		areaColumnsPlaceholder: (0, import_utils$171.makeArrayProp)(),
		addressInfo: {
			type: Object,
			default: () => (0, import_utils$171.extend)({}, DEFAULT_DATA)
		},
		telValidator: {
			type: Function,
			default: import_utils$171.isMobile
		}
	};
	var stdin_default$167 = (0, import_vue$90.defineComponent)({
		name: name$81,
		props: addressEditProps,
		emits: [
			"save",
			"focus",
			"change",
			"delete",
			"clickArea",
			"changeArea",
			"changeDetail",
			"selectSearch",
			"changeDefault"
		],
		setup(props$1, { emit, slots }) {
			const areaRef = (0, import_vue$90.ref)();
			const data = (0, import_vue$90.reactive)({});
			const showAreaPopup = (0, import_vue$90.ref)(false);
			const detailFocused = (0, import_vue$90.ref)(false);
			const areaListLoaded = (0, import_vue$90.computed)(() => (0, import_utils$171.isObject)(props$1.areaList) && Object.keys(props$1.areaList).length);
			const areaText = (0, import_vue$90.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 = (0, import_vue$90.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 = (0, import_vue$90.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 === import_utils2$10.AREA_EMPTY_CODE)) (0, import_toast$2.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": () => (0, import_vue$90.createVNode)(import_switch$2.Switch, {
						"modelValue": data.isDefault,
						"onUpdate:modelValue": ($event) => data.isDefault = $event,
						"onChange": (event) => emit("changeDefault", event)
					}, null) };
					return (0, import_vue$90.withDirectives)((0, import_vue$90.createVNode)(import_cell$8.Cell, {
						"center": true,
						"border": false,
						"title": t$18("defaultAddress"),
						"class": bem$77("default")
					}, slots2), [[import_vue$90.vShow, !hideBottomFields.value]]);
				}
			};
			(0, import_use_expose$24.useExpose)({
				setAreaCode,
				setAddressDetail
			});
			(0, import_vue$90.watch)(() => props$1.addressInfo, (value) => {
				(0, import_utils$171.extend)(data, DEFAULT_DATA, value);
				(0, import_vue$90.nextTick)(() => {
					var _a;
					const options = (_a = areaRef.value) == null ? void 0 : _a.getSelectedOptions();
					if (options && options.every((option) => option && option.value !== import_utils2$10.AREA_EMPTY_CODE)) assignAreaText(options);
				});
			}, {
				deep: true,
				immediate: true
			});
			return () => {
				const { disableArea } = props$1;
				return (0, import_vue$90.createVNode)(import_form$2.Form, {
					"class": bem$77(),
					"onSubmit": onSave
				}, { default: () => {
					var _a;
					return [
						(0, import_vue$90.createVNode)("div", { "class": bem$77("fields") }, [
							(0, import_vue$90.createVNode)(import_field$4.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),
							(0, import_vue$90.createVNode)(import_field$4.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),
							(0, import_vue$90.withDirectives)((0, import_vue$90.createVNode)(import_field$4.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), [[import_vue$90.vShow, props$1.showArea]]),
							(0, import_vue$90.createVNode)(import_AddressEditDetail.default, {
								"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(),
						(0, import_vue$90.withDirectives)((0, import_vue$90.createVNode)("div", { "class": bem$77("buttons") }, [(0, import_vue$90.createVNode)(import_button$9.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 && (0, import_vue$90.createVNode)(import_button$9.Button, {
							"block": true,
							"round": true,
							"class": bem$77("button"),
							"loading": props$1.isDeleting,
							"text": props$1.deleteButtonText || t$18("delete"),
							"onClick": onDelete
						}, null)]), [[import_vue$90.vShow, !hideBottomFields.value]]),
						(0, import_vue$90.createVNode)(import_popup$8.Popup, {
							"show": showAreaPopup.value,
							"onUpdate:show": ($event) => showAreaPopup.value = $event,
							"round": true,
							"teleport": "body",
							"position": "bottom",
							"lazyRender": false
						}, { default: () => [(0, import_vue$90.createVNode)(import_area$1.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/lib/address-edit/index.js
var require_address_edit = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/address-edit/index.js": ((exports, module) => {
	var __create$93 = Object.create;
	var __defProp$179 = Object.defineProperty;
	var __getOwnPropDesc$179 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$179 = Object.getOwnPropertyNames;
	var __getProtoOf$93 = Object.getPrototypeOf;
	var __hasOwnProp$179 = Object.prototype.hasOwnProperty;
	var __export$179 = (target, all) => {
		for (var name$111 in all) __defProp$179(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$179 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$179(from)) if (!__hasOwnProp$179.call(to, key) && key !== except) __defProp$179(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$179(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$93 = (mod, isNodeMode, target) => (target = mod != null ? __create$93(__getProtoOf$93(mod)) : {}, __copyProps$179(isNodeMode || !mod || !mod.__esModule ? __defProp$179(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$179 = (mod) => __copyProps$179(__defProp$179({}, "__esModule", { value: true }), mod);
	var stdin_exports$178 = {};
	__export$179(stdin_exports$178, {
		AddressEdit: () => AddressEdit,
		addressEditProps: () => import_AddressEdit2.addressEditProps,
		default: () => stdin_default$166
	});
	module.exports = __toCommonJS$179(stdin_exports$178);
	var import_utils$170 = require_utils$9();
	var import_AddressEdit = __toESM$93(require_AddressEdit());
	var import_AddressEdit2 = require_AddressEdit();
	var AddressEdit = (0, import_utils$170.withInstall)(import_AddressEdit.default);
	var stdin_default$166 = AddressEdit;
}) });

//#endregion
//#region node_modules/vant/lib/radio-group/RadioGroup.js
var require_RadioGroup = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/radio-group/RadioGroup.js": ((exports, module) => {
	var __defProp$178 = Object.defineProperty;
	var __getOwnPropDesc$178 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$178 = Object.getOwnPropertyNames;
	var __hasOwnProp$178 = Object.prototype.hasOwnProperty;
	var __export$178 = (target, all) => {
		for (var name2 in all) __defProp$178(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$178 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$178(from)) if (!__hasOwnProp$178.call(to, key) && key !== except) __defProp$178(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$178(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$178 = (mod) => __copyProps$178(__defProp$178({}, "__esModule", { value: true }), mod);
	var stdin_exports$177 = {};
	__export$178(stdin_exports$177, {
		RADIO_KEY: () => RADIO_KEY,
		default: () => stdin_default$165,
		radioGroupProps: () => radioGroupProps
	});
	module.exports = __toCommonJS$178(stdin_exports$177);
	var import_vue$89 = require_vue();
	var import_utils$169 = require_utils$9();
	var import_use$46 = require_index_cjs$1();
	var [name$80, bem$76] = (0, import_utils$169.createNamespace)("radio-group");
	var radioGroupProps = {
		shape: String,
		disabled: Boolean,
		iconSize: import_utils$169.numericProp,
		direction: String,
		modelValue: import_utils$169.unknownProp,
		checkedColor: String
	};
	var RADIO_KEY = Symbol(name$80);
	var stdin_default$165 = (0, import_vue$89.defineComponent)({
		name: name$80,
		props: radioGroupProps,
		emits: ["change", "update:modelValue"],
		setup(props$1, { emit, slots }) {
			const { linkChildren } = (0, import_use$46.useChildren)(RADIO_KEY);
			const updateValue = (value) => emit("update:modelValue", value);
			(0, import_vue$89.watch)(() => props$1.modelValue, (value) => emit("change", value));
			linkChildren({
				props: props$1,
				updateValue
			});
			(0, import_use$46.useCustomFieldValue)(() => props$1.modelValue);
			return () => {
				var _a;
				return (0, import_vue$89.createVNode)("div", {
					"class": bem$76([props$1.direction]),
					"role": "radiogroup"
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/radio-group/index.js
var require_radio_group = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/radio-group/index.js": ((exports, module) => {
	var __create$92 = Object.create;
	var __defProp$177 = Object.defineProperty;
	var __getOwnPropDesc$177 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$177 = Object.getOwnPropertyNames;
	var __getProtoOf$92 = Object.getPrototypeOf;
	var __hasOwnProp$177 = Object.prototype.hasOwnProperty;
	var __export$177 = (target, all) => {
		for (var name$111 in all) __defProp$177(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$177 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$177(from)) if (!__hasOwnProp$177.call(to, key) && key !== except) __defProp$177(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$177(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$92 = (mod, isNodeMode, target) => (target = mod != null ? __create$92(__getProtoOf$92(mod)) : {}, __copyProps$177(isNodeMode || !mod || !mod.__esModule ? __defProp$177(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$177 = (mod) => __copyProps$177(__defProp$177({}, "__esModule", { value: true }), mod);
	var stdin_exports$176 = {};
	__export$177(stdin_exports$176, {
		RadioGroup: () => RadioGroup,
		default: () => stdin_default$164,
		radioGroupProps: () => import_RadioGroup2.radioGroupProps
	});
	module.exports = __toCommonJS$177(stdin_exports$176);
	var import_utils$168 = require_utils$9();
	var import_RadioGroup$1 = __toESM$92(require_RadioGroup());
	var import_RadioGroup2 = require_RadioGroup();
	var RadioGroup = (0, import_utils$168.withInstall)(import_RadioGroup$1.default);
	var stdin_default$164 = RadioGroup;
}) });

//#endregion
//#region node_modules/vant/lib/checkbox-group/CheckboxGroup.js
var require_CheckboxGroup = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/checkbox-group/CheckboxGroup.js": ((exports, module) => {
	var __defProp$176 = Object.defineProperty;
	var __getOwnPropDesc$176 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$176 = Object.getOwnPropertyNames;
	var __hasOwnProp$176 = Object.prototype.hasOwnProperty;
	var __export$176 = (target, all) => {
		for (var name2 in all) __defProp$176(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$176 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$176(from)) if (!__hasOwnProp$176.call(to, key) && key !== except) __defProp$176(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$176(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$176 = (mod) => __copyProps$176(__defProp$176({}, "__esModule", { value: true }), mod);
	var stdin_exports$175 = {};
	__export$176(stdin_exports$175, {
		CHECKBOX_GROUP_KEY: () => CHECKBOX_GROUP_KEY,
		checkboxGroupProps: () => checkboxGroupProps,
		default: () => stdin_default$163
	});
	module.exports = __toCommonJS$176(stdin_exports$175);
	var import_vue$88 = require_vue();
	var import_utils$167 = require_utils$9();
	var import_use$45 = require_index_cjs$1();
	var import_use_expose$23 = require_use_expose();
	var [name$79, bem$75] = (0, import_utils$167.createNamespace)("checkbox-group");
	var checkboxGroupProps = {
		max: import_utils$167.numericProp,
		shape: (0, import_utils$167.makeStringProp)("round"),
		disabled: Boolean,
		iconSize: import_utils$167.numericProp,
		direction: String,
		modelValue: (0, import_utils$167.makeArrayProp)(),
		checkedColor: String
	};
	var CHECKBOX_GROUP_KEY = Symbol(name$79);
	var stdin_default$163 = (0, import_vue$88.defineComponent)({
		name: name$79,
		props: checkboxGroupProps,
		emits: ["change", "update:modelValue"],
		setup(props$1, { emit, slots }) {
			const { children, linkChildren } = (0, import_use$45.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));
			};
			(0, import_vue$88.watch)(() => props$1.modelValue, (value) => emit("change", value));
			(0, import_use_expose$23.useExpose)({ toggleAll });
			(0, import_use$45.useCustomFieldValue)(() => props$1.modelValue);
			linkChildren({
				props: props$1,
				updateValue
			});
			return () => {
				var _a;
				return (0, import_vue$88.createVNode)("div", { "class": bem$75([props$1.direction]) }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/checkbox-group/index.js
var require_checkbox_group = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/checkbox-group/index.js": ((exports, module) => {
	var __create$91 = Object.create;
	var __defProp$175 = Object.defineProperty;
	var __getOwnPropDesc$175 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$175 = Object.getOwnPropertyNames;
	var __getProtoOf$91 = Object.getPrototypeOf;
	var __hasOwnProp$175 = Object.prototype.hasOwnProperty;
	var __export$175 = (target, all) => {
		for (var name$111 in all) __defProp$175(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$175 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$175(from)) if (!__hasOwnProp$175.call(to, key) && key !== except) __defProp$175(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$175(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$91 = (mod, isNodeMode, target) => (target = mod != null ? __create$91(__getProtoOf$91(mod)) : {}, __copyProps$175(isNodeMode || !mod || !mod.__esModule ? __defProp$175(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$175 = (mod) => __copyProps$175(__defProp$175({}, "__esModule", { value: true }), mod);
	var stdin_exports$174 = {};
	__export$175(stdin_exports$174, {
		CheckboxGroup: () => CheckboxGroup,
		checkboxGroupProps: () => import_CheckboxGroup2.checkboxGroupProps,
		default: () => stdin_default$162
	});
	module.exports = __toCommonJS$175(stdin_exports$174);
	var import_utils$166 = require_utils$9();
	var import_CheckboxGroup$1 = __toESM$91(require_CheckboxGroup());
	var import_CheckboxGroup2 = require_CheckboxGroup();
	var CheckboxGroup = (0, import_utils$166.withInstall)(import_CheckboxGroup$1.default);
	var stdin_default$162 = CheckboxGroup;
}) });

//#endregion
//#region node_modules/vant/lib/tag/Tag.js
var require_Tag = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tag/Tag.js": ((exports, module) => {
	var __defProp$174 = Object.defineProperty;
	var __getOwnPropDesc$174 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$174 = Object.getOwnPropertyNames;
	var __hasOwnProp$174 = Object.prototype.hasOwnProperty;
	var __export$174 = (target, all) => {
		for (var name2 in all) __defProp$174(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$174 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$174(from)) if (!__hasOwnProp$174.call(to, key) && key !== except) __defProp$174(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$174(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$174 = (mod) => __copyProps$174(__defProp$174({}, "__esModule", { value: true }), mod);
	var stdin_exports$173 = {};
	__export$174(stdin_exports$173, {
		default: () => stdin_default$161,
		tagProps: () => tagProps
	});
	module.exports = __toCommonJS$174(stdin_exports$173);
	var import_vue$87 = require_vue();
	var import_utils$165 = require_utils$9();
	var import_icon$24 = require_icon();
	var [name$78, bem$74] = (0, import_utils$165.createNamespace)("tag");
	var tagProps = {
		size: String,
		mark: Boolean,
		show: import_utils$165.truthProp,
		type: (0, import_utils$165.makeStringProp)("default"),
		color: String,
		plain: Boolean,
		round: Boolean,
		textColor: String,
		closeable: Boolean
	};
	var stdin_default$161 = (0, import_vue$87.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 && (0, import_vue$87.createVNode)(import_icon$24.Icon, {
					"name": "cross",
					"class": [bem$74("close"), import_utils$165.HAPTICS_FEEDBACK],
					"onClick": onClose
				}, null);
				return (0, import_vue$87.createVNode)("span", {
					"style": getStyle(),
					"class": bem$74([classes, type])
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots), CloseIcon]);
			};
			return () => (0, import_vue$87.createVNode)(import_vue$87.Transition, { "name": props$1.closeable ? "van-fade" : void 0 }, { default: () => [props$1.show ? renderTag() : null] });
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/tag/index.js
var require_tag = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tag/index.js": ((exports, module) => {
	var __create$90 = Object.create;
	var __defProp$173 = Object.defineProperty;
	var __getOwnPropDesc$173 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$173 = Object.getOwnPropertyNames;
	var __getProtoOf$90 = Object.getPrototypeOf;
	var __hasOwnProp$173 = Object.prototype.hasOwnProperty;
	var __export$173 = (target, all) => {
		for (var name$111 in all) __defProp$173(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$173 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$173(from)) if (!__hasOwnProp$173.call(to, key) && key !== except) __defProp$173(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$173(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$90 = (mod, isNodeMode, target) => (target = mod != null ? __create$90(__getProtoOf$90(mod)) : {}, __copyProps$173(isNodeMode || !mod || !mod.__esModule ? __defProp$173(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$173 = (mod) => __copyProps$173(__defProp$173({}, "__esModule", { value: true }), mod);
	var stdin_exports$172 = {};
	__export$173(stdin_exports$172, {
		Tag: () => Tag,
		default: () => stdin_default$160,
		tagProps: () => import_Tag2.tagProps
	});
	module.exports = __toCommonJS$173(stdin_exports$172);
	var import_utils$164 = require_utils$9();
	var import_Tag = __toESM$90(require_Tag());
	var import_Tag2 = require_Tag();
	var Tag = (0, import_utils$164.withInstall)(import_Tag.default);
	var stdin_default$160 = Tag;
}) });

//#endregion
//#region node_modules/vant/lib/checkbox/Checker.js
var require_Checker = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/checkbox/Checker.js": ((exports, module) => {
	var __defProp$172 = Object.defineProperty;
	var __getOwnPropDesc$172 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$172 = Object.getOwnPropertyNames;
	var __hasOwnProp$172 = Object.prototype.hasOwnProperty;
	var __export$172 = (target, all) => {
		for (var name$111 in all) __defProp$172(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$172 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$172(from)) if (!__hasOwnProp$172.call(to, key) && key !== except) __defProp$172(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$172(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$172 = (mod) => __copyProps$172(__defProp$172({}, "__esModule", { value: true }), mod);
	var stdin_exports$171 = {};
	__export$172(stdin_exports$171, {
		checkerProps: () => checkerProps,
		default: () => stdin_default$159
	});
	module.exports = __toCommonJS$172(stdin_exports$171);
	var import_vue$86 = require_vue();
	var import_utils$163 = require_utils$9();
	var import_icon$23 = require_icon();
	var checkerProps = {
		name: import_utils$163.unknownProp,
		disabled: Boolean,
		iconSize: import_utils$163.numericProp,
		modelValue: import_utils$163.unknownProp,
		checkedColor: String,
		labelPosition: String,
		labelDisabled: Boolean
	};
	var stdin_default$159 = (0, import_vue$86.defineComponent)({
		props: (0, import_utils$163.extend)({}, checkerProps, {
			bem: (0, import_utils$163.makeRequiredProp)(Function),
			role: String,
			shape: String,
			parent: Object,
			checked: Boolean,
			bindGroup: import_utils$163.truthProp,
			indeterminate: {
				type: Boolean,
				default: null
			}
		}),
		emits: ["click", "toggle"],
		setup(props$1, { emit, slots }) {
			const iconRef = (0, import_vue$86.ref)();
			const getParentProp = (name$111) => {
				if (props$1.parent && props$1.bindGroup) return props$1.parent.props[name$111];
			};
			const disabled = (0, import_vue$86.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 = (0, import_vue$86.computed)(() => getParentProp("direction"));
			const iconStyle = (0, import_vue$86.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 = (0, import_vue$86.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 (0, import_vue$86.createVNode)("div", {
					"ref": iconRef,
					"class": bem$106("icon", [shape.value, {
						disabled: disabled.value,
						checked,
						indeterminate
					}]),
					"style": shape.value !== "dot" ? { fontSize: (0, import_utils$163.addUnit)(iconSize) } : {
						width: (0, import_utils$163.addUnit)(iconSize),
						height: (0, import_utils$163.addUnit)(iconSize),
						borderColor: (_a = iconStyle.value) == null ? void 0 : _a.borderColor
					}
				}, [slots.icon ? slots.icon({
					checked,
					disabled: disabled.value
				}) : shape.value !== "dot" ? (0, import_vue$86.createVNode)(import_icon$23.Icon, {
					"name": indeterminate ? "minus" : "success",
					"style": iconStyle.value
				}, null) : (0, import_vue$86.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 (0, import_vue$86.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 (0, import_vue$86.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/lib/radio/Radio.js
var require_Radio = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/radio/Radio.js": ((exports, module) => {
	var __create$89 = Object.create;
	var __defProp$171 = Object.defineProperty;
	var __getOwnPropDesc$171 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$171 = Object.getOwnPropertyNames;
	var __getProtoOf$89 = Object.getPrototypeOf;
	var __hasOwnProp$171 = Object.prototype.hasOwnProperty;
	var __export$171 = (target, all) => {
		for (var name2 in all) __defProp$171(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$171 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$171(from)) if (!__hasOwnProp$171.call(to, key) && key !== except) __defProp$171(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$171(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$89 = (mod, isNodeMode, target) => (target = mod != null ? __create$89(__getProtoOf$89(mod)) : {}, __copyProps$171(isNodeMode || !mod || !mod.__esModule ? __defProp$171(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$171 = (mod) => __copyProps$171(__defProp$171({}, "__esModule", { value: true }), mod);
	var stdin_exports$170 = {};
	__export$171(stdin_exports$170, {
		default: () => stdin_default$158,
		radioProps: () => radioProps
	});
	module.exports = __toCommonJS$171(stdin_exports$170);
	var import_vue$85 = require_vue();
	var import_utils$162 = require_utils$9();
	var import_RadioGroup = require_RadioGroup();
	var import_use$44 = require_index_cjs$1();
	var import_Checker$1 = __toESM$89(require_Checker());
	var radioProps = (0, import_utils$162.extend)({}, import_Checker$1.checkerProps, { shape: String });
	var [name$77, bem$73] = (0, import_utils$162.createNamespace)("radio");
	var stdin_default$158 = (0, import_vue$85.defineComponent)({
		name: name$77,
		props: radioProps,
		emits: ["update:modelValue"],
		setup(props$1, { emit, slots }) {
			const { parent } = (0, import_use$44.useParent)(import_RadioGroup.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 () => (0, import_vue$85.createVNode)(import_Checker$1.default, (0, import_vue$85.mergeProps)({
				"bem": bem$73,
				"role": "radio",
				"parent": parent,
				"checked": checked(),
				"onToggle": toggle
			}, props$1), (0, import_utils$162.pick)(slots, ["default", "icon"]));
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/radio/index.js
var require_radio = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/radio/index.js": ((exports, module) => {
	var __create$88 = Object.create;
	var __defProp$170 = Object.defineProperty;
	var __getOwnPropDesc$170 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$170 = Object.getOwnPropertyNames;
	var __getProtoOf$88 = Object.getPrototypeOf;
	var __hasOwnProp$170 = Object.prototype.hasOwnProperty;
	var __export$170 = (target, all) => {
		for (var name$111 in all) __defProp$170(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$170 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$170(from)) if (!__hasOwnProp$170.call(to, key) && key !== except) __defProp$170(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$170(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$88 = (mod, isNodeMode, target) => (target = mod != null ? __create$88(__getProtoOf$88(mod)) : {}, __copyProps$170(isNodeMode || !mod || !mod.__esModule ? __defProp$170(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$170 = (mod) => __copyProps$170(__defProp$170({}, "__esModule", { value: true }), mod);
	var stdin_exports$169 = {};
	__export$170(stdin_exports$169, {
		Radio: () => Radio,
		default: () => stdin_default$157,
		radioProps: () => import_Radio2.radioProps
	});
	module.exports = __toCommonJS$170(stdin_exports$169);
	var import_utils$161 = require_utils$9();
	var import_Radio = __toESM$88(require_Radio());
	var import_Radio2 = require_Radio();
	var Radio = (0, import_utils$161.withInstall)(import_Radio.default);
	var stdin_default$157 = Radio;
}) });

//#endregion
//#region node_modules/vant/lib/checkbox/Checkbox.js
var require_Checkbox = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/checkbox/Checkbox.js": ((exports, module) => {
	var __create$87 = Object.create;
	var __defProp$169 = Object.defineProperty;
	var __getOwnPropDesc$169 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$169 = Object.getOwnPropertyNames;
	var __getProtoOf$87 = Object.getPrototypeOf;
	var __hasOwnProp$169 = Object.prototype.hasOwnProperty;
	var __export$169 = (target, all) => {
		for (var name2 in all) __defProp$169(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$169 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$169(from)) if (!__hasOwnProp$169.call(to, key) && key !== except) __defProp$169(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$169(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$87 = (mod, isNodeMode, target) => (target = mod != null ? __create$87(__getProtoOf$87(mod)) : {}, __copyProps$169(isNodeMode || !mod || !mod.__esModule ? __defProp$169(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$169 = (mod) => __copyProps$169(__defProp$169({}, "__esModule", { value: true }), mod);
	var stdin_exports$168 = {};
	__export$169(stdin_exports$168, {
		checkboxProps: () => checkboxProps,
		default: () => stdin_default$156
	});
	module.exports = __toCommonJS$169(stdin_exports$168);
	var import_vue$84 = require_vue();
	var import_utils$160 = require_utils$9();
	var import_CheckboxGroup = require_CheckboxGroup();
	var import_use$43 = require_index_cjs$1();
	var import_use_expose$22 = require_use_expose();
	var import_Checker = __toESM$87(require_Checker());
	var [name$76, bem$72] = (0, import_utils$160.createNamespace)("checkbox");
	var checkboxProps = (0, import_utils$160.extend)({}, import_Checker.checkerProps, {
		shape: String,
		bindGroup: import_utils$160.truthProp,
		indeterminate: {
			type: Boolean,
			default: null
		}
	});
	var stdin_default$156 = (0, import_vue$84.defineComponent)({
		name: name$76,
		props: checkboxProps,
		emits: ["change", "update:modelValue"],
		setup(props$1, { emit, slots }) {
			const { parent } = (0, import_use$43.useParent)(import_CheckboxGroup.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 = (0, import_vue$84.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);
			};
			(0, import_vue$84.watch)(() => props$1.modelValue, (value) => {
				if (props$1.indeterminate === null) emit("change", value);
			});
			(0, import_use_expose$22.useExpose)({
				toggle,
				props: props$1,
				checked
			});
			(0, import_use$43.useCustomFieldValue)(() => props$1.modelValue);
			return () => (0, import_vue$84.createVNode)(import_Checker.default, (0, import_vue$84.mergeProps)({
				"bem": bem$72,
				"role": "checkbox",
				"parent": parent,
				"checked": checked.value,
				"onToggle": toggle
			}, props$1), (0, import_utils$160.pick)(slots, ["default", "icon"]));
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/checkbox/index.js
var require_checkbox = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/checkbox/index.js": ((exports, module) => {
	var __create$86 = Object.create;
	var __defProp$168 = Object.defineProperty;
	var __getOwnPropDesc$168 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$168 = Object.getOwnPropertyNames;
	var __getProtoOf$86 = Object.getPrototypeOf;
	var __hasOwnProp$168 = Object.prototype.hasOwnProperty;
	var __export$168 = (target, all) => {
		for (var name$111 in all) __defProp$168(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$168 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$168(from)) if (!__hasOwnProp$168.call(to, key) && key !== except) __defProp$168(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$168(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$86 = (mod, isNodeMode, target) => (target = mod != null ? __create$86(__getProtoOf$86(mod)) : {}, __copyProps$168(isNodeMode || !mod || !mod.__esModule ? __defProp$168(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$168 = (mod) => __copyProps$168(__defProp$168({}, "__esModule", { value: true }), mod);
	var stdin_exports$167 = {};
	__export$168(stdin_exports$167, {
		Checkbox: () => Checkbox,
		checkboxProps: () => import_Checkbox2.checkboxProps,
		default: () => stdin_default$155
	});
	module.exports = __toCommonJS$168(stdin_exports$167);
	var import_utils$159 = require_utils$9();
	var import_Checkbox = __toESM$86(require_Checkbox());
	var import_Checkbox2 = require_Checkbox();
	var Checkbox = (0, import_utils$159.withInstall)(import_Checkbox.default);
	var stdin_default$155 = Checkbox;
}) });

//#endregion
//#region node_modules/vant/lib/address-list/AddressListItem.js
var require_AddressListItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/address-list/AddressListItem.js": ((exports, module) => {
	var __defProp$167 = Object.defineProperty;
	var __getOwnPropDesc$167 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$167 = Object.getOwnPropertyNames;
	var __hasOwnProp$167 = Object.prototype.hasOwnProperty;
	var __export$167 = (target, all) => {
		for (var name2 in all) __defProp$167(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$167 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$167(from)) if (!__hasOwnProp$167.call(to, key) && key !== except) __defProp$167(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$167(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$167 = (mod) => __copyProps$167(__defProp$167({}, "__esModule", { value: true }), mod);
	var stdin_exports$166 = {};
	__export$167(stdin_exports$166, { default: () => stdin_default$154 });
	module.exports = __toCommonJS$167(stdin_exports$166);
	var import_vue$83 = require_vue();
	var import_utils$158 = require_utils$9();
	var import_tag$3 = require_tag();
	var import_icon$22 = require_icon();
	var import_cell$7 = require_cell();
	var import_radio$2 = require_radio();
	var import_checkbox$2 = require_checkbox();
	var [name$75, bem$71] = (0, import_utils$158.createNamespace)("address-item");
	var stdin_default$154 = (0, import_vue$83.defineComponent)({
		name: name$75,
		props: {
			address: (0, import_utils$158.makeRequiredProp)(Object),
			disabled: Boolean,
			switchable: Boolean,
			singleChoice: Boolean,
			defaultTagText: String,
			rightIcon: (0, import_utils$158.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 = () => (0, import_vue$83.createVNode)(import_icon$22.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 (0, import_vue$83.createVNode)(import_tag$3.Tag, {
					"type": "primary",
					"round": true,
					"class": bem$71("tag")
				}, { default: () => [props$1.defaultTagText] });
			};
			const renderContent = () => {
				const { address, disabled, switchable, singleChoice } = props$1;
				const Info = [(0, import_vue$83.createVNode)("div", { "class": bem$71("name") }, [`${address.name} ${address.tel}`, renderTag()]), (0, import_vue$83.createVNode)("div", { "class": bem$71("address") }, [address.address])];
				if (switchable && !disabled) if (singleChoice) return (0, import_vue$83.createVNode)(import_radio$2.Radio, {
					"name": address.id,
					"iconSize": 18
				}, { default: () => [Info] });
				else return (0, import_vue$83.createVNode)(import_checkbox$2.Checkbox, {
					"name": address.id,
					"iconSize": 18
				}, { default: () => [Info] });
				return Info;
			};
			return () => {
				var _a;
				const { disabled } = props$1;
				return (0, import_vue$83.createVNode)("div", {
					"class": bem$71({ disabled }),
					"onClick": onClick
				}, [(0, import_vue$83.createVNode)(import_cell$7.Cell, {
					"border": false,
					"titleClass": bem$71("title")
				}, {
					title: renderContent,
					"right-icon": renderRightIcon
				}), (_a = slots.bottom) == null ? void 0 : _a.call(slots, (0, import_utils$158.extend)({}, props$1.address, { disabled }))]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/address-list/AddressList.js
var require_AddressList = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/address-list/AddressList.js": ((exports, module) => {
	var __create$85 = Object.create;
	var __defProp$166 = Object.defineProperty;
	var __getOwnPropDesc$166 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$166 = Object.getOwnPropertyNames;
	var __getProtoOf$85 = Object.getPrototypeOf;
	var __hasOwnProp$166 = Object.prototype.hasOwnProperty;
	var __export$166 = (target, all) => {
		for (var name2 in all) __defProp$166(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$166 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$166(from)) if (!__hasOwnProp$166.call(to, key) && key !== except) __defProp$166(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$166(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$85 = (mod, isNodeMode, target) => (target = mod != null ? __create$85(__getProtoOf$85(mod)) : {}, __copyProps$166(isNodeMode || !mod || !mod.__esModule ? __defProp$166(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$166 = (mod) => __copyProps$166(__defProp$166({}, "__esModule", { value: true }), mod);
	var stdin_exports$165 = {};
	__export$166(stdin_exports$165, {
		addressListProps: () => addressListProps,
		default: () => stdin_default$153
	});
	module.exports = __toCommonJS$166(stdin_exports$165);
	var import_vue$82 = require_vue();
	var import_utils$157 = require_utils$9();
	var import_button$8 = require_button();
	var import_radio_group$2 = require_radio_group();
	var import_checkbox_group$1 = require_checkbox_group();
	var import_AddressListItem = __toESM$85(require_AddressListItem());
	var [name$74, bem$70, t$17] = (0, import_utils$157.createNamespace)("address-list");
	var addressListProps = {
		list: (0, import_utils$157.makeArrayProp)(),
		modelValue: [...import_utils$157.numericProp, Array],
		switchable: import_utils$157.truthProp,
		disabledText: String,
		disabledList: (0, import_utils$157.makeArrayProp)(),
		showAddButton: import_utils$157.truthProp,
		addButtonText: String,
		defaultTagText: String,
		rightIcon: (0, import_utils$157.makeStringProp)("edit")
	};
	var stdin_default$153 = (0, import_vue$82.defineComponent)({
		name: name$74,
		props: addressListProps,
		emits: [
			"add",
			"edit",
			"select",
			"clickItem",
			"editDisabled",
			"selectDisabled",
			"update:modelValue"
		],
		setup(props$1, { slots, emit }) {
			const singleChoice = (0, import_vue$82.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 (0, import_vue$82.createVNode)(import_AddressListItem.default, {
					"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 ? (0, import_vue$82.createVNode)("div", { "class": [bem$70("bottom"), "van-safe-area-bottom"] }, [(0, import_vue$82.createVNode)(import_button$8.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 && (0, import_vue$82.createVNode)("div", { "class": bem$70("disabled-text") }, [props$1.disabledText]);
				return (0, import_vue$82.createVNode)("div", { "class": bem$70() }, [
					(_a = slots.top) == null ? void 0 : _a.call(slots),
					!singleChoice.value && Array.isArray(props$1.modelValue) ? (0, import_vue$82.createVNode)(import_checkbox_group$1.CheckboxGroup, { "modelValue": props$1.modelValue }, { default: () => [List$1] }) : (0, import_vue$82.createVNode)(import_radio_group$2.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/lib/address-list/index.js
var require_address_list = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/address-list/index.js": ((exports, module) => {
	var __create$84 = Object.create;
	var __defProp$165 = Object.defineProperty;
	var __getOwnPropDesc$165 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$165 = Object.getOwnPropertyNames;
	var __getProtoOf$84 = Object.getPrototypeOf;
	var __hasOwnProp$165 = Object.prototype.hasOwnProperty;
	var __export$165 = (target, all) => {
		for (var name$111 in all) __defProp$165(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$165 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$165(from)) if (!__hasOwnProp$165.call(to, key) && key !== except) __defProp$165(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$165(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$84 = (mod, isNodeMode, target) => (target = mod != null ? __create$84(__getProtoOf$84(mod)) : {}, __copyProps$165(isNodeMode || !mod || !mod.__esModule ? __defProp$165(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$165 = (mod) => __copyProps$165(__defProp$165({}, "__esModule", { value: true }), mod);
	var stdin_exports$164 = {};
	__export$165(stdin_exports$164, {
		AddressList: () => AddressList,
		addressListProps: () => import_AddressList2.addressListProps,
		default: () => stdin_default$152
	});
	module.exports = __toCommonJS$165(stdin_exports$164);
	var import_utils$156 = require_utils$9();
	var import_AddressList = __toESM$84(require_AddressList());
	var import_AddressList2 = require_AddressList();
	var AddressList = (0, import_utils$156.withInstall)(import_AddressList.default);
	var stdin_default$152 = AddressList;
}) });

//#endregion
//#region node_modules/vant/lib/lazyload/vue-lazyload/util.js
var require_util = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/lazyload/vue-lazyload/util.js": ((exports, module) => {
	var __defProp$164 = Object.defineProperty;
	var __getOwnPropDesc$164 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$164 = Object.getOwnPropertyNames;
	var __hasOwnProp$164 = Object.prototype.hasOwnProperty;
	var __export$164 = (target, all) => {
		for (var name$111 in all) __defProp$164(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$164 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$164(from)) if (!__hasOwnProp$164.call(to, key) && key !== except) __defProp$164(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$164(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$164 = (mod) => __copyProps$164(__defProp$164({}, "__esModule", { value: true }), mod);
	var stdin_exports$163 = {};
	__export$164(stdin_exports$163, {
		ImageCache: () => ImageCache,
		getBestSelectionFromSrcset: () => getBestSelectionFromSrcset,
		getDPR: () => getDPR,
		hasIntersectionObserver: () => hasIntersectionObserver,
		loadImageAsync: () => loadImageAsync,
		modeType: () => modeType,
		off: () => off,
		on: () => on,
		remove: () => remove,
		supportWebp: () => supportWebp,
		throttle: () => throttle
	});
	module.exports = __toCommonJS$164(stdin_exports$163);
	var import_use$42 = require_index_cjs$1();
	var hasIntersectionObserver = import_use$42.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) => import_use$42.inBrowser ? window.devicePixelRatio || scale : scale;
	function supportWebp() {
		if (!import_use$42.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/lib/back-top/BackTop.js
var require_BackTop = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/back-top/BackTop.js": ((exports, module) => {
	var __defProp$163 = Object.defineProperty;
	var __getOwnPropDesc$163 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$163 = Object.getOwnPropertyNames;
	var __hasOwnProp$163 = Object.prototype.hasOwnProperty;
	var __export$163 = (target, all) => {
		for (var name2 in all) __defProp$163(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$163 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$163(from)) if (!__hasOwnProp$163.call(to, key) && key !== except) __defProp$163(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$163(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$163 = (mod) => __copyProps$163(__defProp$163({}, "__esModule", { value: true }), mod);
	var stdin_exports$162 = {};
	__export$163(stdin_exports$162, {
		backTopProps: () => backTopProps,
		default: () => stdin_default$151
	});
	module.exports = __toCommonJS$163(stdin_exports$162);
	var import_vue$81 = require_vue();
	var import_utils$155 = require_utils$9();
	var import_util$4 = require_util();
	var import_use$41 = require_index_cjs$1();
	var import_icon$21 = require_icon();
	var [name$73, bem$69] = (0, import_utils$155.createNamespace)("back-top");
	var backTopProps = {
		right: import_utils$155.numericProp,
		bottom: import_utils$155.numericProp,
		zIndex: import_utils$155.numericProp,
		target: [String, Object],
		offset: (0, import_utils$155.makeNumericProp)(200),
		immediate: Boolean,
		teleport: {
			type: [String, Object],
			default: "body"
		}
	};
	var stdin_default$151 = (0, import_vue$81.defineComponent)({
		name: name$73,
		inheritAttrs: false,
		props: backTopProps,
		emits: ["click"],
		setup(props$1, { emit, slots, attrs }) {
			let shouldReshow = false;
			const show = (0, import_vue$81.ref)(false);
			const root = (0, import_vue$81.ref)();
			const scrollParent = (0, import_vue$81.ref)();
			const style = (0, import_vue$81.computed)(() => (0, import_utils$155.extend)((0, import_utils$155.getZIndexStyle)(props$1.zIndex), {
				right: (0, import_utils$155.addUnit)(props$1.right),
				bottom: (0, import_utils$155.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 ? (0, import_utils$155.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 (import_utils$155.inBrowser) (0, import_vue$81.nextTick)(() => {
					scrollParent.value = props$1.target ? getTarget() : (0, import_use$41.getScrollParent)(root.value);
					scroll();
				});
			};
			(0, import_use$41.useEventListener)("scroll", (0, import_util$4.throttle)(scroll, 100), { target: scrollParent });
			(0, import_vue$81.onMounted)(updateTarget);
			(0, import_vue$81.onActivated)(() => {
				if (shouldReshow) {
					show.value = true;
					shouldReshow = false;
				}
			});
			(0, import_vue$81.onDeactivated)(() => {
				if (show.value && props$1.teleport) {
					show.value = false;
					shouldReshow = true;
				}
			});
			(0, import_vue$81.watch)(() => props$1.target, updateTarget);
			return () => {
				const Content = (0, import_vue$81.createVNode)("div", (0, import_vue$81.mergeProps)({
					"ref": !props$1.teleport ? root : void 0,
					"class": bem$69({ active: show.value }),
					"style": style.value,
					"onClick": onClick
				}, attrs), [slots.default ? slots.default() : (0, import_vue$81.createVNode)(import_icon$21.Icon, {
					"name": "back-top",
					"class": bem$69("icon")
				}, null)]);
				if (props$1.teleport) return [(0, import_vue$81.createVNode)("div", {
					"ref": root,
					"class": bem$69("placeholder")
				}, null), (0, import_vue$81.createVNode)(import_vue$81.Teleport, { "to": props$1.teleport }, { default: () => [Content] })];
				return Content;
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/back-top/index.js
var require_back_top = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/back-top/index.js": ((exports, module) => {
	var __create$83 = Object.create;
	var __defProp$162 = Object.defineProperty;
	var __getOwnPropDesc$162 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$162 = Object.getOwnPropertyNames;
	var __getProtoOf$83 = Object.getPrototypeOf;
	var __hasOwnProp$162 = Object.prototype.hasOwnProperty;
	var __export$162 = (target, all) => {
		for (var name$111 in all) __defProp$162(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$162 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$162(from)) if (!__hasOwnProp$162.call(to, key) && key !== except) __defProp$162(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$162(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$83 = (mod, isNodeMode, target) => (target = mod != null ? __create$83(__getProtoOf$83(mod)) : {}, __copyProps$162(isNodeMode || !mod || !mod.__esModule ? __defProp$162(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$162 = (mod) => __copyProps$162(__defProp$162({}, "__esModule", { value: true }), mod);
	var stdin_exports$161 = {};
	__export$162(stdin_exports$161, {
		BackTop: () => BackTop,
		backTopProps: () => import_BackTop2.backTopProps,
		default: () => stdin_default$150
	});
	module.exports = __toCommonJS$162(stdin_exports$161);
	var import_utils$154 = require_utils$9();
	var import_BackTop = __toESM$83(require_BackTop());
	var import_BackTop2 = require_BackTop();
	var BackTop = (0, import_utils$154.withInstall)(import_BackTop.default);
	var stdin_default$150 = BackTop;
}) });

//#endregion
//#region node_modules/vant/lib/barrage/Barrage.js
var require_Barrage = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/barrage/Barrage.js": ((exports, module) => {
	var __defProp$161 = Object.defineProperty;
	var __getOwnPropDesc$161 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$161 = Object.getOwnPropertyNames;
	var __hasOwnProp$161 = Object.prototype.hasOwnProperty;
	var __export$161 = (target, all) => {
		for (var name2 in all) __defProp$161(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$161 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$161(from)) if (!__hasOwnProp$161.call(to, key) && key !== except) __defProp$161(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$161(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$161 = (mod) => __copyProps$161(__defProp$161({}, "__esModule", { value: true }), mod);
	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 stdin_exports$160 = {};
	__export$161(stdin_exports$160, {
		barrageProps: () => barrageProps,
		default: () => stdin_default$149
	});
	module.exports = __toCommonJS$161(stdin_exports$160);
	var import_vue$80 = require_vue();
	var import_use_expose$21 = require_use_expose();
	var import_utils$153 = require_utils$9();
	var barrageProps = {
		top: (0, import_utils$153.makeNumericProp)(10),
		rows: (0, import_utils$153.makeNumericProp)(4),
		duration: (0, import_utils$153.makeNumericProp)(4e3),
		autoPlay: import_utils$153.truthProp,
		delay: (0, import_utils$153.makeNumberProp)(300),
		modelValue: (0, import_utils$153.makeArrayProp)()
	};
	var [name$72, bem$68] = (0, import_utils$153.createNamespace)("barrage");
	var stdin_default$149 = (0, import_vue$80.defineComponent)({
		name: name$72,
		props: barrageProps,
		emits: ["update:modelValue"],
		setup(props$1, { emit, slots }) {
			const barrageWrapper = (0, import_vue$80.ref)();
			const className = bem$68("item");
			const total = (0, import_vue$80.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 = (0, import_vue$80.ref)(true);
			const isPlay = (0, import_vue$80.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;
			};
			(0, import_vue$80.watch)(() => props$1.modelValue.slice(), (newValue, oldValue) => updateBarrages(newValue != null ? newValue : [], oldValue != null ? oldValue : []), { deep: true });
			const rootStyle = (0, import_vue$80.ref)({});
			(0, import_vue$80.onMounted)(() => __async(null, null, function* () {
				var _a;
				rootStyle.value["--move-distance"] = `-${(_a = barrageWrapper.value) == null ? void 0 : _a.offsetWidth}px`;
				yield (0, import_vue$80.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";
				});
			};
			(0, import_use_expose$21.useExpose)({
				play,
				pause
			});
			return () => {
				var _a;
				return (0, import_vue$80.createVNode)("div", {
					"class": bem$68(),
					"ref": barrageWrapper,
					"style": rootStyle.value
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/barrage/index.js
var require_barrage = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/barrage/index.js": ((exports, module) => {
	var __create$82 = Object.create;
	var __defProp$160 = Object.defineProperty;
	var __getOwnPropDesc$160 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$160 = Object.getOwnPropertyNames;
	var __getProtoOf$82 = Object.getPrototypeOf;
	var __hasOwnProp$160 = Object.prototype.hasOwnProperty;
	var __export$160 = (target, all) => {
		for (var name$111 in all) __defProp$160(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$160 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$160(from)) if (!__hasOwnProp$160.call(to, key) && key !== except) __defProp$160(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$160(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$82 = (mod, isNodeMode, target) => (target = mod != null ? __create$82(__getProtoOf$82(mod)) : {}, __copyProps$160(isNodeMode || !mod || !mod.__esModule ? __defProp$160(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$160 = (mod) => __copyProps$160(__defProp$160({}, "__esModule", { value: true }), mod);
	var stdin_exports$159 = {};
	__export$160(stdin_exports$159, {
		Barrage: () => Barrage,
		barrageProps: () => import_Barrage2.barrageProps,
		default: () => stdin_default$148
	});
	module.exports = __toCommonJS$160(stdin_exports$159);
	var import_utils$152 = require_utils$9();
	var import_Barrage = __toESM$82(require_Barrage());
	var import_Barrage2 = require_Barrage();
	var Barrage = (0, import_utils$152.withInstall)(import_Barrage.default);
	var stdin_default$148 = Barrage;
}) });

//#endregion
//#region node_modules/vant/lib/calendar/utils.js
var require_utils$4 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/calendar/utils.js": ((exports, module) => {
	var __defProp$159 = Object.defineProperty;
	var __getOwnPropDesc$159 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$159 = Object.getOwnPropertyNames;
	var __hasOwnProp$159 = Object.prototype.hasOwnProperty;
	var __export$159 = (target, all) => {
		for (var name2 in all) __defProp$159(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$159 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$159(from)) if (!__hasOwnProp$159.call(to, key) && key !== except) __defProp$159(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$159(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$159 = (mod) => __copyProps$159(__defProp$159({}, "__esModule", { value: true }), mod);
	var stdin_exports$158 = {};
	__export$159(stdin_exports$158, {
		bem: () => bem$67,
		calcDateNum: () => calcDateNum,
		cloneDate: () => cloneDate,
		cloneDates: () => cloneDates,
		compareDay: () => compareDay,
		compareMonth: () => compareMonth,
		formatMonthTitle: () => formatMonthTitle,
		getDayByOffset: () => getDayByOffset,
		getMonthByOffset: () => getMonthByOffset,
		getNextDay: () => getNextDay,
		getNextMonth: () => getNextMonth,
		getNextYear: () => getNextYear,
		getPrevDay: () => getPrevDay,
		getPrevMonth: () => getPrevMonth,
		getPrevYear: () => getPrevYear,
		getToday: () => getToday,
		getYearByOffset: () => getYearByOffset,
		isLastRowInMonth: () => isLastRowInMonth,
		name: () => name$71,
		t: () => t$16
	});
	module.exports = __toCommonJS$159(stdin_exports$158);
	var [name$71, bem$67, t$16] = (0, require_utils$9().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/lib/date-picker/utils.js
var require_utils$3 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/date-picker/utils.js": ((exports, module) => {
	var __defProp$158 = Object.defineProperty;
	var __getOwnPropDesc$158 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$158 = Object.getOwnPropertyNames;
	var __hasOwnProp$158 = Object.prototype.hasOwnProperty;
	var __export$158 = (target, all) => {
		for (var name$111 in all) __defProp$158(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$158 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$158(from)) if (!__hasOwnProp$158.call(to, key) && key !== except) __defProp$158(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$158(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$158 = (mod) => __copyProps$158(__defProp$158({}, "__esModule", { value: true }), mod);
	var stdin_exports$157 = {};
	__export$158(stdin_exports$157, {
		formatValueRange: () => formatValueRange,
		genOptions: () => genOptions,
		getMonthEndDay: () => getMonthEndDay,
		pickerInheritKeys: () => pickerInheritKeys,
		sharedProps: () => sharedProps,
		times: () => times
	});
	module.exports = __toCommonJS$158(stdin_exports$157);
	var import_utils$151 = require_utils$9();
	var import_Picker = require_Picker();
	var sharedProps = (0, import_utils$151.extend)({}, import_Picker.pickerSharedProps, {
		modelValue: (0, import_utils$151.makeArrayProp)(),
		filter: Function,
		formatter: {
			type: Function,
			default: (type, option) => option
		}
	});
	var pickerInheritKeys = Object.keys(import_Picker.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 = (0, import_utils$151.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 (0, import_utils$151.padZero)((0, import_utils$151.clamp)(+value, minValue, maxValue));
		}
		return value;
	});
}) });

//#endregion
//#region node_modules/vant/lib/calendar/CalendarDay.js
var require_CalendarDay = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/calendar/CalendarDay.js": ((exports, module) => {
	var __defProp$157 = Object.defineProperty;
	var __getOwnPropDesc$157 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$157 = Object.getOwnPropertyNames;
	var __hasOwnProp$157 = Object.prototype.hasOwnProperty;
	var __export$157 = (target, all) => {
		for (var name2 in all) __defProp$157(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$157 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$157(from)) if (!__hasOwnProp$157.call(to, key) && key !== except) __defProp$157(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$157(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$157 = (mod) => __copyProps$157(__defProp$157({}, "__esModule", { value: true }), mod);
	var stdin_exports$156 = {};
	__export$157(stdin_exports$156, { default: () => stdin_default$147 });
	module.exports = __toCommonJS$157(stdin_exports$156);
	var import_vue$79 = require_vue();
	var import_utils$150 = require_utils$9();
	var import_utils2$9 = require_utils$4();
	var [name$70] = (0, import_utils$150.createNamespace)("calendar-day");
	var stdin_default$147 = (0, import_vue$79.defineComponent)({
		name: name$70,
		props: {
			item: (0, import_utils$150.makeRequiredProp)(Object),
			color: String,
			index: Number,
			offset: (0, import_utils$150.makeNumberProp)(0),
			rowHeight: String
		},
		emits: ["click", "clickDisabledDate"],
		setup(props$1, { emit, slots }) {
			const style = (0, import_vue$79.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 && (0, import_utils2$9.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 (0, import_vue$79.createVNode)("div", { "class": (0, import_utils2$9.bem)("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 (0, import_vue$79.createVNode)("div", { "class": (0, import_utils2$9.bem)("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 (0, import_vue$79.createVNode)("div", {
					"class": (0, import_utils2$9.bem)("selected-day"),
					"style": {
						width: rowHeight,
						height: rowHeight,
						background: color
					}
				}, [Nodes]);
				return Nodes;
			};
			return () => {
				const { type, className } = props$1.item;
				if (type === "placeholder") return (0, import_vue$79.createVNode)("div", {
					"class": (0, import_utils2$9.bem)("day"),
					"style": style.value
				}, null);
				return (0, import_vue$79.createVNode)("div", {
					"role": "gridcell",
					"style": style.value,
					"class": [(0, import_utils2$9.bem)("day", type), className],
					"tabindex": type === "disabled" ? void 0 : -1,
					"onClick": onClick
				}, [renderContent()]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/calendar/CalendarMonth.js
var require_CalendarMonth = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/calendar/CalendarMonth.js": ((exports, module) => {
	var __create$81 = Object.create;
	var __defProp$156 = Object.defineProperty;
	var __getOwnPropDesc$156 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$156 = Object.getOwnPropertyNames;
	var __getProtoOf$81 = Object.getPrototypeOf;
	var __hasOwnProp$156 = Object.prototype.hasOwnProperty;
	var __export$156 = (target, all) => {
		for (var name2 in all) __defProp$156(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$156 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$156(from)) if (!__hasOwnProp$156.call(to, key) && key !== except) __defProp$156(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$156(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$81 = (mod, isNodeMode, target) => (target = mod != null ? __create$81(__getProtoOf$81(mod)) : {}, __copyProps$156(isNodeMode || !mod || !mod.__esModule ? __defProp$156(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$156 = (mod) => __copyProps$156(__defProp$156({}, "__esModule", { value: true }), mod);
	var stdin_exports$155 = {};
	__export$156(stdin_exports$155, { default: () => stdin_default$146 });
	module.exports = __toCommonJS$156(stdin_exports$155);
	var import_vue$78 = require_vue();
	var import_utils$149 = require_utils$9();
	var import_utils2$8 = require_utils$3();
	var import_utils3 = require_utils$4();
	var import_use$40 = require_index_cjs$1();
	var import_use_expose$20 = require_use_expose();
	var import_use_height = require_use_height();
	var import_CalendarDay = __toESM$81(require_CalendarDay());
	var [name$69] = (0, import_utils$149.createNamespace)("calendar-month");
	var calendarMonthProps = {
		date: (0, import_utils$149.makeRequiredProp)(Date),
		type: String,
		color: String,
		minDate: Date,
		maxDate: Date,
		showMark: Boolean,
		rowHeight: import_utils$149.numericProp,
		formatter: Function,
		lazyRender: Boolean,
		currentDate: [Date, Array],
		allowSameDay: Boolean,
		showSubtitle: Boolean,
		showMonthTitle: Boolean,
		firstDayOfWeek: Number
	};
	var stdin_default$146 = (0, import_vue$78.defineComponent)({
		name: name$69,
		props: calendarMonthProps,
		emits: ["click", "clickDisabledDate"],
		setup(props$1, { emit, slots }) {
			const [visible, setVisible] = (0, import_use$40.useToggle)();
			const daysRef = (0, import_vue$78.ref)();
			const monthRef = (0, import_vue$78.ref)();
			const height$1 = (0, import_use_height.useHeight)(monthRef);
			const title = (0, import_vue$78.computed)(() => (0, import_utils3.formatMonthTitle)(props$1.date));
			const rowHeight = (0, import_vue$78.computed)(() => (0, import_utils$149.addUnit)(props$1.rowHeight));
			const offset$1 = (0, import_vue$78.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 = (0, import_vue$78.computed)(() => (0, import_utils2$8.getMonthEndDay)(props$1.date.getFullYear(), props$1.date.getMonth() + 1));
			const shouldRender = (0, import_vue$78.computed)(() => visible.value || !props$1.lazyRender);
			const getTitle = () => title.value;
			const getMultipleDayType = (day) => {
				const isSelected = (date) => props$1.currentDate.some((item) => (0, import_utils3.compareDay)(item, date) === 0);
				if (isSelected(day)) {
					const prevDay = (0, import_utils3.getPrevDay)(day);
					const nextDay = (0, import_utils3.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 = (0, import_utils3.compareDay)(day, startDay);
				if (!endDay) return compareToStart === 0 ? "start" : "";
				const compareToEnd = (0, import_utils3.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 && (0, import_utils3.compareDay)(day, minDate) < 0 || maxDate && (0, import_utils3.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 (0, import_utils3.compareDay)(day, currentDate) === 0 ? "selected" : "";
				return "";
			};
			const getBottomInfo = (dayType) => {
				if (props$1.type === "range") {
					if (dayType === "start" || dayType === "end") return (0, import_utils3.t)(dayType);
					if (dayType === "start-end") return `${(0, import_utils3.t)("start")}/${(0, import_utils3.t)("end")}`;
				}
			};
			const renderTitle = () => {
				if (props$1.showMonthTitle) return (0, import_vue$78.createVNode)("div", { "class": (0, import_utils3.bem)("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 (0, import_vue$78.createVNode)("div", { "class": (0, import_utils3.bem)("month-mark") }, [props$1.date.getMonth() + 1]);
			};
			const placeholders = (0, import_vue$78.computed)(() => {
				const count = Math.ceil((totalDay.value + offset$1.value) / 7);
				return Array(count).fill({ type: "placeholder" });
			});
			const days = (0, import_vue$78.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 = (0, import_vue$78.computed)(() => days.value.filter((day) => day.type === "disabled"));
			const scrollToDate = (body, targetDate) => {
				if (daysRef.value) {
					const daysRect = (0, import_use$40.useRect)(daysRef.value);
					const totalRows = placeholders.value.length;
					const rowOffset = (Math.ceil((targetDate.getDate() + offset$1.value) / 7) - 1) * daysRect.height / totalRows;
					(0, import_utils$149.setScrollTop)(body, daysRect.top + rowOffset + body.scrollTop - (0, import_use$40.useRect)(body).top);
				}
			};
			const renderDay = (item, index) => (0, import_vue$78.createVNode)(import_CalendarDay.default, {
				"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)
			}, (0, import_utils$149.pick)(slots, [
				"top-info",
				"bottom-info",
				"text"
			]));
			const renderDays = () => (0, import_vue$78.createVNode)("div", {
				"ref": daysRef,
				"role": "grid",
				"class": (0, import_utils3.bem)("days")
			}, [renderMark(), (shouldRender.value ? days : placeholders).value.map(renderDay)]);
			(0, import_use_expose$20.useExpose)({
				getTitle,
				getHeight: () => height$1.value,
				setVisible,
				scrollToDate,
				disabledDays
			});
			return () => (0, import_vue$78.createVNode)("div", {
				"class": (0, import_utils3.bem)("month"),
				"ref": monthRef
			}, [renderTitle(), renderDays()]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/calendar/CalendarHeader.js
var require_CalendarHeader = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/calendar/CalendarHeader.js": ((exports, module) => {
	var __defProp$155 = Object.defineProperty;
	var __getOwnPropDesc$155 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$155 = Object.getOwnPropertyNames;
	var __hasOwnProp$155 = Object.prototype.hasOwnProperty;
	var __export$155 = (target, all) => {
		for (var name2 in all) __defProp$155(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$155 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$155(from)) if (!__hasOwnProp$155.call(to, key) && key !== except) __defProp$155(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$155(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$155 = (mod) => __copyProps$155(__defProp$155({}, "__esModule", { value: true }), mod);
	var stdin_exports$154 = {};
	__export$155(stdin_exports$154, { default: () => stdin_default$145 });
	module.exports = __toCommonJS$155(stdin_exports$154);
	var import_vue$77 = require_vue();
	var import_utils$148 = require_utils$9();
	var import_utils2$7 = require_utils$4();
	var import_icon$20 = require_icon();
	var [name$68] = (0, import_utils$148.createNamespace)("calendar-header");
	var stdin_default$145 = (0, import_vue$77.defineComponent)({
		name: name$68,
		props: {
			date: Date,
			minDate: Date,
			maxDate: Date,
			title: String,
			subtitle: String,
			showTitle: Boolean,
			showSubtitle: Boolean,
			firstDayOfWeek: Number,
			switchMode: (0, import_utils$148.makeStringProp)("none")
		},
		emits: ["clickSubtitle", "panelChange"],
		setup(props$1, { slots, emit }) {
			const prevMonthDisabled = (0, import_vue$77.computed)(() => props$1.date && props$1.minDate && (0, import_utils2$7.compareMonth)((0, import_utils2$7.getPrevMonth)(props$1.date), props$1.minDate) < 0);
			const prevYearDisabled = (0, import_vue$77.computed)(() => props$1.date && props$1.minDate && (0, import_utils2$7.compareMonth)((0, import_utils2$7.getPrevYear)(props$1.date), props$1.minDate) < 0);
			const nextMonthDisabled = (0, import_vue$77.computed)(() => props$1.date && props$1.maxDate && (0, import_utils2$7.compareMonth)((0, import_utils2$7.getNextMonth)(props$1.date), props$1.maxDate) > 0);
			const nextYearDisabled = (0, import_vue$77.computed)(() => props$1.date && props$1.maxDate && (0, import_utils2$7.compareMonth)((0, import_utils2$7.getNextYear)(props$1.date), props$1.maxDate) > 0);
			const renderTitle = () => {
				if (props$1.showTitle) {
					const text = props$1.title || (0, import_utils2$7.t)("title");
					const title = slots.title ? slots.title() : text;
					return (0, import_vue$77.createVNode)("div", { "class": (0, import_utils2$7.bem)("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 ? import_utils2$7.getNextMonth : import_utils2$7.getPrevMonth)(props$1.date));
				const onYearChange = () => onPanelChange((isNext ? import_utils2$7.getNextYear : import_utils2$7.getPrevYear)(props$1.date));
				const MonthAction = (0, import_vue$77.createVNode)("view", {
					"class": (0, import_utils2$7.bem)("header-action", { disabled: monthDisabled }),
					"onClick": monthDisabled ? void 0 : onMonthChange
				}, [monthSlot ? monthSlot({ disabled: monthDisabled }) : (0, import_vue$77.createVNode)(import_icon$20.Icon, {
					"class": { [import_utils$148.HAPTICS_FEEDBACK]: !monthDisabled },
					"name": monthIconName
				}, null)]);
				const YearAction = showYearAction && (0, import_vue$77.createVNode)("view", {
					"class": (0, import_utils2$7.bem)("header-action", { disabled: yearDisabled }),
					"onClick": yearDisabled ? void 0 : onYearChange
				}, [yearSlot ? yearSlot({ disabled: yearDisabled }) : (0, import_vue$77.createVNode)(import_icon$20.Icon, {
					"class": { [import_utils$148.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 (0, import_vue$77.createVNode)("div", {
						"class": (0, import_utils2$7.bem)("header-subtitle", { "with-switch": canSwitch }),
						"onClick": onClickSubtitle
					}, [canSwitch ? [
						renderAction(),
						(0, import_vue$77.createVNode)("div", { "class": (0, import_utils2$7.bem)("header-subtitle-text") }, [title]),
						renderAction(true)
					] : title]);
				}
			};
			const renderWeekDays = () => {
				const { firstDayOfWeek } = props$1;
				const weekdays = (0, import_utils2$7.t)("weekdays");
				const renderWeekDays2 = [...weekdays.slice(firstDayOfWeek, 7), ...weekdays.slice(0, firstDayOfWeek)];
				return (0, import_vue$77.createVNode)("div", { "class": (0, import_utils2$7.bem)("weekdays") }, [renderWeekDays2.map((text) => (0, import_vue$77.createVNode)("span", { "class": (0, import_utils2$7.bem)("weekday") }, [text]))]);
			};
			return () => (0, import_vue$77.createVNode)("div", { "class": (0, import_utils2$7.bem)("header") }, [
				renderTitle(),
				renderSubtitle(),
				renderWeekDays()
			]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/calendar/Calendar.js
var require_Calendar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/calendar/Calendar.js": ((exports, module) => {
	var __create$80 = Object.create;
	var __defProp$154 = Object.defineProperty;
	var __getOwnPropDesc$154 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$154 = Object.getOwnPropertyNames;
	var __getProtoOf$80 = Object.getPrototypeOf;
	var __hasOwnProp$154 = Object.prototype.hasOwnProperty;
	var __export$154 = (target, all) => {
		for (var name2 in all) __defProp$154(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$154 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$154(from)) if (!__hasOwnProp$154.call(to, key) && key !== except) __defProp$154(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$154(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$80 = (mod, isNodeMode, target) => (target = mod != null ? __create$80(__getProtoOf$80(mod)) : {}, __copyProps$154(isNodeMode || !mod || !mod.__esModule ? __defProp$154(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$154 = (mod) => __copyProps$154(__defProp$154({}, "__esModule", { value: true }), mod);
	var stdin_exports$153 = {};
	__export$154(stdin_exports$153, {
		calendarProps: () => calendarProps,
		default: () => stdin_default$144
	});
	module.exports = __toCommonJS$154(stdin_exports$153);
	var import_vue$76 = require_vue();
	var import_utils$147 = require_utils$9();
	var import_utils2$6 = require_utils$4();
	var import_use$39 = require_index_cjs$1();
	var import_use_refs$3 = require_use_refs();
	var import_use_expose$19 = require_use_expose();
	var import_popup$7 = require_popup();
	var import_button$7 = require_button();
	var import_toast$1 = require_toast();
	var import_CalendarMonth = __toESM$80(require_CalendarMonth());
	var import_CalendarHeader = __toESM$80(require_CalendarHeader());
	var calendarProps = {
		show: Boolean,
		type: (0, import_utils$147.makeStringProp)("single"),
		switchMode: (0, import_utils$147.makeStringProp)("none"),
		title: String,
		color: String,
		round: import_utils$147.truthProp,
		readonly: Boolean,
		poppable: import_utils$147.truthProp,
		maxRange: (0, import_utils$147.makeNumericProp)(null),
		position: (0, import_utils$147.makeStringProp)("bottom"),
		teleport: [String, Object],
		showMark: import_utils$147.truthProp,
		showTitle: import_utils$147.truthProp,
		formatter: Function,
		rowHeight: import_utils$147.numericProp,
		confirmText: String,
		rangePrompt: String,
		lazyRender: import_utils$147.truthProp,
		showConfirm: import_utils$147.truthProp,
		defaultDate: [Date, Array],
		allowSameDay: Boolean,
		showSubtitle: import_utils$147.truthProp,
		closeOnPopstate: import_utils$147.truthProp,
		showRangePrompt: import_utils$147.truthProp,
		confirmDisabledText: String,
		closeOnClickOverlay: import_utils$147.truthProp,
		safeAreaInsetTop: Boolean,
		safeAreaInsetBottom: import_utils$147.truthProp,
		minDate: {
			type: Date,
			validator: import_utils$147.isDate
		},
		maxDate: {
			type: Date,
			validator: import_utils$147.isDate
		},
		firstDayOfWeek: {
			type: import_utils$147.numericProp,
			default: 0,
			validator: (val) => val >= 0 && val <= 6
		}
	};
	var stdin_default$144 = (0, import_vue$76.defineComponent)({
		name: import_utils2$6.name,
		props: calendarProps,
		emits: [
			"select",
			"confirm",
			"unselect",
			"monthShow",
			"overRange",
			"update:show",
			"clickSubtitle",
			"clickDisabledDate",
			"clickOverlay",
			"panelChange"
		],
		setup(props$1, { emit, slots }) {
			const canSwitch = (0, import_vue$76.computed)(() => props$1.switchMode !== "none");
			const minDate = (0, import_vue$76.computed)(() => {
				if (!props$1.minDate && !canSwitch.value) return (0, import_utils2$6.getToday)();
				return props$1.minDate;
			});
			const maxDate = (0, import_vue$76.computed)(() => {
				if (!props$1.maxDate && !canSwitch.value) return (0, import_utils2$6.getMonthByOffset)((0, import_utils2$6.getToday)(), 6);
				return props$1.maxDate;
			});
			const limitDateRange = (date, min = minDate.value, max = maxDate.value) => {
				if (min && (0, import_utils2$6.compareDay)(date, min) === -1) return min;
				if (max && (0, import_utils2$6.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 = (0, import_utils2$6.getToday)();
				if (type === "range") {
					if (!Array.isArray(defaultDate)) defaultDate = [];
					if (defaultDate.length === 1 && (0, import_utils2$6.compareDay)(defaultDate[0], now) === 1) defaultDate = [];
					const min = minDate.value;
					const max = maxDate.value;
					return [limitDateRange(defaultDate[0] || now, min, max ? allowSameDay ? max : (0, import_utils2$6.getPrevDay)(max) : void 0), limitDateRange(defaultDate[1] || (allowSameDay ? now : (0, import_utils2$6.getNextDay)(now)), min ? allowSameDay ? min : (0, import_utils2$6.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((0, import_utils2$6.getToday)());
			};
			let bodyHeight;
			const bodyRef = (0, import_vue$76.ref)();
			const currentDate = (0, import_vue$76.ref)(getInitialDate());
			const currentPanelDate = (0, import_vue$76.ref)(getInitialPanelDate());
			const currentMonthRef = (0, import_vue$76.ref)();
			const [monthRefs, setMonthRefs] = (0, import_use_refs$3.useRefs)();
			const dayOffset = (0, import_vue$76.computed)(() => props$1.firstDayOfWeek ? +props$1.firstDayOfWeek % 7 : 0);
			const months = (0, import_vue$76.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 ((0, import_utils2$6.compareMonth)(cursor, maxDate.value) !== 1);
				return months2;
			});
			const buttonDisabled = (0, import_vue$76.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 = (0, import_utils$147.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 (0, import_use$39.raf)(() => {
					months.value.some((month, index) => {
						if ((0, import_utils2$6.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 ((0, import_utils$147.isDate)(targetDate)) scrollToDate(targetDate);
				} else if (!canSwitch.value) (0, import_use$39.raf)(onScroll);
			};
			const init = () => {
				if (props$1.poppable && !props$1.show) return;
				if (!canSwitch.value) (0, import_use$39.raf)(() => {
					bodyHeight = Math.floor((0, import_use$39.useRect)(bodyRef).height);
				});
				scrollToCurrentDate();
			};
			const reset$1 = (date = getInitialDate()) => {
				currentDate.value = date;
				scrollToCurrentDate();
			};
			const checkRange = (date) => {
				const { maxRange, rangePrompt, showRangePrompt } = props$1;
				if (maxRange && (0, import_utils2$6.calcDateNum)(date) > +maxRange) {
					if (showRangePrompt) (0, import_toast$1.showToast)(rangePrompt || (0, import_utils2$6.t)("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 : (0, import_utils2$6.cloneDates)(currentDate.value));
			};
			const select = (date, complete) => {
				const setCurrentDate = (date2) => {
					currentDate.value = date2;
					emit("select", (0, import_utils2$6.cloneDates)(date2));
				};
				if (complete && props$1.type === "range") {
					if (!checkRange(date)) {
						setCurrentDate([date[0], (0, import_utils2$6.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) => (0, import_utils2$6.compareDay)(startDay, day.date) === -1 && (0, import_utils2$6.compareDay)(day.date, date) === -1)) == null ? void 0 : _a.date;
			};
			const disabledDays = (0, import_vue$76.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 = (0, import_utils2$6.compareDay)(date, startDay);
						if (compareToStart === 1) {
							const disabledDay = getDisabledDate(disabledDays.value, startDay, date);
							if (disabledDay) {
								const endDay2 = (0, import_utils2$6.getPrevDay)(disabledDay);
								if ((0, import_utils2$6.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) => (0, import_utils2$6.compareDay)(dateItem, date) === 0);
					if (selectedIndex !== -1) {
						const [unselectedDate] = dates.splice(selectedIndex, 1);
						emit("unselect", (0, import_utils2$6.cloneDate)(unselectedDate));
					} else if (props$1.maxRange && dates.length >= +props$1.maxRange) (0, import_toast$1.showToast)(props$1.rangePrompt || (0, import_utils2$6.t)("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 (0, import_vue$76.createVNode)(import_CalendarMonth.default, (0, import_vue$76.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
				}, (0, import_utils$147.pick)(props$1, [
					"type",
					"color",
					"showMark",
					"formatter",
					"rowHeight",
					"showSubtitle",
					"allowSameDay"
				]), {
					"onClick": onClickDay,
					"onClickDisabledDate": (item) => emit("clickDisabledDate", item)
				}), (0, import_utils$147.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 (0, import_vue$76.createVNode)(import_button$7.Button, {
						"round": true,
						"block": true,
						"type": "primary",
						"color": props$1.color,
						"class": (0, import_utils2$6.bem)("confirm"),
						"disabled": disabled,
						"nativeType": "button",
						"onClick": onConfirm
					}, { default: () => [slot ? slot({ disabled }) : text || (0, import_utils2$6.t)("confirm")] });
				}
			};
			const renderFooter = () => (0, import_vue$76.createVNode)("div", { "class": [(0, import_utils2$6.bem)("footer"), { "van-safe-area-bottom": props$1.safeAreaInsetBottom }] }, [renderFooterButton()]);
			const renderCalendar = () => {
				var _a, _b;
				return (0, import_vue$76.createVNode)("div", { "class": (0, import_utils2$6.bem)() }, [
					(0, import_vue$76.createVNode)(import_CalendarHeader.default, {
						"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
					}, (0, import_utils$147.pick)(slots, [
						"title",
						"subtitle",
						"prev-month",
						"prev-year",
						"next-month",
						"next-year"
					])),
					(0, import_vue$76.createVNode)("div", {
						"ref": bodyRef,
						"class": (0, import_utils2$6.bem)("body"),
						"onScroll": canSwitch.value ? void 0 : onScroll
					}, [canSwitch.value ? renderMonth(currentPanelDate.value, 0) : months.value.map(renderMonth)]),
					renderFooter()
				]);
			};
			(0, import_vue$76.watch)(() => props$1.show, init);
			(0, import_vue$76.watch)(() => [
				props$1.type,
				props$1.minDate,
				props$1.maxDate,
				props$1.switchMode
			], () => reset$1(getInitialDate(currentDate.value)));
			(0, import_vue$76.watch)(() => props$1.defaultDate, (value) => {
				reset$1(value);
			});
			(0, import_use_expose$19.useExpose)({
				reset: reset$1,
				scrollToDate,
				getSelectedDate
			});
			(0, import_use$39.onMountedOrActivated)(init);
			return () => {
				if (props$1.poppable) return (0, import_vue$76.createVNode)(import_popup$7.Popup, {
					"show": props$1.show,
					"class": (0, import_utils2$6.bem)("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/lib/calendar/index.js
var require_calendar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/calendar/index.js": ((exports, module) => {
	var __create$79 = Object.create;
	var __defProp$153 = Object.defineProperty;
	var __getOwnPropDesc$153 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$153 = Object.getOwnPropertyNames;
	var __getProtoOf$79 = Object.getPrototypeOf;
	var __hasOwnProp$153 = Object.prototype.hasOwnProperty;
	var __export$153 = (target, all) => {
		for (var name$111 in all) __defProp$153(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$153 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$153(from)) if (!__hasOwnProp$153.call(to, key) && key !== except) __defProp$153(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$153(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$79 = (mod, isNodeMode, target) => (target = mod != null ? __create$79(__getProtoOf$79(mod)) : {}, __copyProps$153(isNodeMode || !mod || !mod.__esModule ? __defProp$153(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$153 = (mod) => __copyProps$153(__defProp$153({}, "__esModule", { value: true }), mod);
	var stdin_exports$152 = {};
	__export$153(stdin_exports$152, {
		Calendar: () => Calendar,
		calendarProps: () => import_Calendar2.calendarProps,
		default: () => stdin_default$143
	});
	module.exports = __toCommonJS$153(stdin_exports$152);
	var import_utils$146 = require_utils$9();
	var import_Calendar = __toESM$79(require_Calendar());
	var import_Calendar2 = require_Calendar();
	var Calendar = (0, import_utils$146.withInstall)(import_Calendar.default);
	var stdin_default$143 = Calendar;
}) });

//#endregion
//#region node_modules/vant/lib/image/Image.js
var require_Image = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/image/Image.js": ((exports, module) => {
	var __defProp$152 = Object.defineProperty;
	var __getOwnPropDesc$152 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$152 = Object.getOwnPropertyNames;
	var __hasOwnProp$152 = Object.prototype.hasOwnProperty;
	var __export$152 = (target, all) => {
		for (var name2 in all) __defProp$152(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$152 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$152(from)) if (!__hasOwnProp$152.call(to, key) && key !== except) __defProp$152(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$152(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$152 = (mod) => __copyProps$152(__defProp$152({}, "__esModule", { value: true }), mod);
	var stdin_exports$151 = {};
	__export$152(stdin_exports$151, {
		default: () => stdin_default$142,
		imageProps: () => imageProps
	});
	module.exports = __toCommonJS$152(stdin_exports$151);
	var import_vue$75 = require_vue();
	var import_utils$145 = require_utils$9();
	var import_icon$19 = require_icon();
	var [name$67, bem$66] = (0, import_utils$145.createNamespace)("image");
	var imageProps = {
		src: String,
		alt: String,
		fit: String,
		position: String,
		round: Boolean,
		block: Boolean,
		width: import_utils$145.numericProp,
		height: import_utils$145.numericProp,
		radius: import_utils$145.numericProp,
		lazyLoad: Boolean,
		iconSize: import_utils$145.numericProp,
		showError: import_utils$145.truthProp,
		errorIcon: (0, import_utils$145.makeStringProp)("photo-fail"),
		iconPrefix: String,
		showLoading: import_utils$145.truthProp,
		loadingIcon: (0, import_utils$145.makeStringProp)("photo"),
		crossorigin: String,
		referrerpolicy: String,
		decoding: String
	};
	var stdin_default$142 = (0, import_vue$75.defineComponent)({
		name: name$67,
		props: imageProps,
		emits: ["load", "error"],
		setup(props$1, { emit, slots }) {
			const error = (0, import_vue$75.ref)(false);
			const loading = (0, import_vue$75.ref)(true);
			const imageRef = (0, import_vue$75.ref)();
			const { $Lazyload } = (0, import_vue$75.getCurrentInstance)().proxy;
			const style = (0, import_vue$75.computed)(() => {
				const style2 = {
					width: (0, import_utils$145.addUnit)(props$1.width),
					height: (0, import_utils$145.addUnit)(props$1.height)
				};
				if ((0, import_utils$145.isDef)(props$1.radius)) {
					style2.overflow = "hidden";
					style2.borderRadius = (0, import_utils$145.addUnit)(props$1.radius);
				}
				return style2;
			});
			(0, import_vue$75.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 (0, import_vue$75.createVNode)(import_icon$19.Icon, {
					"name": name2,
					"size": props$1.iconSize,
					"class": className,
					"classPrefix": props$1.iconPrefix
				}, null);
			};
			const renderPlaceholder = () => {
				if (loading.value && props$1.showLoading) return (0, import_vue$75.createVNode)("div", { "class": bem$66("loading") }, [renderIcon(props$1.loadingIcon, bem$66("loading-icon"), slots.loading)]);
				if (error.value && props$1.showError) return (0, import_vue$75.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 (0, import_vue$75.withDirectives)((0, import_vue$75.createVNode)("img", (0, import_vue$75.mergeProps)({ "ref": imageRef }, attrs), null), [[(0, import_vue$75.resolveDirective)("lazy"), props$1.src]]);
				return (0, import_vue$75.createVNode)("img", (0, import_vue$75.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 (0, import_vue$75.nextTick)(check);
			};
			const onLazyLoadError = ({ el }) => {
				if (el === imageRef.value && !error.value) onError();
			};
			if ($Lazyload && import_utils$145.inBrowser) {
				$Lazyload.$on("loaded", onLazyLoaded);
				$Lazyload.$on("error", onLazyLoadError);
				(0, import_vue$75.onBeforeUnmount)(() => {
					$Lazyload.$off("loaded", onLazyLoaded);
					$Lazyload.$off("error", onLazyLoadError);
				});
			}
			(0, import_vue$75.onMounted)(() => {
				(0, import_vue$75.nextTick)(() => {
					var _a;
					if (((_a = imageRef.value) == null ? void 0 : _a.complete) && !props$1.lazyLoad) triggerLoad();
				});
			});
			return () => {
				var _a;
				return (0, import_vue$75.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/lib/image/index.js
var require_image = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/image/index.js": ((exports, module) => {
	var __create$78 = Object.create;
	var __defProp$151 = Object.defineProperty;
	var __getOwnPropDesc$151 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$151 = Object.getOwnPropertyNames;
	var __getProtoOf$78 = Object.getPrototypeOf;
	var __hasOwnProp$151 = Object.prototype.hasOwnProperty;
	var __export$151 = (target, all) => {
		for (var name$111 in all) __defProp$151(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$151 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$151(from)) if (!__hasOwnProp$151.call(to, key) && key !== except) __defProp$151(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$151(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$78 = (mod, isNodeMode, target) => (target = mod != null ? __create$78(__getProtoOf$78(mod)) : {}, __copyProps$151(isNodeMode || !mod || !mod.__esModule ? __defProp$151(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$151 = (mod) => __copyProps$151(__defProp$151({}, "__esModule", { value: true }), mod);
	var stdin_exports$150 = {};
	__export$151(stdin_exports$150, {
		Image: () => Image$1,
		default: () => stdin_default$141,
		imageProps: () => import_Image2.imageProps
	});
	module.exports = __toCommonJS$151(stdin_exports$150);
	var import_utils$144 = require_utils$9();
	var import_Image = __toESM$78(require_Image());
	var import_Image2 = require_Image();
	var Image$1 = (0, import_utils$144.withInstall)(import_Image.default);
	var stdin_default$141 = Image$1;
}) });

//#endregion
//#region node_modules/vant/lib/card/Card.js
var require_Card = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/card/Card.js": ((exports, module) => {
	var __defProp$150 = Object.defineProperty;
	var __getOwnPropDesc$150 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$150 = Object.getOwnPropertyNames;
	var __hasOwnProp$150 = Object.prototype.hasOwnProperty;
	var __export$150 = (target, all) => {
		for (var name2 in all) __defProp$150(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$150 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$150(from)) if (!__hasOwnProp$150.call(to, key) && key !== except) __defProp$150(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$150(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$150 = (mod) => __copyProps$150(__defProp$150({}, "__esModule", { value: true }), mod);
	var stdin_exports$149 = {};
	__export$150(stdin_exports$149, {
		cardProps: () => cardProps,
		default: () => stdin_default$140
	});
	module.exports = __toCommonJS$150(stdin_exports$149);
	var import_vue$74 = require_vue();
	var import_utils$143 = require_utils$9();
	var import_tag$2 = require_tag();
	var import_image$3 = require_image();
	var [name$66, bem$65] = (0, import_utils$143.createNamespace)("card");
	var cardProps = {
		tag: String,
		num: import_utils$143.numericProp,
		desc: String,
		thumb: String,
		title: String,
		price: import_utils$143.numericProp,
		centered: Boolean,
		lazyLoad: Boolean,
		currency: (0, import_utils$143.makeStringProp)("¥"),
		thumbLink: String,
		originPrice: import_utils$143.numericProp
	};
	var stdin_default$140 = (0, import_vue$74.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 (0, import_vue$74.createVNode)("div", { "class": [bem$65("title"), "van-multi-ellipsis--l2"] }, [props$1.title]);
			};
			const renderThumbTag = () => {
				if (slots.tag || props$1.tag) return (0, import_vue$74.createVNode)("div", { "class": bem$65("tag") }, [slots.tag ? slots.tag() : (0, import_vue$74.createVNode)(import_tag$2.Tag, {
					"mark": true,
					"type": "primary"
				}, { default: () => [props$1.tag] })]);
			};
			const renderThumbImage = () => {
				if (slots.thumb) return slots.thumb();
				return (0, import_vue$74.createVNode)(import_image$3.Image, {
					"src": props$1.thumb,
					"fit": "cover",
					"width": "100%",
					"height": "100%",
					"lazyLoad": props$1.lazyLoad
				}, null);
			};
			const renderThumb = () => {
				if (slots.thumb || props$1.thumb) return (0, import_vue$74.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 (0, import_vue$74.createVNode)("div", { "class": [bem$65("desc"), "van-ellipsis"] }, [props$1.desc]);
			};
			const renderPriceText = () => {
				const priceArr = props$1.price.toString().split(".");
				return (0, import_vue$74.createVNode)("div", null, [
					(0, import_vue$74.createVNode)("span", { "class": bem$65("price-currency") }, [props$1.currency]),
					(0, import_vue$74.createVNode)("span", { "class": bem$65("price-integer") }, [priceArr[0]]),
					priceArr.length > 1 && (0, import_vue$74.createVNode)(import_vue$74.Fragment, null, [(0, import_vue$74.createTextVNode)("."), (0, import_vue$74.createVNode)("span", { "class": bem$65("price-decimal") }, [priceArr[1]])])
				]);
			};
			return () => {
				var _a, _b, _c;
				const showNum = slots.num || (0, import_utils$143.isDef)(props$1.num);
				const showPrice = slots.price || (0, import_utils$143.isDef)(props$1.price);
				const showOriginPrice = slots["origin-price"] || (0, import_utils$143.isDef)(props$1.originPrice);
				const showBottom = showNum || showPrice || showOriginPrice || slots.bottom;
				const Price = showPrice && (0, import_vue$74.createVNode)("div", { "class": bem$65("price") }, [slots.price ? slots.price() : renderPriceText()]);
				const OriginPrice = showOriginPrice && (0, import_vue$74.createVNode)("div", { "class": bem$65("origin-price") }, [slots["origin-price"] ? slots["origin-price"]() : `${props$1.currency} ${props$1.originPrice}`]);
				const Num = showNum && (0, import_vue$74.createVNode)("div", { "class": bem$65("num") }, [slots.num ? slots.num() : `x${props$1.num}`]);
				const Footer = slots.footer && (0, import_vue$74.createVNode)("div", { "class": bem$65("footer") }, [slots.footer()]);
				const Bottom = showBottom && (0, import_vue$74.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 (0, import_vue$74.createVNode)("div", { "class": bem$65() }, [(0, import_vue$74.createVNode)("div", { "class": bem$65("header") }, [renderThumb(), (0, import_vue$74.createVNode)("div", { "class": bem$65("content", { centered: props$1.centered }) }, [(0, import_vue$74.createVNode)("div", null, [
					renderTitle(),
					renderDesc(),
					(_c = slots.tags) == null ? void 0 : _c.call(slots)
				]), Bottom])]), Footer]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/card/index.js
var require_card = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/card/index.js": ((exports, module) => {
	var __create$77 = Object.create;
	var __defProp$149 = Object.defineProperty;
	var __getOwnPropDesc$149 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$149 = Object.getOwnPropertyNames;
	var __getProtoOf$77 = Object.getPrototypeOf;
	var __hasOwnProp$149 = Object.prototype.hasOwnProperty;
	var __export$149 = (target, all) => {
		for (var name$111 in all) __defProp$149(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$149 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$149(from)) if (!__hasOwnProp$149.call(to, key) && key !== except) __defProp$149(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$149(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$77 = (mod, isNodeMode, target) => (target = mod != null ? __create$77(__getProtoOf$77(mod)) : {}, __copyProps$149(isNodeMode || !mod || !mod.__esModule ? __defProp$149(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$149 = (mod) => __copyProps$149(__defProp$149({}, "__esModule", { value: true }), mod);
	var stdin_exports$148 = {};
	__export$149(stdin_exports$148, {
		Card: () => Card,
		cardProps: () => import_Card2.cardProps,
		default: () => stdin_default$139
	});
	module.exports = __toCommonJS$149(stdin_exports$148);
	var import_utils$142 = require_utils$9();
	var import_Card = __toESM$77(require_Card());
	var import_Card2 = require_Card();
	var Card = (0, import_utils$142.withInstall)(import_Card.default);
	var stdin_default$139 = Card;
}) });

//#endregion
//#region node_modules/vant/lib/cascader/Cascader.js
var require_Cascader = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/cascader/Cascader.js": ((exports, module) => {
	var __defProp$148 = Object.defineProperty;
	var __getOwnPropDesc$148 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$148 = Object.getOwnPropertyNames;
	var __hasOwnProp$148 = Object.prototype.hasOwnProperty;
	var __export$148 = (target, all) => {
		for (var name2 in all) __defProp$148(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$148 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$148(from)) if (!__hasOwnProp$148.call(to, key) && key !== except) __defProp$148(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$148(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$148 = (mod) => __copyProps$148(__defProp$148({}, "__esModule", { value: true }), mod);
	var stdin_exports$147 = {};
	__export$148(stdin_exports$147, {
		cascaderProps: () => cascaderProps,
		default: () => stdin_default$138
	});
	module.exports = __toCommonJS$148(stdin_exports$147);
	var import_vue$73 = require_vue();
	var import_utils$141 = require_utils$9();
	var import_use_refs$2 = require_use_refs();
	var import_tab$2 = require_tab();
	var import_tabs$2 = require_tabs();
	var import_icon$18 = require_icon();
	var [name$65, bem$64, t$15] = (0, import_utils$141.createNamespace)("cascader");
	var cascaderProps = {
		title: String,
		options: (0, import_utils$141.makeArrayProp)(),
		closeable: import_utils$141.truthProp,
		swipeable: import_utils$141.truthProp,
		closeIcon: (0, import_utils$141.makeStringProp)("cross"),
		showHeader: import_utils$141.truthProp,
		modelValue: import_utils$141.numericProp,
		fieldNames: Object,
		placeholder: String,
		activeColor: String
	};
	var stdin_default$138 = (0, import_vue$73.defineComponent)({
		name: name$65,
		props: cascaderProps,
		emits: [
			"close",
			"change",
			"finish",
			"clickTab",
			"update:modelValue"
		],
		setup(props$1, { slots, emit }) {
			const tabs = (0, import_vue$73.ref)([]);
			const activeTab = (0, import_vue$73.ref)(0);
			const [selectedElementRefs, setSelectedElementRefs] = (0, import_use_refs$2.useRefs)();
			const { text: textKey, value: valueKey, children: childrenKey } = (0, import_utils$141.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
						});
						(0, import_vue$73.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);
					(0, import_vue$73.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 ? (0, import_vue$73.createVNode)("div", { "class": bem$64("header") }, [(0, import_vue$73.createVNode)("h2", { "class": bem$64("title") }, [slots.title ? slots.title() : props$1.title]), props$1.closeable ? (0, import_vue$73.createVNode)(import_icon$18.Icon, {
				"name": props$1.closeIcon,
				"class": [bem$64("close-icon"), import_utils$141.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 = slots.option ? slots.option({
					option,
					selected
				}) : (0, import_vue$73.createVNode)("span", null, [option[textKey]]);
				return (0, import_vue$73.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, selected ? (0, import_vue$73.createVNode)(import_icon$18.Icon, {
					"name": "success",
					"class": bem$64("selected-icon")
				}, null) : null]);
			};
			const renderOptions = (options, selectedOption, tabIndex) => (0, import_vue$73.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 (0, import_vue$73.createVNode)(import_tab$2.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 = () => (0, import_vue$73.createVNode)(import_tabs$2.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();
			(0, import_vue$73.watch)(activeTab, (value) => {
				const el = selectedElementRefs.value[value];
				if (el) scrollIntoView(el);
			});
			(0, import_vue$73.watch)(() => props$1.options, updateTabs, { deep: true });
			(0, import_vue$73.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 () => (0, import_vue$73.createVNode)("div", { "class": bem$64() }, [renderHeader(), renderTabs()]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/cascader/index.js
var require_cascader = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/cascader/index.js": ((exports, module) => {
	var __create$76 = Object.create;
	var __defProp$147 = Object.defineProperty;
	var __getOwnPropDesc$147 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$147 = Object.getOwnPropertyNames;
	var __getProtoOf$76 = Object.getPrototypeOf;
	var __hasOwnProp$147 = Object.prototype.hasOwnProperty;
	var __export$147 = (target, all) => {
		for (var name$111 in all) __defProp$147(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$147 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$147(from)) if (!__hasOwnProp$147.call(to, key) && key !== except) __defProp$147(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$147(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$76 = (mod, isNodeMode, target) => (target = mod != null ? __create$76(__getProtoOf$76(mod)) : {}, __copyProps$147(isNodeMode || !mod || !mod.__esModule ? __defProp$147(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$147 = (mod) => __copyProps$147(__defProp$147({}, "__esModule", { value: true }), mod);
	var stdin_exports$146 = {};
	__export$147(stdin_exports$146, {
		Cascader: () => Cascader,
		cascaderProps: () => import_Cascader2.cascaderProps,
		default: () => stdin_default$137
	});
	module.exports = __toCommonJS$147(stdin_exports$146);
	var import_utils$140 = require_utils$9();
	var import_Cascader = __toESM$76(require_Cascader());
	var import_Cascader2 = require_Cascader();
	var Cascader = (0, import_utils$140.withInstall)(import_Cascader.default);
	var stdin_default$137 = Cascader;
}) });

//#endregion
//#region node_modules/vant/lib/cell-group/CellGroup.js
var require_CellGroup = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/cell-group/CellGroup.js": ((exports, module) => {
	var __defProp$146 = Object.defineProperty;
	var __getOwnPropDesc$146 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$146 = Object.getOwnPropertyNames;
	var __hasOwnProp$146 = Object.prototype.hasOwnProperty;
	var __export$146 = (target, all) => {
		for (var name2 in all) __defProp$146(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$146 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$146(from)) if (!__hasOwnProp$146.call(to, key) && key !== except) __defProp$146(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$146(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$146 = (mod) => __copyProps$146(__defProp$146({}, "__esModule", { value: true }), mod);
	var stdin_exports$145 = {};
	__export$146(stdin_exports$145, {
		cellGroupProps: () => cellGroupProps,
		default: () => stdin_default$136
	});
	module.exports = __toCommonJS$146(stdin_exports$145);
	var import_vue$72 = require_vue();
	var import_utils$139 = require_utils$9();
	var import_use_scope_id$1 = require_use_scope_id();
	var [name$64, bem$63] = (0, import_utils$139.createNamespace)("cell-group");
	var cellGroupProps = {
		title: String,
		inset: Boolean,
		border: import_utils$139.truthProp
	};
	var stdin_default$136 = (0, import_vue$72.defineComponent)({
		name: name$64,
		inheritAttrs: false,
		props: cellGroupProps,
		setup(props$1, { slots, attrs }) {
			const renderGroup = () => {
				var _a;
				return (0, import_vue$72.createVNode)("div", (0, import_vue$72.mergeProps)({ "class": [bem$63({ inset: props$1.inset }), { [import_utils$139.BORDER_TOP_BOTTOM]: props$1.border && !props$1.inset }] }, attrs, (0, import_use_scope_id$1.useScopeId)()), [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
			const renderTitle = () => (0, import_vue$72.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 (0, import_vue$72.createVNode)(import_vue$72.Fragment, null, [renderTitle(), renderGroup()]);
				return renderGroup();
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/cell-group/index.js
var require_cell_group = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/cell-group/index.js": ((exports, module) => {
	var __create$75 = Object.create;
	var __defProp$145 = Object.defineProperty;
	var __getOwnPropDesc$145 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$145 = Object.getOwnPropertyNames;
	var __getProtoOf$75 = Object.getPrototypeOf;
	var __hasOwnProp$145 = Object.prototype.hasOwnProperty;
	var __export$145 = (target, all) => {
		for (var name$111 in all) __defProp$145(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$145 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$145(from)) if (!__hasOwnProp$145.call(to, key) && key !== except) __defProp$145(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$145(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$75 = (mod, isNodeMode, target) => (target = mod != null ? __create$75(__getProtoOf$75(mod)) : {}, __copyProps$145(isNodeMode || !mod || !mod.__esModule ? __defProp$145(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$145 = (mod) => __copyProps$145(__defProp$145({}, "__esModule", { value: true }), mod);
	var stdin_exports$144 = {};
	__export$145(stdin_exports$144, {
		CellGroup: () => CellGroup,
		cellGroupProps: () => import_CellGroup2.cellGroupProps,
		default: () => stdin_default$135
	});
	module.exports = __toCommonJS$145(stdin_exports$144);
	var import_utils$138 = require_utils$9();
	var import_CellGroup = __toESM$75(require_CellGroup());
	var import_CellGroup2 = require_CellGroup();
	var CellGroup = (0, import_utils$138.withInstall)(import_CellGroup.default);
	var stdin_default$135 = CellGroup;
}) });

//#endregion
//#region node_modules/vant/lib/circle/Circle.js
var require_Circle = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/circle/Circle.js": ((exports, module) => {
	var __defProp$144 = Object.defineProperty;
	var __getOwnPropDesc$144 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$144 = Object.getOwnPropertyNames;
	var __hasOwnProp$144 = Object.prototype.hasOwnProperty;
	var __export$144 = (target, all) => {
		for (var name2 in all) __defProp$144(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$144 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$144(from)) if (!__hasOwnProp$144.call(to, key) && key !== except) __defProp$144(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$144(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$144 = (mod) => __copyProps$144(__defProp$144({}, "__esModule", { value: true }), mod);
	var stdin_exports$143 = {};
	__export$144(stdin_exports$143, {
		circleProps: () => circleProps,
		default: () => stdin_default$134
	});
	module.exports = __toCommonJS$144(stdin_exports$143);
	var import_vue$71 = require_vue();
	var import_use$38 = require_index_cjs$1();
	var import_utils$137 = require_utils$9();
	var [name$63, bem$62] = (0, import_utils$137.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: import_utils$137.numericProp,
		fill: (0, import_utils$137.makeStringProp)("none"),
		rate: (0, import_utils$137.makeNumericProp)(100),
		speed: (0, import_utils$137.makeNumericProp)(0),
		color: [String, Object],
		clockwise: import_utils$137.truthProp,
		layerColor: String,
		currentRate: (0, import_utils$137.makeNumberProp)(0),
		strokeWidth: (0, import_utils$137.makeNumericProp)(40),
		strokeLinecap: String,
		startPosition: (0, import_utils$137.makeStringProp)("top")
	};
	var stdin_default$134 = (0, import_vue$71.defineComponent)({
		name: name$63,
		props: circleProps,
		emits: ["update:currentRate"],
		setup(props$1, { emit, slots }) {
			const id = `van-circle-${uid++}`;
			const viewBoxSize = (0, import_vue$71.computed)(() => +props$1.strokeWidth + 1e3);
			const path = (0, import_vue$71.computed)(() => getPath(props$1.clockwise, viewBoxSize.value));
			const svgStyle = (0, import_vue$71.computed)(() => {
				const angleValue = {
					top: 0,
					right: 90,
					bottom: 180,
					left: 270
				}[props$1.startPosition];
				if (angleValue) return { transform: `rotate(${angleValue}deg)` };
			});
			(0, import_vue$71.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 = (0, import_use$38.raf)(animate);
				};
				if (props$1.speed) {
					if (rafId) (0, import_use$38.cancelRaf)(rafId);
					rafId = (0, import_use$38.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 = (0, import_utils$137.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 (0, import_vue$71.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 (0, import_vue$71.createVNode)("path", {
					"class": bem$62("layer"),
					"style": style,
					"d": path.value
				}, null);
			};
			const renderGradient = () => {
				const { color } = props$1;
				if (!(0, import_utils$137.isObject)(color)) return;
				const Stops = Object.keys(color).sort((a, b) => parseFloat(a) - parseFloat(b)).map((key, index) => (0, import_vue$71.createVNode)("stop", {
					"key": index,
					"offset": key,
					"stop-color": color[key]
				}, null));
				return (0, import_vue$71.createVNode)("defs", null, [(0, import_vue$71.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 (0, import_vue$71.createVNode)("div", { "class": bem$62("text") }, [props$1.text]);
			};
			return () => (0, import_vue$71.createVNode)("div", {
				"class": bem$62(),
				"style": (0, import_utils$137.getSizeStyle)(props$1.size)
			}, [(0, import_vue$71.createVNode)("svg", {
				"viewBox": `0 0 ${viewBoxSize.value} ${viewBoxSize.value}`,
				"style": svgStyle.value
			}, [
				renderGradient(),
				renderLayer(),
				renderHover()
			]), renderText()]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/circle/index.js
var require_circle = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/circle/index.js": ((exports, module) => {
	var __create$74 = Object.create;
	var __defProp$143 = Object.defineProperty;
	var __getOwnPropDesc$143 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$143 = Object.getOwnPropertyNames;
	var __getProtoOf$74 = Object.getPrototypeOf;
	var __hasOwnProp$143 = Object.prototype.hasOwnProperty;
	var __export$143 = (target, all) => {
		for (var name$111 in all) __defProp$143(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$143 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$143(from)) if (!__hasOwnProp$143.call(to, key) && key !== except) __defProp$143(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$143(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$74 = (mod, isNodeMode, target) => (target = mod != null ? __create$74(__getProtoOf$74(mod)) : {}, __copyProps$143(isNodeMode || !mod || !mod.__esModule ? __defProp$143(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$143 = (mod) => __copyProps$143(__defProp$143({}, "__esModule", { value: true }), mod);
	var stdin_exports$142 = {};
	__export$143(stdin_exports$142, {
		Circle: () => Circle,
		circleProps: () => import_Circle2.circleProps,
		default: () => stdin_default$133
	});
	module.exports = __toCommonJS$143(stdin_exports$142);
	var import_utils$136 = require_utils$9();
	var import_Circle = __toESM$74(require_Circle());
	var import_Circle2 = require_Circle();
	var Circle = (0, import_utils$136.withInstall)(import_Circle.default);
	var stdin_default$133 = Circle;
}) });

//#endregion
//#region node_modules/vant/lib/row/Row.js
var require_Row = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/row/Row.js": ((exports, module) => {
	var __defProp$142 = Object.defineProperty;
	var __getOwnPropDesc$142 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$142 = Object.getOwnPropertyNames;
	var __hasOwnProp$142 = Object.prototype.hasOwnProperty;
	var __export$142 = (target, all) => {
		for (var name2 in all) __defProp$142(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$142 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$142(from)) if (!__hasOwnProp$142.call(to, key) && key !== except) __defProp$142(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$142(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$142 = (mod) => __copyProps$142(__defProp$142({}, "__esModule", { value: true }), mod);
	var stdin_exports$141 = {};
	__export$142(stdin_exports$141, {
		ROW_KEY: () => ROW_KEY,
		default: () => stdin_default$132,
		rowProps: () => rowProps
	});
	module.exports = __toCommonJS$142(stdin_exports$141);
	var import_vue$70 = require_vue();
	var import_utils$135 = require_utils$9();
	var import_use$37 = require_index_cjs$1();
	var [name$62, bem$61] = (0, import_utils$135.createNamespace)("row");
	var ROW_KEY = Symbol(name$62);
	var rowProps = {
		tag: (0, import_utils$135.makeStringProp)("div"),
		wrap: import_utils$135.truthProp,
		align: String,
		gutter: {
			type: [
				String,
				Number,
				Array
			],
			default: 0
		},
		justify: String
	};
	var stdin_default$132 = (0, import_vue$70.defineComponent)({
		name: name$62,
		props: rowProps,
		setup(props$1, { slots }) {
			const { children, linkChildren } = (0, import_use$37.useChildren)(ROW_KEY);
			const groups = (0, import_vue$70.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: (0, import_vue$70.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: (0, import_vue$70.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 (0, import_vue$70.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/lib/col/Col.js
var require_Col = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/col/Col.js": ((exports, module) => {
	var __defProp$141 = Object.defineProperty;
	var __getOwnPropDesc$141 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$141 = Object.getOwnPropertyNames;
	var __hasOwnProp$141 = Object.prototype.hasOwnProperty;
	var __export$141 = (target, all) => {
		for (var name2 in all) __defProp$141(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$141 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$141(from)) if (!__hasOwnProp$141.call(to, key) && key !== except) __defProp$141(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$141(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$141 = (mod) => __copyProps$141(__defProp$141({}, "__esModule", { value: true }), mod);
	var stdin_exports$140 = {};
	__export$141(stdin_exports$140, {
		colProps: () => colProps,
		default: () => stdin_default$131
	});
	module.exports = __toCommonJS$141(stdin_exports$140);
	var import_vue$69 = require_vue();
	var import_utils$134 = require_utils$9();
	var import_use$36 = require_index_cjs$1();
	var import_Row$1 = require_Row();
	var [name$61, bem$60] = (0, import_utils$134.createNamespace)("col");
	var colProps = {
		tag: (0, import_utils$134.makeStringProp)("div"),
		span: (0, import_utils$134.makeNumericProp)(0),
		offset: import_utils$134.numericProp
	};
	var stdin_default$131 = (0, import_vue$69.defineComponent)({
		name: name$61,
		props: colProps,
		setup(props$1, { slots }) {
			const { parent, index } = (0, import_use$36.useParent)(import_Row$1.ROW_KEY);
			const style = (0, import_vue$69.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 (0, import_utils$134.extend)(styles, { marginBottom: bottom$1 ? `${bottom$1}px` : null });
			});
			return () => {
				const { tag, span, offset: offset$1 } = props$1;
				return (0, import_vue$69.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/lib/col/index.js
var require_col = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/col/index.js": ((exports, module) => {
	var __create$73 = Object.create;
	var __defProp$140 = Object.defineProperty;
	var __getOwnPropDesc$140 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$140 = Object.getOwnPropertyNames;
	var __getProtoOf$73 = Object.getPrototypeOf;
	var __hasOwnProp$140 = Object.prototype.hasOwnProperty;
	var __export$140 = (target, all) => {
		for (var name$111 in all) __defProp$140(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$140 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$140(from)) if (!__hasOwnProp$140.call(to, key) && key !== except) __defProp$140(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$140(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$73 = (mod, isNodeMode, target) => (target = mod != null ? __create$73(__getProtoOf$73(mod)) : {}, __copyProps$140(isNodeMode || !mod || !mod.__esModule ? __defProp$140(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$140 = (mod) => __copyProps$140(__defProp$140({}, "__esModule", { value: true }), mod);
	var stdin_exports$139 = {};
	__export$140(stdin_exports$139, {
		Col: () => Col,
		colProps: () => import_Col2.colProps,
		default: () => stdin_default$130
	});
	module.exports = __toCommonJS$140(stdin_exports$139);
	var import_utils$133 = require_utils$9();
	var import_Col = __toESM$73(require_Col());
	var import_Col2 = require_Col();
	var Col = (0, import_utils$133.withInstall)(import_Col.default);
	var stdin_default$130 = Col;
}) });

//#endregion
//#region node_modules/vant/lib/collapse/Collapse.js
var require_Collapse = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/collapse/Collapse.js": ((exports, module) => {
	var __defProp$139 = Object.defineProperty;
	var __getOwnPropDesc$139 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$139 = Object.getOwnPropertyNames;
	var __hasOwnProp$139 = Object.prototype.hasOwnProperty;
	var __export$139 = (target, all) => {
		for (var name2 in all) __defProp$139(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$139 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$139(from)) if (!__hasOwnProp$139.call(to, key) && key !== except) __defProp$139(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$139(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$139 = (mod) => __copyProps$139(__defProp$139({}, "__esModule", { value: true }), mod);
	var stdin_exports$138 = {};
	__export$139(stdin_exports$138, {
		COLLAPSE_KEY: () => COLLAPSE_KEY,
		collapseProps: () => collapseProps,
		default: () => stdin_default$129
	});
	module.exports = __toCommonJS$139(stdin_exports$138);
	var import_vue$68 = require_vue();
	var import_utils$132 = require_utils$9();
	var import_use$35 = require_index_cjs$1();
	var import_use_expose$18 = require_use_expose();
	var [name$60, bem$59] = (0, import_utils$132.createNamespace)("collapse");
	var COLLAPSE_KEY = Symbol(name$60);
	var collapseProps = {
		border: import_utils$132.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$129 = (0, import_vue$68.defineComponent)({
		name: name$60,
		props: collapseProps,
		emits: ["change", "update:modelValue"],
		setup(props$1, { emit, slots }) {
			const { linkChildren, children } = (0, import_use$35.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);
			};
			(0, import_use_expose$18.useExpose)({ toggleAll });
			linkChildren({
				toggle,
				isExpanded
			});
			return () => {
				var _a;
				return (0, import_vue$68.createVNode)("div", { "class": [bem$59(), { [import_utils$132.BORDER_TOP_BOTTOM]: props$1.border }] }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/collapse/index.js
var require_collapse = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/collapse/index.js": ((exports, module) => {
	var __create$72 = Object.create;
	var __defProp$138 = Object.defineProperty;
	var __getOwnPropDesc$138 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$138 = Object.getOwnPropertyNames;
	var __getProtoOf$72 = Object.getPrototypeOf;
	var __hasOwnProp$138 = Object.prototype.hasOwnProperty;
	var __export$138 = (target, all) => {
		for (var name$111 in all) __defProp$138(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$138 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$138(from)) if (!__hasOwnProp$138.call(to, key) && key !== except) __defProp$138(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$138(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$72 = (mod, isNodeMode, target) => (target = mod != null ? __create$72(__getProtoOf$72(mod)) : {}, __copyProps$138(isNodeMode || !mod || !mod.__esModule ? __defProp$138(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$138 = (mod) => __copyProps$138(__defProp$138({}, "__esModule", { value: true }), mod);
	var stdin_exports$137 = {};
	__export$138(stdin_exports$137, {
		Collapse: () => Collapse,
		collapseProps: () => import_Collapse2.collapseProps,
		default: () => stdin_default$128
	});
	module.exports = __toCommonJS$138(stdin_exports$137);
	var import_utils$131 = require_utils$9();
	var import_Collapse$1 = __toESM$72(require_Collapse());
	var import_Collapse2 = require_Collapse();
	var Collapse = (0, import_utils$131.withInstall)(import_Collapse$1.default);
	var stdin_default$128 = Collapse;
}) });

//#endregion
//#region node_modules/vant/lib/collapse-item/CollapseItem.js
var require_CollapseItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/collapse-item/CollapseItem.js": ((exports, module) => {
	var __defProp$137 = Object.defineProperty;
	var __getOwnPropDesc$137 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$137 = Object.getOwnPropertyNames;
	var __hasOwnProp$137 = Object.prototype.hasOwnProperty;
	var __export$137 = (target, all) => {
		for (var name2 in all) __defProp$137(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$137 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$137(from)) if (!__hasOwnProp$137.call(to, key) && key !== except) __defProp$137(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$137(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$137 = (mod) => __copyProps$137(__defProp$137({}, "__esModule", { value: true }), mod);
	var stdin_exports$136 = {};
	__export$137(stdin_exports$136, {
		collapseItemProps: () => collapseItemProps,
		default: () => stdin_default$127
	});
	module.exports = __toCommonJS$137(stdin_exports$136);
	var import_vue$67 = require_vue();
	var import_Cell = require_Cell();
	var import_utils$130 = require_utils$9();
	var import_Collapse = require_Collapse();
	var import_use$34 = require_index_cjs$1();
	var import_use_expose$17 = require_use_expose();
	var import_use_lazy_render = require_use_lazy_render();
	var import_cell$6 = require_cell();
	var [name$59, bem$58] = (0, import_utils$130.createNamespace)("collapse-item");
	var CELL_SLOTS = [
		"icon",
		"title",
		"value",
		"label",
		"right-icon"
	];
	var collapseItemProps = (0, import_utils$130.extend)({}, import_Cell.cellSharedProps, {
		name: import_utils$130.numericProp,
		isLink: import_utils$130.truthProp,
		disabled: Boolean,
		readonly: Boolean,
		lazyRender: import_utils$130.truthProp
	});
	var stdin_default$127 = (0, import_vue$67.defineComponent)({
		name: name$59,
		props: collapseItemProps,
		setup(props$1, { slots }) {
			const wrapperRef = (0, import_vue$67.ref)();
			const contentRef = (0, import_vue$67.ref)();
			const { parent, index } = (0, import_use$34.useParent)(import_Collapse.COLLAPSE_KEY);
			if (!parent) {
				console.error("[Vant] <CollapseItem> must be a child component of <Collapse>.");
				return;
			}
			const name2 = (0, import_vue$67.computed)(() => {
				var _a;
				return (_a = props$1.name) != null ? _a : index.value;
			});
			const expanded = (0, import_vue$67.computed)(() => parent.isExpanded(name2.value));
			const show = (0, import_vue$67.ref)(expanded.value);
			const lazyRender = (0, import_use_lazy_render.useLazyRender)(() => show.value || !props$1.lazyRender);
			const onTransitionEnd = () => {
				if (!expanded.value) show.value = false;
				else if (wrapperRef.value) wrapperRef.value.style.height = "";
			};
			(0, import_vue$67.watch)(expanded, (value, oldValue) => {
				if (oldValue === null) return;
				if (value) show.value = true;
				(value ? import_vue$67.nextTick : import_use$34.raf)(() => {
					if (!contentRef.value || !wrapperRef.value) return;
					const { offsetHeight } = contentRef.value;
					if (offsetHeight) {
						const contentHeight = `${offsetHeight}px`;
						wrapperRef.value.style.height = value ? "0" : contentHeight;
						(0, import_use$34.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 = (0, import_utils$130.pick)(props$1, Object.keys(import_Cell.cellSharedProps));
				if (readonly) attrs.isLink = false;
				if (disabled || readonly) attrs.clickable = false;
				return (0, import_vue$67.createVNode)(import_cell$6.Cell, (0, import_vue$67.mergeProps)({
					"role": "button",
					"class": bem$58("title", {
						disabled,
						expanded: expanded.value,
						borderless: !border
					}),
					"aria-expanded": String(expanded.value),
					"onClick": onClickTitle
				}, attrs), (0, import_utils$130.pick)(slots, CELL_SLOTS));
			};
			const renderContent = lazyRender(() => {
				var _a;
				return (0, import_vue$67.withDirectives)((0, import_vue$67.createVNode)("div", {
					"ref": wrapperRef,
					"class": bem$58("wrapper"),
					"onTransitionend": onTransitionEnd
				}, [(0, import_vue$67.createVNode)("div", {
					"ref": contentRef,
					"class": bem$58("content")
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]), [[import_vue$67.vShow, show.value]]);
			});
			(0, import_use_expose$17.useExpose)({
				toggle,
				expanded,
				itemName: name2
			});
			return () => (0, import_vue$67.createVNode)("div", { "class": [bem$58({ border: index.value && props$1.border })] }, [renderTitle(), renderContent()]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/collapse-item/index.js
var require_collapse_item = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/collapse-item/index.js": ((exports, module) => {
	var __create$71 = Object.create;
	var __defProp$136 = Object.defineProperty;
	var __getOwnPropDesc$136 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$136 = Object.getOwnPropertyNames;
	var __getProtoOf$71 = Object.getPrototypeOf;
	var __hasOwnProp$136 = Object.prototype.hasOwnProperty;
	var __export$136 = (target, all) => {
		for (var name$111 in all) __defProp$136(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$136 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$136(from)) if (!__hasOwnProp$136.call(to, key) && key !== except) __defProp$136(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$136(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$71 = (mod, isNodeMode, target) => (target = mod != null ? __create$71(__getProtoOf$71(mod)) : {}, __copyProps$136(isNodeMode || !mod || !mod.__esModule ? __defProp$136(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$136 = (mod) => __copyProps$136(__defProp$136({}, "__esModule", { value: true }), mod);
	var stdin_exports$135 = {};
	__export$136(stdin_exports$135, {
		CollapseItem: () => CollapseItem,
		collapseItemProps: () => import_CollapseItem2.collapseItemProps,
		default: () => stdin_default$126
	});
	module.exports = __toCommonJS$136(stdin_exports$135);
	var import_utils$129 = require_utils$9();
	var import_CollapseItem = __toESM$71(require_CollapseItem());
	var import_CollapseItem2 = require_CollapseItem();
	var CollapseItem = (0, import_utils$129.withInstall)(import_CollapseItem.default);
	var stdin_default$126 = CollapseItem;
}) });

//#endregion
//#region node_modules/vant/lib/config-provider/index.js
var require_config_provider = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/config-provider/index.js": ((exports, module) => {
	var __create$70 = Object.create;
	var __defProp$135 = Object.defineProperty;
	var __getOwnPropDesc$135 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$135 = Object.getOwnPropertyNames;
	var __getProtoOf$70 = Object.getPrototypeOf;
	var __hasOwnProp$135 = Object.prototype.hasOwnProperty;
	var __export$135 = (target, all) => {
		for (var name$111 in all) __defProp$135(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$135 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$135(from)) if (!__hasOwnProp$135.call(to, key) && key !== except) __defProp$135(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$135(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$70 = (mod, isNodeMode, target) => (target = mod != null ? __create$70(__getProtoOf$70(mod)) : {}, __copyProps$135(isNodeMode || !mod || !mod.__esModule ? __defProp$135(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$135 = (mod) => __copyProps$135(__defProp$135({}, "__esModule", { value: true }), mod);
	var stdin_exports$134 = {};
	__export$135(stdin_exports$134, {
		ConfigProvider: () => ConfigProvider,
		configProviderProps: () => import_ConfigProvider2.configProviderProps,
		default: () => stdin_default$125
	});
	module.exports = __toCommonJS$135(stdin_exports$134);
	var import_utils$128 = require_utils$9();
	var import_ConfigProvider = __toESM$70(require_ConfigProvider());
	var import_ConfigProvider2 = require_ConfigProvider();
	var ConfigProvider = (0, import_utils$128.withInstall)(import_ConfigProvider.default);
	var stdin_default$125 = ConfigProvider;
}) });

//#endregion
//#region node_modules/vant/lib/contact-card/ContactCard.js
var require_ContactCard = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/contact-card/ContactCard.js": ((exports, module) => {
	var __defProp$134 = Object.defineProperty;
	var __getOwnPropDesc$134 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$134 = Object.getOwnPropertyNames;
	var __hasOwnProp$134 = Object.prototype.hasOwnProperty;
	var __export$134 = (target, all) => {
		for (var name2 in all) __defProp$134(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$134 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$134(from)) if (!__hasOwnProp$134.call(to, key) && key !== except) __defProp$134(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$134(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$134 = (mod) => __copyProps$134(__defProp$134({}, "__esModule", { value: true }), mod);
	var stdin_exports$133 = {};
	__export$134(stdin_exports$133, {
		contactCardProps: () => contactCardProps,
		default: () => stdin_default$124
	});
	module.exports = __toCommonJS$134(stdin_exports$133);
	var import_vue$66 = require_vue();
	var import_utils$127 = require_utils$9();
	var import_cell$5 = require_cell();
	var [name$58, bem$57, t$14] = (0, import_utils$127.createNamespace)("contact-card");
	var contactCardProps = {
		tel: String,
		name: String,
		type: (0, import_utils$127.makeStringProp)("add"),
		addText: String,
		editable: import_utils$127.truthProp
	};
	var stdin_default$124 = (0, import_vue$66.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 [(0, import_vue$66.createVNode)("div", null, [`${t$14("name")}\uFF1A${props$1.name}`]), (0, import_vue$66.createVNode)("div", null, [`${t$14("tel")}\uFF1A${props$1.tel}`])];
			};
			return () => (0, import_vue$66.createVNode)(import_cell$5.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/lib/contact-card/index.js
var require_contact_card = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/contact-card/index.js": ((exports, module) => {
	var __create$69 = Object.create;
	var __defProp$133 = Object.defineProperty;
	var __getOwnPropDesc$133 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$133 = Object.getOwnPropertyNames;
	var __getProtoOf$69 = Object.getPrototypeOf;
	var __hasOwnProp$133 = Object.prototype.hasOwnProperty;
	var __export$133 = (target, all) => {
		for (var name$111 in all) __defProp$133(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$133 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$133(from)) if (!__hasOwnProp$133.call(to, key) && key !== except) __defProp$133(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$133(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$69 = (mod, isNodeMode, target) => (target = mod != null ? __create$69(__getProtoOf$69(mod)) : {}, __copyProps$133(isNodeMode || !mod || !mod.__esModule ? __defProp$133(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$133 = (mod) => __copyProps$133(__defProp$133({}, "__esModule", { value: true }), mod);
	var stdin_exports$132 = {};
	__export$133(stdin_exports$132, {
		ContactCard: () => ContactCard,
		contactCardProps: () => import_ContactCard2.contactCardProps,
		default: () => stdin_default$123
	});
	module.exports = __toCommonJS$133(stdin_exports$132);
	var import_utils$126 = require_utils$9();
	var import_ContactCard = __toESM$69(require_ContactCard());
	var import_ContactCard2 = require_ContactCard();
	var ContactCard = (0, import_utils$126.withInstall)(import_ContactCard.default);
	var stdin_default$123 = ContactCard;
}) });

//#endregion
//#region node_modules/vant/lib/contact-edit/ContactEdit.js
var require_ContactEdit = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/contact-edit/ContactEdit.js": ((exports, module) => {
	var __defProp$132 = Object.defineProperty;
	var __getOwnPropDesc$132 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$132 = Object.getOwnPropertyNames;
	var __hasOwnProp$132 = Object.prototype.hasOwnProperty;
	var __export$132 = (target, all) => {
		for (var name2 in all) __defProp$132(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$132 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$132(from)) if (!__hasOwnProp$132.call(to, key) && key !== except) __defProp$132(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$132(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$132 = (mod) => __copyProps$132(__defProp$132({}, "__esModule", { value: true }), mod);
	var stdin_exports$131 = {};
	__export$132(stdin_exports$131, {
		contactEditProps: () => contactEditProps,
		default: () => stdin_default$122
	});
	module.exports = __toCommonJS$132(stdin_exports$131);
	var import_vue$65 = require_vue();
	var import_utils$125 = require_utils$9();
	var import_cell$4 = require_cell();
	var import_form$1 = require_form();
	var import_field$3 = require_field();
	var import_button$6 = require_button();
	var import_switch$1 = require_switch();
	var [name$57, bem$56, t$13] = (0, import_utils$125.createNamespace)("contact-edit");
	var DEFAULT_CONTACT = {
		tel: "",
		name: ""
	};
	var contactEditProps = {
		isEdit: Boolean,
		isSaving: Boolean,
		isDeleting: Boolean,
		showSetDefault: Boolean,
		setDefaultLabel: String,
		contactInfo: {
			type: Object,
			default: () => (0, import_utils$125.extend)({}, DEFAULT_CONTACT)
		},
		telValidator: {
			type: Function,
			default: import_utils$125.isMobile
		}
	};
	var stdin_default$122 = (0, import_vue$65.defineComponent)({
		name: name$57,
		props: contactEditProps,
		emits: [
			"save",
			"delete",
			"changeDefault"
		],
		setup(props$1, { emit }) {
			const contact = (0, import_vue$65.reactive)((0, import_utils$125.extend)({}, DEFAULT_CONTACT, props$1.contactInfo));
			const onSave = () => {
				if (!props$1.isSaving) emit("save", contact);
			};
			const onDelete = () => emit("delete", contact);
			const renderButtons = () => (0, import_vue$65.createVNode)("div", { "class": bem$56("buttons") }, [(0, import_vue$65.createVNode)(import_button$6.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 && (0, import_vue$65.createVNode)(import_button$6.Button, {
				"block": true,
				"round": true,
				"text": t$13("delete"),
				"class": bem$56("button"),
				"loading": props$1.isDeleting,
				"onClick": onDelete
			}, null)]);
			const renderSwitch = () => (0, import_vue$65.createVNode)(import_switch$1.Switch, {
				"modelValue": contact.isDefault,
				"onUpdate:modelValue": ($event) => contact.isDefault = $event,
				"onChange": (checked) => emit("changeDefault", checked)
			}, null);
			const renderSetDefault = () => {
				if (props$1.showSetDefault) return (0, import_vue$65.createVNode)(import_cell$4.Cell, {
					"title": props$1.setDefaultLabel,
					"class": bem$56("switch-cell"),
					"border": false
				}, { "right-icon": renderSwitch });
			};
			(0, import_vue$65.watch)(() => props$1.contactInfo, (value) => (0, import_utils$125.extend)(contact, DEFAULT_CONTACT, value));
			return () => (0, import_vue$65.createVNode)(import_form$1.Form, {
				"class": bem$56(),
				"onSubmit": onSave
			}, { default: () => [
				(0, import_vue$65.createVNode)("div", { "class": bem$56("fields") }, [(0, import_vue$65.createVNode)(import_field$3.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), (0, import_vue$65.createVNode)(import_field$3.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/lib/contact-edit/index.js
var require_contact_edit = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/contact-edit/index.js": ((exports, module) => {
	var __create$68 = Object.create;
	var __defProp$131 = Object.defineProperty;
	var __getOwnPropDesc$131 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$131 = Object.getOwnPropertyNames;
	var __getProtoOf$68 = Object.getPrototypeOf;
	var __hasOwnProp$131 = Object.prototype.hasOwnProperty;
	var __export$131 = (target, all) => {
		for (var name$111 in all) __defProp$131(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$131 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$131(from)) if (!__hasOwnProp$131.call(to, key) && key !== except) __defProp$131(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$131(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$68 = (mod, isNodeMode, target) => (target = mod != null ? __create$68(__getProtoOf$68(mod)) : {}, __copyProps$131(isNodeMode || !mod || !mod.__esModule ? __defProp$131(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$131 = (mod) => __copyProps$131(__defProp$131({}, "__esModule", { value: true }), mod);
	var stdin_exports$130 = {};
	__export$131(stdin_exports$130, {
		ContactEdit: () => ContactEdit,
		contactEditProps: () => import_ContactEdit2.contactEditProps,
		default: () => stdin_default$121
	});
	module.exports = __toCommonJS$131(stdin_exports$130);
	var import_utils$124 = require_utils$9();
	var import_ContactEdit = __toESM$68(require_ContactEdit());
	var import_ContactEdit2 = require_ContactEdit();
	var ContactEdit = (0, import_utils$124.withInstall)(import_ContactEdit.default);
	var stdin_default$121 = ContactEdit;
}) });

//#endregion
//#region node_modules/vant/lib/contact-list/ContactList.js
var require_ContactList = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/contact-list/ContactList.js": ((exports, module) => {
	var __defProp$130 = Object.defineProperty;
	var __getOwnPropDesc$130 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$130 = Object.getOwnPropertyNames;
	var __hasOwnProp$130 = Object.prototype.hasOwnProperty;
	var __export$130 = (target, all) => {
		for (var name2 in all) __defProp$130(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$130 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$130(from)) if (!__hasOwnProp$130.call(to, key) && key !== except) __defProp$130(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$130(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$130 = (mod) => __copyProps$130(__defProp$130({}, "__esModule", { value: true }), mod);
	var stdin_exports$129 = {};
	__export$130(stdin_exports$129, {
		contactListProps: () => contactListProps,
		default: () => stdin_default$120
	});
	module.exports = __toCommonJS$130(stdin_exports$129);
	var import_vue$64 = require_vue();
	var import_utils$123 = require_utils$9();
	var import_tag$1 = require_tag();
	var import_icon$17 = require_icon();
	var import_cell$3 = require_cell();
	var import_radio$1 = require_radio();
	var import_button$5 = require_button();
	var import_radio_group$1 = require_radio_group();
	var [name$56, bem$55, t$12] = (0, import_utils$123.createNamespace)("contact-list");
	var contactListProps = {
		list: Array,
		addText: String,
		modelValue: import_utils$123.unknownProp,
		defaultTagText: String
	};
	var stdin_default$120 = (0, import_vue$64.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 = () => (0, import_vue$64.createVNode)(import_radio$1.Radio, {
					"class": bem$55("radio"),
					"name": item.id,
					"iconSize": 18
				}, null);
				const renderEditIcon = () => (0, import_vue$64.createVNode)(import_icon$17.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((0, import_vue$64.createVNode)(import_tag$1.Tag, {
						"type": "primary",
						"round": true,
						"class": bem$55("item-tag")
					}, { default: () => [props$1.defaultTagText] }));
					return nodes;
				};
				return (0, import_vue$64.createVNode)(import_cell$3.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 () => (0, import_vue$64.createVNode)("div", { "class": bem$55() }, [(0, import_vue$64.createVNode)(import_radio_group$1.RadioGroup, {
				"modelValue": props$1.modelValue,
				"class": bem$55("group")
			}, { default: () => [props$1.list && props$1.list.map(renderItem)] }), (0, import_vue$64.createVNode)("div", { "class": [bem$55("bottom"), "van-safe-area-bottom"] }, [(0, import_vue$64.createVNode)(import_button$5.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/lib/contact-list/index.js
var require_contact_list = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/contact-list/index.js": ((exports, module) => {
	var __create$67 = Object.create;
	var __defProp$129 = Object.defineProperty;
	var __getOwnPropDesc$129 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$129 = Object.getOwnPropertyNames;
	var __getProtoOf$67 = Object.getPrototypeOf;
	var __hasOwnProp$129 = Object.prototype.hasOwnProperty;
	var __export$129 = (target, all) => {
		for (var name$111 in all) __defProp$129(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$129 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$129(from)) if (!__hasOwnProp$129.call(to, key) && key !== except) __defProp$129(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$129(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$67 = (mod, isNodeMode, target) => (target = mod != null ? __create$67(__getProtoOf$67(mod)) : {}, __copyProps$129(isNodeMode || !mod || !mod.__esModule ? __defProp$129(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$129 = (mod) => __copyProps$129(__defProp$129({}, "__esModule", { value: true }), mod);
	var stdin_exports$128 = {};
	__export$129(stdin_exports$128, {
		ContactList: () => ContactList,
		contactListProps: () => import_ContactList2.contactListProps,
		default: () => stdin_default$119
	});
	module.exports = __toCommonJS$129(stdin_exports$128);
	var import_utils$122 = require_utils$9();
	var import_ContactList = __toESM$67(require_ContactList());
	var import_ContactList2 = require_ContactList();
	var ContactList = (0, import_utils$122.withInstall)(import_ContactList.default);
	var stdin_default$119 = ContactList;
}) });

//#endregion
//#region node_modules/vant/lib/count-down/utils.js
var require_utils$2 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/count-down/utils.js": ((exports, module) => {
	var __defProp$128 = Object.defineProperty;
	var __getOwnPropDesc$128 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$128 = Object.getOwnPropertyNames;
	var __hasOwnProp$128 = Object.prototype.hasOwnProperty;
	var __export$128 = (target, all) => {
		for (var name$111 in all) __defProp$128(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$128 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$128(from)) if (!__hasOwnProp$128.call(to, key) && key !== except) __defProp$128(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$128(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$128 = (mod) => __copyProps$128(__defProp$128({}, "__esModule", { value: true }), mod);
	var stdin_exports$127 = {};
	__export$128(stdin_exports$127, { parseFormat: () => parseFormat });
	module.exports = __toCommonJS$128(stdin_exports$127);
	var import_utils$121 = require_utils$9();
	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", (0, import_utils$121.padZero)(days));
		else hours += days * 24;
		if (format$2.includes("HH")) format$2 = format$2.replace("HH", (0, import_utils$121.padZero)(hours));
		else minutes += hours * 60;
		if (format$2.includes("mm")) format$2 = format$2.replace("mm", (0, import_utils$121.padZero)(minutes));
		else seconds += minutes * 60;
		if (format$2.includes("ss")) format$2 = format$2.replace("ss", (0, import_utils$121.padZero)(seconds));
		else milliseconds += seconds * 1e3;
		if (format$2.includes("S")) {
			const ms = (0, import_utils$121.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/lib/count-down/CountDown.js
var require_CountDown = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/count-down/CountDown.js": ((exports, module) => {
	var __defProp$127 = Object.defineProperty;
	var __getOwnPropDesc$127 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$127 = Object.getOwnPropertyNames;
	var __hasOwnProp$127 = Object.prototype.hasOwnProperty;
	var __export$127 = (target, all) => {
		for (var name2 in all) __defProp$127(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$127 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$127(from)) if (!__hasOwnProp$127.call(to, key) && key !== except) __defProp$127(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$127(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$127 = (mod) => __copyProps$127(__defProp$127({}, "__esModule", { value: true }), mod);
	var stdin_exports$126 = {};
	__export$127(stdin_exports$126, {
		countDownProps: () => countDownProps,
		default: () => stdin_default$118
	});
	module.exports = __toCommonJS$127(stdin_exports$126);
	var import_vue$63 = require_vue();
	var import_utils$120 = require_utils$9();
	var import_utils2$5 = require_utils$2();
	var import_use$33 = require_index_cjs$1();
	var import_use_expose$16 = require_use_expose();
	var [name$55, bem$54] = (0, import_utils$120.createNamespace)("count-down");
	var countDownProps = {
		time: (0, import_utils$120.makeNumericProp)(0),
		format: (0, import_utils$120.makeStringProp)("HH:mm:ss"),
		autoStart: import_utils$120.truthProp,
		millisecond: Boolean
	};
	var stdin_default$118 = (0, import_vue$63.defineComponent)({
		name: name$55,
		props: countDownProps,
		emits: ["change", "finish"],
		setup(props$1, { emit, slots }) {
			const { start: start$1, pause, reset: reset$1, current: current$1 } = (0, import_use$33.useCountDown)({
				time: +props$1.time,
				millisecond: props$1.millisecond,
				onChange: (current2) => emit("change", current2),
				onFinish: () => emit("finish")
			});
			const timeText = (0, import_vue$63.computed)(() => (0, import_utils2$5.parseFormat)(props$1.format, current$1.value));
			const resetTime = () => {
				reset$1(+props$1.time);
				if (props$1.autoStart) start$1();
			};
			(0, import_vue$63.watch)(() => props$1.time, resetTime, { immediate: true });
			(0, import_use_expose$16.useExpose)({
				start: start$1,
				pause,
				reset: resetTime
			});
			return () => (0, import_vue$63.createVNode)("div", {
				"role": "timer",
				"class": bem$54()
			}, [slots.default ? slots.default(current$1.value) : timeText.value]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/count-down/index.js
var require_count_down = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/count-down/index.js": ((exports, module) => {
	var __create$66 = Object.create;
	var __defProp$126 = Object.defineProperty;
	var __getOwnPropDesc$126 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$126 = Object.getOwnPropertyNames;
	var __getProtoOf$66 = Object.getPrototypeOf;
	var __hasOwnProp$126 = Object.prototype.hasOwnProperty;
	var __export$126 = (target, all) => {
		for (var name$111 in all) __defProp$126(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$126 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$126(from)) if (!__hasOwnProp$126.call(to, key) && key !== except) __defProp$126(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$126(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$66 = (mod, isNodeMode, target) => (target = mod != null ? __create$66(__getProtoOf$66(mod)) : {}, __copyProps$126(isNodeMode || !mod || !mod.__esModule ? __defProp$126(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$126 = (mod) => __copyProps$126(__defProp$126({}, "__esModule", { value: true }), mod);
	var stdin_exports$125 = {};
	__export$126(stdin_exports$125, {
		CountDown: () => CountDown,
		countDownProps: () => import_CountDown2.countDownProps,
		default: () => stdin_default$117
	});
	module.exports = __toCommonJS$126(stdin_exports$125);
	var import_utils$119 = require_utils$9();
	var import_CountDown = __toESM$66(require_CountDown());
	var import_CountDown2 = require_CountDown();
	var CountDown = (0, import_utils$119.withInstall)(import_CountDown.default);
	var stdin_default$117 = CountDown;
}) });

//#endregion
//#region node_modules/vant/lib/coupon/utils.js
var require_utils$1 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/coupon/utils.js": ((exports, module) => {
	var __defProp$125 = Object.defineProperty;
	var __getOwnPropDesc$125 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$125 = Object.getOwnPropertyNames;
	var __hasOwnProp$125 = Object.prototype.hasOwnProperty;
	var __export$125 = (target, all) => {
		for (var name$111 in all) __defProp$125(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$125 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$125(from)) if (!__hasOwnProp$125.call(to, key) && key !== except) __defProp$125(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$125(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$125 = (mod) => __copyProps$125(__defProp$125({}, "__esModule", { value: true }), mod);
	var stdin_exports$124 = {};
	__export$125(stdin_exports$124, {
		formatAmount: () => formatAmount,
		formatDiscount: () => formatDiscount,
		getDate: () => getDate
	});
	module.exports = __toCommonJS$125(stdin_exports$124);
	var import_utils$118 = require_utils$9();
	function getDate(timeStamp) {
		const date = /* @__PURE__ */ new Date(timeStamp * 1e3);
		return `${date.getFullYear()}.${(0, import_utils$118.padZero)(date.getMonth() + 1)}.${(0, import_utils$118.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/lib/coupon/Coupon.js
var require_Coupon = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/coupon/Coupon.js": ((exports, module) => {
	var __defProp$124 = Object.defineProperty;
	var __getOwnPropDesc$124 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$124 = Object.getOwnPropertyNames;
	var __hasOwnProp$124 = Object.prototype.hasOwnProperty;
	var __export$124 = (target, all) => {
		for (var name2 in all) __defProp$124(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$124 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$124(from)) if (!__hasOwnProp$124.call(to, key) && key !== except) __defProp$124(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$124(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$124 = (mod) => __copyProps$124(__defProp$124({}, "__esModule", { value: true }), mod);
	var stdin_exports$123 = {};
	__export$124(stdin_exports$123, { default: () => stdin_default$116 });
	module.exports = __toCommonJS$124(stdin_exports$123);
	var import_vue$62 = require_vue();
	var import_utils$117 = require_utils$9();
	var import_utils2$4 = require_utils$1();
	var import_checkbox$1 = require_checkbox();
	var [name$54, bem$53, t$11] = (0, import_utils$117.createNamespace)("coupon");
	var stdin_default$116 = (0, import_vue$62.defineComponent)({
		name: name$54,
		props: {
			chosen: Boolean,
			coupon: (0, import_utils$117.makeRequiredProp)(Object),
			disabled: Boolean,
			currency: (0, import_utils$117.makeStringProp)("¥")
		},
		setup(props$1) {
			const validPeriod = (0, import_vue$62.computed)(() => {
				const { startAt, endAt } = props$1.coupon;
				return `${(0, import_utils2$4.getDate)(startAt)} - ${(0, import_utils2$4.getDate)(endAt)}`;
			});
			const faceAmount = (0, import_vue$62.computed)(() => {
				const { coupon, currency } = props$1;
				if (coupon.valueDesc) return [coupon.valueDesc, (0, import_vue$62.createVNode)("span", null, [coupon.unitDesc || ""])];
				if (coupon.denominations) {
					const denominations = (0, import_utils2$4.formatAmount)(coupon.denominations);
					return [(0, import_vue$62.createVNode)("span", null, [currency]), ` ${denominations}`];
				}
				if (coupon.discount) return t$11("discount", (0, import_utils2$4.formatDiscount)(coupon.discount));
				return "";
			});
			const conditionMessage = (0, import_vue$62.computed)(() => {
				const condition = (0, import_utils2$4.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 (0, import_vue$62.createVNode)("div", { "class": bem$53({ disabled }) }, [(0, import_vue$62.createVNode)("div", { "class": bem$53("content") }, [(0, import_vue$62.createVNode)("div", { "class": bem$53("head") }, [(0, import_vue$62.createVNode)("h2", { "class": bem$53("amount") }, [faceAmount.value]), (0, import_vue$62.createVNode)("p", { "class": bem$53("condition") }, [coupon.condition || conditionMessage.value])]), (0, import_vue$62.createVNode)("div", { "class": bem$53("body") }, [
					(0, import_vue$62.createVNode)("p", { "class": bem$53("name") }, [coupon.name]),
					(0, import_vue$62.createVNode)("p", { "class": bem$53("valid") }, [validPeriod.value]),
					!disabled && (0, import_vue$62.createVNode)(import_checkbox$1.Checkbox, {
						"class": bem$53("corner"),
						"modelValue": chosen
					}, null)
				])]), description && (0, import_vue$62.createVNode)("p", { "class": bem$53("description") }, [description])]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/coupon/index.js
var require_coupon = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/coupon/index.js": ((exports, module) => {
	var __create$65 = Object.create;
	var __defProp$123 = Object.defineProperty;
	var __getOwnPropDesc$123 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$123 = Object.getOwnPropertyNames;
	var __getProtoOf$65 = Object.getPrototypeOf;
	var __hasOwnProp$123 = Object.prototype.hasOwnProperty;
	var __export$123 = (target, all) => {
		for (var name$111 in all) __defProp$123(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$123 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$123(from)) if (!__hasOwnProp$123.call(to, key) && key !== except) __defProp$123(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$123(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$65 = (mod, isNodeMode, target) => (target = mod != null ? __create$65(__getProtoOf$65(mod)) : {}, __copyProps$123(isNodeMode || !mod || !mod.__esModule ? __defProp$123(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$123 = (mod) => __copyProps$123(__defProp$123({}, "__esModule", { value: true }), mod);
	var stdin_exports$122 = {};
	__export$123(stdin_exports$122, {
		Coupon: () => Coupon,
		default: () => stdin_default$115
	});
	module.exports = __toCommonJS$123(stdin_exports$122);
	var import_utils$116 = require_utils$9();
	var import_Coupon = __toESM$65(require_Coupon());
	var Coupon = (0, import_utils$116.withInstall)(import_Coupon.default);
	var stdin_default$115 = Coupon;
}) });

//#endregion
//#region node_modules/vant/lib/coupon-cell/CouponCell.js
var require_CouponCell = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/coupon-cell/CouponCell.js": ((exports, module) => {
	var __defProp$122 = Object.defineProperty;
	var __getOwnPropDesc$122 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$122 = Object.getOwnPropertyNames;
	var __hasOwnProp$122 = Object.prototype.hasOwnProperty;
	var __export$122 = (target, all) => {
		for (var name2 in all) __defProp$122(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$122 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$122(from)) if (!__hasOwnProp$122.call(to, key) && key !== except) __defProp$122(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$122(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$122 = (mod) => __copyProps$122(__defProp$122({}, "__esModule", { value: true }), mod);
	var stdin_exports$121 = {};
	__export$122(stdin_exports$121, {
		couponCellProps: () => couponCellProps,
		default: () => stdin_default$114
	});
	module.exports = __toCommonJS$122(stdin_exports$121);
	var import_vue$61 = require_vue();
	var import_utils$115 = require_utils$9();
	var import_cell$2 = require_cell();
	var [name$53, bem$52, t$10] = (0, import_utils$115.createNamespace)("coupon-cell");
	var couponCellProps = {
		title: String,
		border: import_utils$115.truthProp,
		editable: import_utils$115.truthProp,
		coupons: (0, import_utils$115.makeArrayProp)(),
		currency: (0, import_utils$115.makeStringProp)("¥"),
		chosenCoupon: {
			type: [Number, Array],
			default: -1
		}
	};
	var getValue = (coupon) => {
		const { value, denominations } = coupon;
		if ((0, import_utils$115.isDef)(value)) return value;
		if ((0, import_utils$115.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$114 = (0, import_vue$61.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 (0, import_vue$61.createVNode)(import_cell$2.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/lib/coupon-cell/index.js
var require_coupon_cell = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/coupon-cell/index.js": ((exports, module) => {
	var __create$64 = Object.create;
	var __defProp$121 = Object.defineProperty;
	var __getOwnPropDesc$121 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$121 = Object.getOwnPropertyNames;
	var __getProtoOf$64 = Object.getPrototypeOf;
	var __hasOwnProp$121 = Object.prototype.hasOwnProperty;
	var __export$121 = (target, all) => {
		for (var name$111 in all) __defProp$121(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$121 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$121(from)) if (!__hasOwnProp$121.call(to, key) && key !== except) __defProp$121(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$121(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$64 = (mod, isNodeMode, target) => (target = mod != null ? __create$64(__getProtoOf$64(mod)) : {}, __copyProps$121(isNodeMode || !mod || !mod.__esModule ? __defProp$121(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$121 = (mod) => __copyProps$121(__defProp$121({}, "__esModule", { value: true }), mod);
	var stdin_exports$120 = {};
	__export$121(stdin_exports$120, {
		CouponCell: () => CouponCell,
		couponCellProps: () => import_CouponCell2.couponCellProps,
		default: () => stdin_default$113
	});
	module.exports = __toCommonJS$121(stdin_exports$120);
	var import_utils$114 = require_utils$9();
	var import_CouponCell = __toESM$64(require_CouponCell());
	var import_CouponCell2 = require_CouponCell();
	var CouponCell = (0, import_utils$114.withInstall)(import_CouponCell.default);
	var stdin_default$113 = CouponCell;
}) });

//#endregion
//#region node_modules/vant/lib/empty/Empty.js
var require_Empty = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/empty/Empty.js": ((exports, module) => {
	var __defProp$120 = Object.defineProperty;
	var __getOwnPropDesc$120 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$120 = Object.getOwnPropertyNames;
	var __hasOwnProp$120 = Object.prototype.hasOwnProperty;
	var __export$120 = (target, all) => {
		for (var name2 in all) __defProp$120(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$120 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$120(from)) if (!__hasOwnProp$120.call(to, key) && key !== except) __defProp$120(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$120(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$120 = (mod) => __copyProps$120(__defProp$120({}, "__esModule", { value: true }), mod);
	var stdin_exports$119 = {};
	__export$120(stdin_exports$119, {
		default: () => stdin_default$112,
		emptyProps: () => emptyProps
	});
	module.exports = __toCommonJS$120(stdin_exports$119);
	var import_vue$60 = require_vue();
	var import_use_id$2 = require_use_id();
	var import_utils$113 = require_utils$9();
	var [name$52, bem$51] = (0, import_utils$113.createNamespace)("empty");
	var emptyProps = {
		image: (0, import_utils$113.makeStringProp)("default"),
		imageSize: [
			Number,
			String,
			Array
		],
		description: String
	};
	var stdin_default$112 = (0, import_vue$60.defineComponent)({
		name: name$52,
		props: emptyProps,
		setup(props$1, { slots }) {
			const renderDescription = () => {
				const description = slots.description ? slots.description() : props$1.description;
				if (description) return (0, import_vue$60.createVNode)("p", { "class": bem$51("description") }, [description]);
			};
			const renderBottom = () => {
				if (slots.default) return (0, import_vue$60.createVNode)("div", { "class": bem$51("bottom") }, [slots.default()]);
			};
			const baseId = (0, import_use_id$2.useId)();
			const getId = (num) => `${baseId}-${num}`;
			const getUrlById = (num) => `url(#${getId(num)})`;
			const renderStop = (color, offset$1, opacity) => (0, import_vue$60.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) => [(0, import_vue$60.createVNode)("defs", null, [(0, import_vue$60.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)])]), (0, import_vue$60.createVNode)("ellipse", {
				"fill": getUrlById(id),
				"opacity": ".8",
				"cx": "80",
				"cy": "140",
				"rx": "46",
				"ry": "8",
				"data-allow-mismatch": "attribute"
			}, null)];
			const renderBuilding = () => [(0, import_vue$60.createVNode)("defs", null, [(0, import_vue$60.createVNode)("linearGradient", {
				"id": getId("a"),
				"x1": "64%",
				"y1": "100%",
				"x2": "64%",
				"data-allow-mismatch": "attribute"
			}, [renderStop("#FFF", 0, .5), renderStop("#F2F3F5", 100)])]), (0, import_vue$60.createVNode)("g", {
				"opacity": ".8",
				"data-allow-mismatch": "children"
			}, [(0, import_vue$60.createVNode)("path", {
				"d": "M36 131V53H16v20H2v58h34z",
				"fill": getUrlById("a")
			}, null), (0, import_vue$60.createVNode)("path", {
				"d": "M123 15h22v14h9v77h-31V15z",
				"fill": getUrlById("a")
			}, null)])];
			const renderCloud = () => [(0, import_vue$60.createVNode)("defs", null, [(0, import_vue$60.createVNode)("linearGradient", {
				"id": getId("b"),
				"x1": "64%",
				"y1": "97%",
				"x2": "64%",
				"y2": "0%",
				"data-allow-mismatch": "attribute"
			}, [renderStop("#F2F3F5", 0, .3), renderStop("#F2F3F5", 100)])]), (0, import_vue$60.createVNode)("g", {
				"opacity": ".8",
				"data-allow-mismatch": "children"
			}, [(0, import_vue$60.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), (0, import_vue$60.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 = () => (0, import_vue$60.createVNode)("svg", { "viewBox": "0 0 160 160" }, [(0, import_vue$60.createVNode)("defs", { "data-allow-mismatch": "children" }, [
				(0, import_vue$60.createVNode)("linearGradient", {
					"id": getId(1),
					"x1": "64%",
					"y1": "100%",
					"x2": "64%"
				}, [renderStop("#FFF", 0, .5), renderStop("#F2F3F5", 100)]),
				(0, import_vue$60.createVNode)("linearGradient", {
					"id": getId(2),
					"x1": "50%",
					"x2": "50%",
					"y2": "84%"
				}, [renderStop("#EBEDF0", 0), renderStop("#DCDEE0", 100, 0)]),
				(0, import_vue$60.createVNode)("linearGradient", {
					"id": getId(3),
					"x1": "100%",
					"x2": "100%",
					"y2": "100%"
				}, [renderStops("#EAEDF0", "#DCDEE0")]),
				(0, import_vue$60.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)])
			]), (0, import_vue$60.createVNode)("g", { "fill": "none" }, [
				renderBuilding(),
				(0, import_vue$60.createVNode)("path", {
					"fill": getUrlById(4),
					"d": "M0 139h160v21H0z",
					"data-allow-mismatch": "attribute"
				}, null),
				(0, import_vue$60.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),
				(0, import_vue$60.createVNode)("g", {
					"opacity": ".6",
					"stroke-linecap": "round",
					"stroke-width": "7",
					"data-allow-mismatch": "children"
				}, [
					(0, import_vue$60.createVNode)("path", {
						"d": "M64 47a19 19 0 0 0-5 13c0 5 2 10 5 13",
						"stroke": getUrlById(3)
					}, null),
					(0, import_vue$60.createVNode)("path", {
						"d": "M53 36a34 34 0 0 0 0 48",
						"stroke": getUrlById(3)
					}, null),
					(0, import_vue$60.createVNode)("path", {
						"d": "M95 73a19 19 0 0 0 6-13c0-5-2-9-6-13",
						"stroke": getUrlById(3)
					}, null),
					(0, import_vue$60.createVNode)("path", {
						"d": "M106 84a34 34 0 0 0 0-48",
						"stroke": getUrlById(3)
					}, null)
				]),
				(0, import_vue$60.createVNode)("g", { "transform": "translate(31 105)" }, [
					(0, import_vue$60.createVNode)("rect", {
						"fill": "#EBEDF0",
						"width": "98",
						"height": "34",
						"rx": "2"
					}, null),
					(0, import_vue$60.createVNode)("rect", {
						"fill": "#FFF",
						"x": "9",
						"y": "8",
						"width": "80",
						"height": "18",
						"rx": "1.1"
					}, null),
					(0, import_vue$60.createVNode)("rect", {
						"fill": "#EBEDF0",
						"x": "15",
						"y": "12",
						"width": "18",
						"height": "6",
						"rx": "1.1"
					}, null)
				])
			])]);
			const renderMaterial = () => (0, import_vue$60.createVNode)("svg", { "viewBox": "0 0 160 160" }, [
				(0, import_vue$60.createVNode)("defs", { "data-allow-mismatch": "children" }, [
					(0, import_vue$60.createVNode)("linearGradient", {
						"x1": "50%",
						"x2": "50%",
						"y2": "100%",
						"id": getId(5)
					}, [renderStops("#F2F3F5", "#DCDEE0")]),
					(0, import_vue$60.createVNode)("linearGradient", {
						"x1": "95%",
						"y1": "48%",
						"x2": "5.5%",
						"y2": "51%",
						"id": getId(6)
					}, [renderStops("#EAEDF1", "#DCDEE0")]),
					(0, import_vue$60.createVNode)("linearGradient", {
						"y1": "45%",
						"x2": "100%",
						"y2": "54%",
						"id": getId(7)
					}, [renderStops("#EAEDF1", "#DCDEE0")])
				]),
				renderBuilding(),
				renderCloud(),
				(0, import_vue$60.createVNode)("g", {
					"transform": "translate(36 50)",
					"fill": "none"
				}, [
					(0, import_vue$60.createVNode)("g", { "transform": "translate(8)" }, [
						(0, import_vue$60.createVNode)("rect", {
							"fill": "#EBEDF0",
							"opacity": ".6",
							"x": "38",
							"y": "13",
							"width": "36",
							"height": "53",
							"rx": "2"
						}, null),
						(0, import_vue$60.createVNode)("rect", {
							"fill": getUrlById(5),
							"width": "64",
							"height": "66",
							"rx": "2",
							"data-allow-mismatch": "attribute"
						}, null),
						(0, import_vue$60.createVNode)("rect", {
							"fill": "#FFF",
							"x": "6",
							"y": "6",
							"width": "52",
							"height": "55",
							"rx": "1"
						}, null),
						(0, import_vue$60.createVNode)("g", {
							"transform": "translate(15 17)",
							"fill": getUrlById(6),
							"data-allow-mismatch": "attribute"
						}, [
							(0, import_vue$60.createVNode)("rect", {
								"width": "34",
								"height": "6",
								"rx": "1"
							}, null),
							(0, import_vue$60.createVNode)("path", { "d": "M0 14h34v6H0z" }, null),
							(0, import_vue$60.createVNode)("rect", {
								"y": "28",
								"width": "34",
								"height": "6",
								"rx": "1"
							}, null)
						])
					]),
					(0, import_vue$60.createVNode)("rect", {
						"fill": getUrlById(7),
						"y": "61",
						"width": "88",
						"height": "28",
						"rx": "1",
						"data-allow-mismatch": "attribute"
					}, null),
					(0, import_vue$60.createVNode)("rect", {
						"fill": "#F7F8FA",
						"x": "29",
						"y": "72",
						"width": "30",
						"height": "6",
						"rx": "1"
					}, null)
				])
			]);
			const renderError = () => (0, import_vue$60.createVNode)("svg", { "viewBox": "0 0 160 160" }, [
				(0, import_vue$60.createVNode)("defs", null, [(0, import_vue$60.createVNode)("linearGradient", {
					"x1": "50%",
					"x2": "50%",
					"y2": "100%",
					"id": getId(8),
					"data-allow-mismatch": "attribute"
				}, [renderStops("#EAEDF1", "#DCDEE0")])]),
				renderBuilding(),
				renderCloud(),
				renderShadow("c"),
				(0, import_vue$60.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 = () => (0, import_vue$60.createVNode)("svg", { "viewBox": "0 0 160 160" }, [
				(0, import_vue$60.createVNode)("defs", { "data-allow-mismatch": "children" }, [
					(0, import_vue$60.createVNode)("linearGradient", {
						"x1": "50%",
						"y1": "100%",
						"x2": "50%",
						"id": getId(9)
					}, [renderStops("#EEE", "#D8D8D8")]),
					(0, import_vue$60.createVNode)("linearGradient", {
						"x1": "100%",
						"y1": "50%",
						"y2": "50%",
						"id": getId(10)
					}, [renderStops("#F2F3F5", "#DCDEE0")]),
					(0, import_vue$60.createVNode)("linearGradient", {
						"x1": "50%",
						"x2": "50%",
						"y2": "100%",
						"id": getId(11)
					}, [renderStops("#F2F3F5", "#DCDEE0")]),
					(0, import_vue$60.createVNode)("linearGradient", {
						"x1": "50%",
						"x2": "50%",
						"y2": "100%",
						"id": getId(12)
					}, [renderStops("#FFF", "#F7F8FA")])
				]),
				renderBuilding(),
				renderCloud(),
				renderShadow("d"),
				(0, import_vue$60.createVNode)("g", {
					"transform": "rotate(-45 113 -4)",
					"fill": "none",
					"data-allow-mismatch": "children"
				}, [
					(0, import_vue$60.createVNode)("rect", {
						"fill": getUrlById(9),
						"x": "24",
						"y": "52.8",
						"width": "5.8",
						"height": "19",
						"rx": "1"
					}, null),
					(0, import_vue$60.createVNode)("rect", {
						"fill": getUrlById(10),
						"x": "22.1",
						"y": "67.3",
						"width": "9.9",
						"height": "28",
						"rx": "1"
					}, null),
					(0, import_vue$60.createVNode)("circle", {
						"stroke": getUrlById(11),
						"stroke-width": "8",
						"cx": "27",
						"cy": "27",
						"r": "27"
					}, null),
					(0, import_vue$60.createVNode)("circle", {
						"fill": getUrlById(12),
						"cx": "27",
						"cy": "27",
						"r": "16"
					}, null),
					(0, import_vue$60.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)) || (0, import_vue$60.createVNode)("img", { "src": props$1.image }, null);
			};
			return () => (0, import_vue$60.createVNode)("div", { "class": bem$51() }, [
				(0, import_vue$60.createVNode)("div", {
					"class": bem$51("image"),
					"style": (0, import_utils$113.getSizeStyle)(props$1.imageSize)
				}, [renderImage()]),
				renderDescription(),
				renderBottom()
			]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/empty/index.js
var require_empty = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/empty/index.js": ((exports, module) => {
	var __create$63 = Object.create;
	var __defProp$119 = Object.defineProperty;
	var __getOwnPropDesc$119 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$119 = Object.getOwnPropertyNames;
	var __getProtoOf$63 = Object.getPrototypeOf;
	var __hasOwnProp$119 = Object.prototype.hasOwnProperty;
	var __export$119 = (target, all) => {
		for (var name$111 in all) __defProp$119(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$119 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$119(from)) if (!__hasOwnProp$119.call(to, key) && key !== except) __defProp$119(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$119(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$63 = (mod, isNodeMode, target) => (target = mod != null ? __create$63(__getProtoOf$63(mod)) : {}, __copyProps$119(isNodeMode || !mod || !mod.__esModule ? __defProp$119(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$119 = (mod) => __copyProps$119(__defProp$119({}, "__esModule", { value: true }), mod);
	var stdin_exports$118 = {};
	__export$119(stdin_exports$118, {
		Empty: () => Empty,
		default: () => stdin_default$111,
		emptyProps: () => import_Empty2.emptyProps
	});
	module.exports = __toCommonJS$119(stdin_exports$118);
	var import_utils$112 = require_utils$9();
	var import_Empty = __toESM$63(require_Empty());
	var import_Empty2 = require_Empty();
	var Empty = (0, import_utils$112.withInstall)(import_Empty.default);
	var stdin_default$111 = Empty;
}) });

//#endregion
//#region node_modules/vant/lib/coupon-list/CouponList.js
var require_CouponList = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/coupon-list/CouponList.js": ((exports, module) => {
	var __defProp$118 = Object.defineProperty;
	var __getOwnPropDesc$118 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$118 = Object.getOwnPropertyNames;
	var __hasOwnProp$118 = Object.prototype.hasOwnProperty;
	var __export$118 = (target, all) => {
		for (var name2 in all) __defProp$118(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$118 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$118(from)) if (!__hasOwnProp$118.call(to, key) && key !== except) __defProp$118(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$118(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$118 = (mod) => __copyProps$118(__defProp$118({}, "__esModule", { value: true }), mod);
	var stdin_exports$117 = {};
	__export$118(stdin_exports$117, {
		couponListProps: () => couponListProps,
		default: () => stdin_default$110
	});
	module.exports = __toCommonJS$118(stdin_exports$117);
	var import_vue$59 = require_vue();
	var import_utils$111 = require_utils$9();
	var import_use_refs$1 = require_use_refs();
	var import_tab$1 = require_tab();
	var import_tabs$1 = require_tabs();
	var import_empty$1 = require_empty();
	var import_field$2 = require_field();
	var import_button$4 = require_button();
	var import_coupon$1 = require_coupon();
	var import_use$32 = require_index_cjs$1();
	var [name$51, bem$50, t$9] = (0, import_utils$111.createNamespace)("coupon-list");
	var couponListProps = {
		code: (0, import_utils$111.makeStringProp)(""),
		coupons: (0, import_utils$111.makeArrayProp)(),
		currency: (0, import_utils$111.makeStringProp)("¥"),
		showCount: import_utils$111.truthProp,
		emptyImage: String,
		enabledTitle: String,
		disabledTitle: String,
		disabledCoupons: (0, import_utils$111.makeArrayProp)(),
		showExchangeBar: import_utils$111.truthProp,
		showCloseButton: import_utils$111.truthProp,
		closeButtonText: String,
		inputPlaceholder: String,
		exchangeMinLength: (0, import_utils$111.makeNumberProp)(1),
		exchangeButtonText: String,
		displayedCouponIndex: (0, import_utils$111.makeNumberProp)(-1),
		exchangeButtonLoading: Boolean,
		exchangeButtonDisabled: Boolean,
		chosenCoupon: {
			type: [Number, Array],
			default: -1
		}
	};
	var stdin_default$110 = (0, import_vue$59.defineComponent)({
		name: name$51,
		props: couponListProps,
		emits: [
			"change",
			"exchange",
			"update:code"
		],
		setup(props$1, { emit, slots }) {
			const [couponRefs, setCouponRefs] = (0, import_use_refs$1.useRefs)();
			const root = (0, import_vue$59.ref)();
			const barRef = (0, import_vue$59.ref)();
			const activeTab = (0, import_vue$59.ref)(0);
			const listHeight = (0, import_vue$59.ref)(0);
			const currentCode = (0, import_vue$59.ref)(props$1.code);
			const buttonDisabled = (0, import_vue$59.computed)(() => !props$1.exchangeButtonLoading && (props$1.exchangeButtonDisabled || !currentCode.value || currentCode.value.length < props$1.exchangeMinLength));
			const updateListHeight = () => {
				const TABS_HEIGHT = 44;
				const rootHeight = (0, import_use$32.useRect)(root).height;
				const headerHeight = (0, import_use$32.useRect)(barRef).height + TABS_HEIGHT;
				listHeight.value = (rootHeight > headerHeight ? rootHeight : import_utils$111.windowHeight.value) - headerHeight;
			};
			const onExchange = () => {
				emit("exchange", currentCode.value);
				if (!props$1.code) currentCode.value = "";
			};
			const scrollToCoupon = (index) => {
				(0, import_vue$59.nextTick)(() => {
					var _a;
					return (_a = couponRefs.value[index]) == null ? void 0 : _a.scrollIntoView();
				});
			};
			const renderEmpty = () => (0, import_vue$59.createVNode)(import_empty$1.Empty, { "image": props$1.emptyImage }, { default: () => [(0, import_vue$59.createVNode)("p", { "class": bem$50("empty-tip") }, [t$9("noCoupon")])] });
			const renderExchangeBar = () => {
				if (props$1.showExchangeBar) return (0, import_vue$59.createVNode)("div", {
					"ref": barRef,
					"class": bem$50("exchange-bar")
				}, [(0, import_vue$59.createVNode)(import_field$2.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), (0, import_vue$59.createVNode)(import_button$4.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 (0, import_vue$59.createVNode)(import_tab$1.Tab, { "title": title }, { default: () => {
					var _a;
					return [(0, import_vue$59.createVNode)("div", {
						"class": bem$50("list", { "with-bottom": props$1.showCloseButton }),
						"style": { height: `${listHeight.value}px` }
					}, [
						coupons.map((coupon, index) => (0, import_vue$59.createVNode)(import_coupon$1.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 (0, import_vue$59.createVNode)(import_tab$1.Tab, { "title": title }, { default: () => {
					var _a;
					return [(0, import_vue$59.createVNode)("div", {
						"class": bem$50("list", { "with-bottom": props$1.showCloseButton }),
						"style": { height: `${listHeight.value}px` }
					}, [
						disabledCoupons.map((coupon) => (0, import_vue$59.createVNode)(import_coupon$1.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)
					])];
				} });
			};
			(0, import_vue$59.watch)(() => props$1.code, (value) => {
				currentCode.value = value;
			});
			(0, import_vue$59.watch)(import_utils$111.windowHeight, updateListHeight);
			(0, import_vue$59.watch)(currentCode, (value) => emit("update:code", value));
			(0, import_vue$59.watch)(() => props$1.displayedCouponIndex, scrollToCoupon);
			(0, import_vue$59.onMounted)(() => {
				updateListHeight();
				scrollToCoupon(props$1.displayedCouponIndex);
			});
			return () => (0, import_vue$59.createVNode)("div", {
				"ref": root,
				"class": bem$50()
			}, [
				renderExchangeBar(),
				(0, import_vue$59.createVNode)(import_tabs$1.Tabs, {
					"active": activeTab.value,
					"onUpdate:active": ($event) => activeTab.value = $event,
					"class": bem$50("tab")
				}, { default: () => [renderCouponTab(), renderDisabledTab()] }),
				(0, import_vue$59.createVNode)("div", { "class": bem$50("bottom") }, [slots["list-button"] ? slots["list-button"]() : (0, import_vue$59.withDirectives)((0, import_vue$59.createVNode)(import_button$4.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), [[import_vue$59.vShow, props$1.showCloseButton]])])
			]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/coupon-list/index.js
var require_coupon_list = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/coupon-list/index.js": ((exports, module) => {
	var __create$62 = Object.create;
	var __defProp$117 = Object.defineProperty;
	var __getOwnPropDesc$117 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$117 = Object.getOwnPropertyNames;
	var __getProtoOf$62 = Object.getPrototypeOf;
	var __hasOwnProp$117 = Object.prototype.hasOwnProperty;
	var __export$117 = (target, all) => {
		for (var name$111 in all) __defProp$117(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$117 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$117(from)) if (!__hasOwnProp$117.call(to, key) && key !== except) __defProp$117(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$117(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$62 = (mod, isNodeMode, target) => (target = mod != null ? __create$62(__getProtoOf$62(mod)) : {}, __copyProps$117(isNodeMode || !mod || !mod.__esModule ? __defProp$117(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$117 = (mod) => __copyProps$117(__defProp$117({}, "__esModule", { value: true }), mod);
	var stdin_exports$116 = {};
	__export$117(stdin_exports$116, {
		CouponList: () => CouponList,
		couponListProps: () => import_CouponList2.couponListProps,
		default: () => stdin_default$109
	});
	module.exports = __toCommonJS$117(stdin_exports$116);
	var import_utils$110 = require_utils$9();
	var import_CouponList = __toESM$62(require_CouponList());
	var import_CouponList2 = require_CouponList();
	var CouponList = (0, import_utils$110.withInstall)(import_CouponList.default);
	var stdin_default$109 = CouponList;
}) });

//#endregion
//#region node_modules/vant/lib/date-picker/DatePicker.js
var require_DatePicker = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/date-picker/DatePicker.js": ((exports, module) => {
	var __defProp$116 = Object.defineProperty;
	var __getOwnPropDesc$116 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$116 = Object.getOwnPropertyNames;
	var __hasOwnProp$116 = Object.prototype.hasOwnProperty;
	var __export$116 = (target, all) => {
		for (var name2 in all) __defProp$116(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$116 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$116(from)) if (!__hasOwnProp$116.call(to, key) && key !== except) __defProp$116(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$116(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$116 = (mod) => __copyProps$116(__defProp$116({}, "__esModule", { value: true }), mod);
	var stdin_exports$115 = {};
	__export$116(stdin_exports$115, {
		datePickerProps: () => datePickerProps,
		default: () => stdin_default$108
	});
	module.exports = __toCommonJS$116(stdin_exports$115);
	var import_vue$58 = require_vue();
	var import_utils$109 = require_utils$9();
	var import_utils2$3 = require_utils$3();
	var import_use_expose$15 = require_use_expose();
	var import_picker$2 = require_picker();
	var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
	var [name$50] = (0, import_utils$109.createNamespace)("date-picker");
	var datePickerProps = (0, import_utils$109.extend)({}, import_utils2$3.sharedProps, {
		columnsType: {
			type: Array,
			default: () => [
				"year",
				"month",
				"day"
			]
		},
		minDate: {
			type: Date,
			default: () => new Date(currentYear - 10, 0, 1),
			validator: import_utils$109.isDate
		},
		maxDate: {
			type: Date,
			default: () => new Date(currentYear + 10, 11, 31),
			validator: import_utils$109.isDate
		}
	});
	var stdin_default$108 = (0, import_vue$58.defineComponent)({
		name: name$50,
		props: datePickerProps,
		emits: [
			"confirm",
			"cancel",
			"change",
			"update:modelValue"
		],
		setup(props$1, { emit, slots }) {
			const currentValues = (0, import_vue$58.ref)(props$1.modelValue);
			const updatedByExternalSources = (0, import_vue$58.ref)(false);
			const pickerRef = (0, import_vue$58.ref)();
			const computedValues = (0, import_vue$58.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 = () => {
				const minYear = props$1.minDate.getFullYear();
				const maxYear = props$1.maxDate.getFullYear();
				return (0, import_utils2$3.genOptions)(minYear, maxYear, "year", props$1.formatter, props$1.filter, computedValues.value);
			};
			const genMonthOptions = () => {
				const year = getValue$1("year");
				const minMonth = isMinYear(year) ? props$1.minDate.getMonth() + 1 : 1;
				const maxMonth = isMaxYear(year) ? props$1.maxDate.getMonth() + 1 : 12;
				return (0, import_utils2$3.genOptions)(minMonth, maxMonth, "month", props$1.formatter, props$1.filter, computedValues.value);
			};
			const genDayOptions = () => {
				const year = getValue$1("year");
				const month = getValue$1("month");
				const minDate = isMinYear(year) && isMinMonth(month) ? props$1.minDate.getDate() : 1;
				const maxDate = isMaxYear(year) && isMaxMonth(month) ? props$1.maxDate.getDate() : (0, import_utils2$3.getMonthEndDay)(year, month);
				return (0, import_utils2$3.genOptions)(minDate, maxDate, "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 = (0, import_vue$58.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}`);
				}
			}));
			(0, import_vue$58.watch)(currentValues, (newValues) => {
				if (!(0, import_utils$109.isSameValue)(newValues, props$1.modelValue)) emit("update:modelValue", newValues);
			});
			(0, import_vue$58.watch)(() => props$1.modelValue, (newValues, oldValues) => {
				updatedByExternalSources.value = (0, import_utils$109.isSameValue)(oldValues, currentValues.value);
				newValues = (0, import_utils2$3.formatValueRange)(newValues, columns.value);
				if (!(0, import_utils$109.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);
			(0, import_use_expose$15.useExpose)({
				confirm,
				getSelectedDate
			});
			return () => (0, import_vue$58.createVNode)(import_picker$2.Picker, (0, import_vue$58.mergeProps)({
				"ref": pickerRef,
				"modelValue": currentValues.value,
				"onUpdate:modelValue": ($event) => currentValues.value = $event,
				"columns": columns.value,
				"onChange": onChange,
				"onCancel": onCancel,
				"onConfirm": onConfirm
			}, (0, import_utils$109.pick)(props$1, import_utils2$3.pickerInheritKeys)), slots);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/date-picker/index.js
var require_date_picker = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/date-picker/index.js": ((exports, module) => {
	var __create$61 = Object.create;
	var __defProp$115 = Object.defineProperty;
	var __getOwnPropDesc$115 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$115 = Object.getOwnPropertyNames;
	var __getProtoOf$61 = Object.getPrototypeOf;
	var __hasOwnProp$115 = Object.prototype.hasOwnProperty;
	var __export$115 = (target, all) => {
		for (var name$111 in all) __defProp$115(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$115 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$115(from)) if (!__hasOwnProp$115.call(to, key) && key !== except) __defProp$115(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$115(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$61 = (mod, isNodeMode, target) => (target = mod != null ? __create$61(__getProtoOf$61(mod)) : {}, __copyProps$115(isNodeMode || !mod || !mod.__esModule ? __defProp$115(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$115 = (mod) => __copyProps$115(__defProp$115({}, "__esModule", { value: true }), mod);
	var stdin_exports$114 = {};
	__export$115(stdin_exports$114, {
		DatePicker: () => DatePicker,
		datePickerProps: () => import_DatePicker2.datePickerProps,
		default: () => stdin_default$107
	});
	module.exports = __toCommonJS$115(stdin_exports$114);
	var import_utils$108 = require_utils$9();
	var import_DatePicker = __toESM$61(require_DatePicker());
	var import_DatePicker2 = require_DatePicker();
	var DatePicker = (0, import_utils$108.withInstall)(import_DatePicker.default);
	var stdin_default$107 = DatePicker;
}) });

//#endregion
//#region node_modules/vant/lib/dialog/Dialog.js
var require_Dialog = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/dialog/Dialog.js": ((exports, module) => {
	var __defProp$114 = Object.defineProperty;
	var __getOwnPropDesc$114 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$114 = Object.getOwnPropertyNames;
	var __hasOwnProp$114 = Object.prototype.hasOwnProperty;
	var __export$114 = (target, all) => {
		for (var name2 in all) __defProp$114(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$114 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$114(from)) if (!__hasOwnProp$114.call(to, key) && key !== except) __defProp$114(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$114(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$114 = (mod) => __copyProps$114(__defProp$114({}, "__esModule", { value: true }), mod);
	var stdin_exports$113 = {};
	__export$114(stdin_exports$113, {
		default: () => stdin_default$106,
		dialogProps: () => dialogProps
	});
	module.exports = __toCommonJS$114(stdin_exports$113);
	var import_vue$57 = require_vue();
	var import_utils$107 = require_utils$9();
	var import_shared$2 = require_shared();
	var import_popup$6 = require_popup();
	var import_button$3 = require_button();
	var import_action_bar$1 = require_action_bar();
	var import_action_bar_button$1 = require_action_bar_button();
	var [name$49, bem$49, t$8] = (0, import_utils$107.createNamespace)("dialog");
	var dialogProps = (0, import_utils$107.extend)({}, import_shared$2.popupSharedProps, {
		title: String,
		theme: String,
		width: import_utils$107.numericProp,
		message: [String, Function],
		callback: Function,
		allowHtml: Boolean,
		className: import_utils$107.unknownProp,
		transition: (0, import_utils$107.makeStringProp)("van-dialog-bounce"),
		messageAlign: String,
		closeOnPopstate: import_utils$107.truthProp,
		showCancelButton: Boolean,
		cancelButtonText: String,
		cancelButtonColor: String,
		cancelButtonDisabled: Boolean,
		confirmButtonText: String,
		confirmButtonColor: String,
		confirmButtonDisabled: Boolean,
		showConfirmButton: import_utils$107.truthProp,
		closeOnClickOverlay: Boolean,
		keyboardEnabled: import_utils$107.truthProp,
		destroyOnClose: Boolean
	});
	var popupInheritKeys$1 = [
		...import_shared$2.popupSharedPropKeys,
		"transition",
		"closeOnPopstate",
		"destroyOnClose"
	];
	var stdin_default$106 = (0, import_vue$57.defineComponent)({
		name: name$49,
		props: dialogProps,
		emits: [
			"confirm",
			"cancel",
			"keydown",
			"update:show"
		],
		setup(props$1, { emit, slots }) {
			const root = (0, import_vue$57.ref)();
			const loading = (0, import_vue$57.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;
					(0, import_utils$107.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 = (0, import_vue$57.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 : import_utils$107.noop,
					Escape: props$1.showCancelButton ? onCancel : import_utils$107.noop
				})[event.key]();
				emit("keydown", event);
			}, ["enter", "esc"]);
			const renderTitle = () => {
				const title = slots.title ? slots.title() : props$1.title;
				if (title) return (0, import_vue$57.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 = (0, import_utils$107.isFunction)(message) ? message() : message;
				if (allowHtml && typeof content === "string") return (0, import_vue$57.createVNode)("div", {
					"class": classNames,
					"innerHTML": content
				}, null);
				return (0, import_vue$57.createVNode)("div", { "class": classNames }, [content]);
			};
			const renderContent = () => {
				if (slots.default) return (0, import_vue$57.createVNode)("div", { "class": bem$49("content") }, [slots.default()]);
				const { title, message, allowHtml } = props$1;
				if (message) {
					const hasTitle = !!(title || slots.title);
					return (0, import_vue$57.createVNode)("div", {
						"key": allowHtml ? 1 : 0,
						"class": bem$49("content", { isolated: !hasTitle })
					}, [renderMessage(hasTitle)]);
				}
			};
			const renderButtons = () => (0, import_vue$57.createVNode)("div", { "class": [import_utils$107.BORDER_TOP, bem$49("footer")] }, [props$1.showCancelButton && (0, import_vue$57.createVNode)(import_button$3.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 && (0, import_vue$57.createVNode)(import_button$3.Button, {
				"size": "large",
				"text": props$1.confirmButtonText || t$8("confirm"),
				"class": [bem$49("confirm"), { [import_utils$107.BORDER_LEFT]: props$1.showCancelButton }],
				"style": { color: props$1.confirmButtonColor },
				"loading": loading.confirm,
				"disabled": props$1.confirmButtonDisabled,
				"onClick": onConfirm
			}, null)]);
			const renderRoundButtons = () => (0, import_vue$57.createVNode)(import_action_bar$1.ActionBar, { "class": bem$49("footer") }, { default: () => [props$1.showCancelButton && (0, import_vue$57.createVNode)(import_action_bar_button$1.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 && (0, import_vue$57.createVNode)(import_action_bar_button$1.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 (0, import_vue$57.createVNode)(import_popup$6.Popup, (0, import_vue$57.mergeProps)({
					"ref": root,
					"role": "dialog",
					"class": [bem$49([theme]), className],
					"style": { width: (0, import_utils$107.addUnit)(width$1) },
					"tabindex": 0,
					"aria-labelledby": title || message,
					"onKeydown": onKeydown,
					"onUpdate:show": updateShow
				}, (0, import_utils$107.pick)(props$1, popupInheritKeys$1)), { default: () => [
					renderTitle(),
					renderContent(),
					renderFooter()
				] });
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/dialog/function-call.js
var require_function_call$2 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/dialog/function-call.js": ((exports, module) => {
	var __create$60 = Object.create;
	var __defProp$113 = Object.defineProperty;
	var __getOwnPropDesc$113 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$113 = Object.getOwnPropertyNames;
	var __getProtoOf$60 = Object.getPrototypeOf;
	var __hasOwnProp$113 = Object.prototype.hasOwnProperty;
	var __export$113 = (target, all) => {
		for (var name$111 in all) __defProp$113(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$113 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$113(from)) if (!__hasOwnProp$113.call(to, key) && key !== except) __defProp$113(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$113(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$60 = (mod, isNodeMode, target) => (target = mod != null ? __create$60(__getProtoOf$60(mod)) : {}, __copyProps$113(isNodeMode || !mod || !mod.__esModule ? __defProp$113(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$113 = (mod) => __copyProps$113(__defProp$113({}, "__esModule", { value: true }), mod);
	var stdin_exports$112 = {};
	__export$113(stdin_exports$112, {
		closeDialog: () => closeDialog,
		resetDialogDefaultOptions: () => resetDialogDefaultOptions,
		setDialogDefaultOptions: () => setDialogDefaultOptions,
		showConfirmDialog: () => showConfirmDialog,
		showDialog: () => showDialog
	});
	module.exports = __toCommonJS$113(stdin_exports$112);
	var import_vue$56 = require_vue();
	var import_utils$106 = require_utils$9();
	var import_mount_component$2 = require_mount_component();
	var import_Dialog$1 = __toESM$60(require_Dialog());
	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 = (0, import_utils$106.extend)({}, DEFAULT_OPTIONS$1);
	function initInstance$2() {
		const Wrapper = { setup() {
			const { state, toggle } = (0, import_mount_component$2.usePopupState)();
			return () => (0, import_vue$56.createVNode)(import_Dialog$1.default, (0, import_vue$56.mergeProps)(state, { "onUpdate:show": toggle }), null);
		} };
		({instance: instance$2} = (0, import_mount_component$2.mountComponent)(Wrapper));
	}
	function showDialog(options) {
		if (!import_utils$106.inBrowser) return Promise.resolve(void 0);
		return new Promise((resolve, reject) => {
			if (!instance$2) initInstance$2();
			instance$2.open((0, import_utils$106.extend)({}, currentOptions$1, options, { callback: (action) => {
				(action === "confirm" ? resolve : reject)(action);
			} }));
		});
	}
	var setDialogDefaultOptions = (options) => {
		(0, import_utils$106.extend)(currentOptions$1, options);
	};
	var resetDialogDefaultOptions = () => {
		currentOptions$1 = (0, import_utils$106.extend)({}, DEFAULT_OPTIONS$1);
	};
	var showConfirmDialog = (options) => showDialog((0, import_utils$106.extend)({ showCancelButton: true }, options));
	var closeDialog = () => {
		if (instance$2) instance$2.toggle(false);
	};
}) });

//#endregion
//#region node_modules/vant/lib/dialog/index.js
var require_dialog = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/dialog/index.js": ((exports, module) => {
	var __create$59 = Object.create;
	var __defProp$112 = Object.defineProperty;
	var __getOwnPropDesc$112 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$112 = Object.getOwnPropertyNames;
	var __getProtoOf$59 = Object.getPrototypeOf;
	var __hasOwnProp$112 = Object.prototype.hasOwnProperty;
	var __export$112 = (target, all) => {
		for (var name$111 in all) __defProp$112(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$112 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$112(from)) if (!__hasOwnProp$112.call(to, key) && key !== except) __defProp$112(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$112(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$59 = (mod, isNodeMode, target) => (target = mod != null ? __create$59(__getProtoOf$59(mod)) : {}, __copyProps$112(isNodeMode || !mod || !mod.__esModule ? __defProp$112(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$112 = (mod) => __copyProps$112(__defProp$112({}, "__esModule", { value: true }), mod);
	var stdin_exports$111 = {};
	__export$112(stdin_exports$111, {
		Dialog: () => Dialog,
		closeDialog: () => import_function_call$2.closeDialog,
		default: () => stdin_default$105,
		dialogProps: () => import_Dialog2.dialogProps,
		resetDialogDefaultOptions: () => import_function_call$2.resetDialogDefaultOptions,
		setDialogDefaultOptions: () => import_function_call$2.setDialogDefaultOptions,
		showConfirmDialog: () => import_function_call$2.showConfirmDialog,
		showDialog: () => import_function_call$2.showDialog
	});
	module.exports = __toCommonJS$112(stdin_exports$111);
	var import_utils$105 = require_utils$9();
	var import_Dialog = __toESM$59(require_Dialog());
	var import_Dialog2 = require_Dialog();
	var import_function_call$2 = require_function_call$2();
	var Dialog = (0, import_utils$105.withInstall)(import_Dialog.default);
	var stdin_default$105 = Dialog;
}) });

//#endregion
//#region node_modules/vant/lib/divider/Divider.js
var require_Divider = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/divider/Divider.js": ((exports, module) => {
	var __defProp$111 = Object.defineProperty;
	var __getOwnPropDesc$111 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$111 = Object.getOwnPropertyNames;
	var __hasOwnProp$111 = Object.prototype.hasOwnProperty;
	var __export$111 = (target, all) => {
		for (var name2 in all) __defProp$111(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$111 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$111(from)) if (!__hasOwnProp$111.call(to, key) && key !== except) __defProp$111(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$111(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$111 = (mod) => __copyProps$111(__defProp$111({}, "__esModule", { value: true }), mod);
	var stdin_exports$110 = {};
	__export$111(stdin_exports$110, {
		default: () => stdin_default$104,
		dividerProps: () => dividerProps
	});
	module.exports = __toCommonJS$111(stdin_exports$110);
	var import_vue$55 = require_vue();
	var import_utils$104 = require_utils$9();
	var [name$48, bem$48] = (0, import_utils$104.createNamespace)("divider");
	var dividerProps = {
		dashed: Boolean,
		hairline: import_utils$104.truthProp,
		vertical: Boolean,
		contentPosition: (0, import_utils$104.makeStringProp)("center")
	};
	var stdin_default$104 = (0, import_vue$55.defineComponent)({
		name: name$48,
		props: dividerProps,
		setup(props$1, { slots }) {
			return () => {
				var _a;
				return (0, import_vue$55.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/lib/divider/index.js
var require_divider = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/divider/index.js": ((exports, module) => {
	var __create$58 = Object.create;
	var __defProp$110 = Object.defineProperty;
	var __getOwnPropDesc$110 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$110 = Object.getOwnPropertyNames;
	var __getProtoOf$58 = Object.getPrototypeOf;
	var __hasOwnProp$110 = Object.prototype.hasOwnProperty;
	var __export$110 = (target, all) => {
		for (var name$111 in all) __defProp$110(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$110 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$110(from)) if (!__hasOwnProp$110.call(to, key) && key !== except) __defProp$110(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$110(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$58 = (mod, isNodeMode, target) => (target = mod != null ? __create$58(__getProtoOf$58(mod)) : {}, __copyProps$110(isNodeMode || !mod || !mod.__esModule ? __defProp$110(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$110 = (mod) => __copyProps$110(__defProp$110({}, "__esModule", { value: true }), mod);
	var stdin_exports$109 = {};
	__export$110(stdin_exports$109, {
		Divider: () => Divider,
		default: () => stdin_default$103,
		dividerProps: () => import_Divider2.dividerProps
	});
	module.exports = __toCommonJS$110(stdin_exports$109);
	var import_utils$103 = require_utils$9();
	var import_Divider = __toESM$58(require_Divider());
	var import_Divider2 = require_Divider();
	var Divider = (0, import_utils$103.withInstall)(import_Divider.default);
	var stdin_default$103 = Divider;
}) });

//#endregion
//#region node_modules/vant/lib/dropdown-menu/DropdownMenu.js
var require_DropdownMenu = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/dropdown-menu/DropdownMenu.js": ((exports, module) => {
	var __defProp$109 = Object.defineProperty;
	var __getOwnPropDesc$109 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$109 = Object.getOwnPropertyNames;
	var __hasOwnProp$109 = Object.prototype.hasOwnProperty;
	var __export$109 = (target, all) => {
		for (var name2 in all) __defProp$109(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$109 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$109(from)) if (!__hasOwnProp$109.call(to, key) && key !== except) __defProp$109(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$109(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$109 = (mod) => __copyProps$109(__defProp$109({}, "__esModule", { value: true }), mod);
	var stdin_exports$108 = {};
	__export$109(stdin_exports$108, {
		DROPDOWN_KEY: () => DROPDOWN_KEY,
		default: () => stdin_default$102,
		dropdownMenuProps: () => dropdownMenuProps
	});
	module.exports = __toCommonJS$109(stdin_exports$108);
	var import_vue$54 = require_vue();
	var import_utils$102 = require_utils$9();
	var import_use_id$1 = require_use_id();
	var import_use_expose$14 = require_use_expose();
	var import_use$31 = require_index_cjs$1();
	var [name$47, bem$47] = (0, import_utils$102.createNamespace)("dropdown-menu");
	var dropdownMenuProps = {
		overlay: import_utils$102.truthProp,
		zIndex: import_utils$102.numericProp,
		duration: (0, import_utils$102.makeNumericProp)(.2),
		direction: (0, import_utils$102.makeStringProp)("down"),
		activeColor: String,
		autoLocate: Boolean,
		closeOnClickOutside: import_utils$102.truthProp,
		closeOnClickOverlay: import_utils$102.truthProp,
		swipeThreshold: import_utils$102.numericProp
	};
	var DROPDOWN_KEY = Symbol(name$47);
	var stdin_default$102 = (0, import_vue$54.defineComponent)({
		name: name$47,
		props: dropdownMenuProps,
		setup(props$1, { slots }) {
			const id = (0, import_use_id$1.useId)();
			const root = (0, import_vue$54.ref)();
			const barRef = (0, import_vue$54.ref)();
			const offset$1 = (0, import_vue$54.ref)(0);
			const { children, linkChildren } = (0, import_use$31.useChildren)(DROPDOWN_KEY);
			const scrollParent = (0, import_use$31.useScrollParent)(root);
			const opened = (0, import_vue$54.computed)(() => children.some((item) => item.state.showWrapper));
			const scrollable = (0, import_vue$54.computed)(() => props$1.swipeThreshold && children.length > +props$1.swipeThreshold);
			const barStyle = (0, import_vue$54.computed)(() => {
				if (opened.value && (0, import_utils$102.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 = (0, import_use$31.useRect)(barRef);
					if (props$1.direction === "down") offset$1.value = rect.bottom;
					else offset$1.value = import_utils$102.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 (0, import_vue$54.createVNode)("div", {
					"id": `${id}-${index}`,
					"role": "button",
					"tabindex": disabled ? void 0 : 0,
					"data-allow-mismatch": "attribute",
					"class": [bem$47("item", {
						disabled,
						grow: scrollable.value
					}), { [import_utils$102.HAPTICS_FEEDBACK]: !disabled }],
					"onClick": () => {
						if (!disabled) toggleItem(index);
					}
				}, [(0, import_vue$54.createVNode)("span", {
					"class": [bem$47("title", {
						down: showPopup === (props$1.direction === "down"),
						active: showPopup
					}), titleClass],
					"style": { color: showPopup ? props$1.activeColor : "" }
				}, [(0, import_vue$54.createVNode)("div", { "class": "van-ellipsis" }, [item.renderTitle()])])]);
			};
			(0, import_use_expose$14.useExpose)({
				close,
				opened
			});
			linkChildren({
				id,
				props: props$1,
				offset: offset$1,
				opened,
				updateOffset
			});
			(0, import_use$31.useClickAway)(root, onClickAway);
			(0, import_use$31.useEventListener)("scroll", onScroll, {
				target: scrollParent,
				passive: true
			});
			return () => {
				var _a;
				return (0, import_vue$54.createVNode)("div", {
					"ref": root,
					"class": bem$47()
				}, [(0, import_vue$54.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/lib/dropdown-item/DropdownItem.js
var require_DropdownItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/dropdown-item/DropdownItem.js": ((exports, module) => {
	var __defProp$108 = Object.defineProperty;
	var __getOwnPropDesc$108 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$108 = Object.getOwnPropertyNames;
	var __hasOwnProp$108 = Object.prototype.hasOwnProperty;
	var __export$108 = (target, all) => {
		for (var name2 in all) __defProp$108(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$108 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$108(from)) if (!__hasOwnProp$108.call(to, key) && key !== except) __defProp$108(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$108(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$108 = (mod) => __copyProps$108(__defProp$108({}, "__esModule", { value: true }), mod);
	var stdin_exports$107 = {};
	__export$108(stdin_exports$107, {
		default: () => stdin_default$101,
		dropdownItemProps: () => dropdownItemProps
	});
	module.exports = __toCommonJS$108(stdin_exports$107);
	var import_vue$53 = require_vue();
	var import_utils$101 = require_utils$9();
	var import_DropdownMenu$1 = require_DropdownMenu();
	var import_use$30 = require_index_cjs$1();
	var import_use_expose$13 = require_use_expose();
	var import_cell$1 = require_cell();
	var import_icon$16 = require_icon();
	var import_popup$5 = require_popup();
	var [name$46, bem$46] = (0, import_utils$101.createNamespace)("dropdown-item");
	var dropdownItemProps = {
		title: String,
		options: (0, import_utils$101.makeArrayProp)(),
		disabled: Boolean,
		teleport: [String, Object],
		lazyRender: import_utils$101.truthProp,
		modelValue: import_utils$101.unknownProp,
		titleClass: import_utils$101.unknownProp
	};
	var stdin_default$101 = (0, import_vue$53.defineComponent)({
		name: name$46,
		inheritAttrs: false,
		props: dropdownItemProps,
		emits: [
			"open",
			"opened",
			"close",
			"closed",
			"change",
			"update:modelValue"
		],
		setup(props$1, { emit, slots, attrs }) {
			const state = (0, import_vue$53.reactive)({
				showPopup: false,
				transition: true,
				showWrapper: false
			});
			const wrapperRef = (0, import_vue$53.ref)();
			const { parent, index } = (0, import_use$30.useParent)(import_DropdownMenu$1.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 (0, import_vue$53.createVNode)(import_icon$16.Icon, {
						"class": bem$46("icon"),
						"color": disabled ? void 0 : activeColor,
						"name": "success"
					}, null);
				};
				return (0, import_vue$53.createVNode)(import_cell$1.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 = (0, import_utils$101.getZIndexStyle)(zIndex);
				let offsetValue = offset$1.value;
				if (autoLocate && wrapperRef.value) {
					const offsetParent = (0, import_utils$101.getContainingBlock)(wrapperRef.value);
					if (offsetParent) offsetValue -= (0, import_use$30.useRect)(offsetParent).top;
				}
				if (direction === "down") style.top = `${offsetValue}px`;
				else style.bottom = `${offsetValue}px`;
				return (0, import_vue$53.withDirectives)((0, import_vue$53.createVNode)("div", (0, import_vue$53.mergeProps)({
					"ref": wrapperRef,
					"style": style,
					"class": bem$46([direction]),
					"onClick": onClickWrapper
				}, attrs), [(0, import_vue$53.createVNode)(import_popup$5.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)];
				} })]), [[import_vue$53.vShow, state.showWrapper]]);
			};
			(0, import_use_expose$13.useExpose)({
				state,
				toggle,
				renderTitle
			});
			return () => {
				if (props$1.teleport) return (0, import_vue$53.createVNode)(import_vue$53.Teleport, { "to": props$1.teleport }, { default: () => [renderContent()] });
				return renderContent();
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/dropdown-item/index.js
var require_dropdown_item = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/dropdown-item/index.js": ((exports, module) => {
	var __create$57 = Object.create;
	var __defProp$107 = Object.defineProperty;
	var __getOwnPropDesc$107 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$107 = Object.getOwnPropertyNames;
	var __getProtoOf$57 = Object.getPrototypeOf;
	var __hasOwnProp$107 = Object.prototype.hasOwnProperty;
	var __export$107 = (target, all) => {
		for (var name$111 in all) __defProp$107(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$107 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$107(from)) if (!__hasOwnProp$107.call(to, key) && key !== except) __defProp$107(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$107(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$57 = (mod, isNodeMode, target) => (target = mod != null ? __create$57(__getProtoOf$57(mod)) : {}, __copyProps$107(isNodeMode || !mod || !mod.__esModule ? __defProp$107(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$107 = (mod) => __copyProps$107(__defProp$107({}, "__esModule", { value: true }), mod);
	var stdin_exports$106 = {};
	__export$107(stdin_exports$106, {
		DropdownItem: () => DropdownItem,
		default: () => stdin_default$100,
		dropdownItemProps: () => import_DropdownItem2.dropdownItemProps
	});
	module.exports = __toCommonJS$107(stdin_exports$106);
	var import_utils$100 = require_utils$9();
	var import_DropdownItem = __toESM$57(require_DropdownItem());
	var import_DropdownItem2 = require_DropdownItem();
	var DropdownItem = (0, import_utils$100.withInstall)(import_DropdownItem.default);
	var stdin_default$100 = DropdownItem;
}) });

//#endregion
//#region node_modules/vant/lib/dropdown-menu/index.js
var require_dropdown_menu = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/dropdown-menu/index.js": ((exports, module) => {
	var __create$56 = Object.create;
	var __defProp$106 = Object.defineProperty;
	var __getOwnPropDesc$106 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$106 = Object.getOwnPropertyNames;
	var __getProtoOf$56 = Object.getPrototypeOf;
	var __hasOwnProp$106 = Object.prototype.hasOwnProperty;
	var __export$106 = (target, all) => {
		for (var name$111 in all) __defProp$106(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$106 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$106(from)) if (!__hasOwnProp$106.call(to, key) && key !== except) __defProp$106(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$106(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$56 = (mod, isNodeMode, target) => (target = mod != null ? __create$56(__getProtoOf$56(mod)) : {}, __copyProps$106(isNodeMode || !mod || !mod.__esModule ? __defProp$106(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$106 = (mod) => __copyProps$106(__defProp$106({}, "__esModule", { value: true }), mod);
	var stdin_exports$105 = {};
	__export$106(stdin_exports$105, {
		DropdownMenu: () => DropdownMenu,
		default: () => stdin_default$99,
		dropdownMenuProps: () => import_DropdownMenu2.dropdownMenuProps
	});
	module.exports = __toCommonJS$106(stdin_exports$105);
	var import_utils$99 = require_utils$9();
	var import_DropdownMenu = __toESM$56(require_DropdownMenu());
	var import_DropdownMenu2 = require_DropdownMenu();
	var DropdownMenu = (0, import_utils$99.withInstall)(import_DropdownMenu.default);
	var stdin_default$99 = DropdownMenu;
}) });

//#endregion
//#region node_modules/vant/lib/floating-bubble/FloatingBubble.js
var require_FloatingBubble = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/floating-bubble/FloatingBubble.js": ((exports, module) => {
	var __create$55 = Object.create;
	var __defProp$105 = Object.defineProperty;
	var __getOwnPropDesc$105 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$105 = Object.getOwnPropertyNames;
	var __getProtoOf$55 = Object.getPrototypeOf;
	var __hasOwnProp$105 = Object.prototype.hasOwnProperty;
	var __export$105 = (target, all) => {
		for (var name2 in all) __defProp$105(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$105 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$105(from)) if (!__hasOwnProp$105.call(to, key) && key !== except) __defProp$105(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$105(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$55 = (mod, isNodeMode, target) => (target = mod != null ? __create$55(__getProtoOf$55(mod)) : {}, __copyProps$105(isNodeMode || !mod || !mod.__esModule ? __defProp$105(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$105 = (mod) => __copyProps$105(__defProp$105({}, "__esModule", { value: true }), mod);
	var stdin_exports$104 = {};
	__export$105(stdin_exports$104, {
		default: () => stdin_default$98,
		floatingBubbleProps: () => floatingBubbleProps
	});
	module.exports = __toCommonJS$105(stdin_exports$104);
	var import_vue$52 = require_vue();
	var import_utils$98 = require_utils$9();
	var import_use$29 = require_index_cjs$1();
	var import_use_touch$8 = require_use_touch();
	var import_icon$15 = __toESM$55(require_icon());
	var floatingBubbleProps = {
		gap: {
			type: [Number, Object],
			default: 24
		},
		icon: String,
		axis: (0, import_utils$98.makeStringProp)("y"),
		magnetic: String,
		offset: Object,
		teleport: {
			type: [String, Object],
			default: "body"
		}
	};
	var [name$45, bem$45] = (0, import_utils$98.createNamespace)("floating-bubble");
	var stdin_default$98 = (0, import_vue$52.defineComponent)({
		name: name$45,
		inheritAttrs: false,
		props: floatingBubbleProps,
		emits: [
			"click",
			"update:offset",
			"offsetChange"
		],
		setup(props$1, { slots, emit, attrs }) {
			const rootRef = (0, import_vue$52.ref)();
			const state = (0, import_vue$52.ref)({
				x: 0,
				y: 0,
				width: 0,
				height: 0
			});
			const gapX = (0, import_vue$52.computed)(() => (0, import_utils$98.isObject)(props$1.gap) ? props$1.gap.x : props$1.gap);
			const gapY = (0, import_vue$52.computed)(() => (0, import_utils$98.isObject)(props$1.gap) ? props$1.gap.y : props$1.gap);
			const boundary = (0, import_vue$52.computed)(() => ({
				top: gapY.value,
				right: import_utils$98.windowWidth.value - state.value.width - gapX.value,
				bottom: import_utils$98.windowHeight.value - state.value.height - gapY.value,
				left: gapX.value
			}));
			const dragging = (0, import_vue$52.ref)(false);
			let initialized = false;
			const rootStyle = (0, import_vue$52.computed)(() => {
				const style = {};
				style.transform = `translate3d(${(0, import_utils$98.addUnit)(state.value.x)}, ${(0, import_utils$98.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 } = (0, import_use$29.useRect)(rootRef.value);
				const { offset: offset$1 } = props$1;
				state.value = {
					x: offset$1 ? offset$1.x : import_utils$98.windowWidth.value - width$1 - gapX.value,
					y: offset$1 ? offset$1.y : import_utils$98.windowHeight.value - height$1 - gapY.value,
					width: width$1,
					height: height$1
				};
			};
			const touch = (0, import_use_touch$8.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", (0, import_utils$98.pick)(state.value, ["x", "y"]));
				}
			};
			(0, import_use$29.useEventListener)("touchmove", onTouchMove, { target: rootRef });
			const onTouchEnd = () => {
				dragging.value = false;
				(0, import_vue$52.nextTick)(() => {
					if (props$1.magnetic === "x") {
						const nextX = (0, import_utils$98.closest)([boundary.value.left, boundary.value.right], state.value.x);
						state.value.x = nextX;
					}
					if (props$1.magnetic === "y") {
						const nextY = (0, import_utils$98.closest)([boundary.value.top, boundary.value.bottom], state.value.y);
						state.value.y = nextY;
					}
					if (!touch.isTap.value) {
						const offset$1 = (0, import_utils$98.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();
			};
			(0, import_vue$52.onMounted)(() => {
				updateState();
				(0, import_vue$52.nextTick)(() => {
					initialized = true;
				});
			});
			(0, import_vue$52.watch)([
				import_utils$98.windowWidth,
				import_utils$98.windowHeight,
				gapX,
				gapY,
				() => props$1.offset
			], updateState, { deep: true });
			const show = (0, import_vue$52.ref)(true);
			(0, import_vue$52.onActivated)(() => {
				show.value = true;
			});
			(0, import_vue$52.onDeactivated)(() => {
				if (props$1.teleport) show.value = false;
			});
			return () => {
				const Content = (0, import_vue$52.withDirectives)((0, import_vue$52.createVNode)("div", (0, import_vue$52.mergeProps)({
					"class": bem$45(),
					"ref": rootRef,
					"onTouchstartPassive": onTouchStart,
					"onTouchend": onTouchEnd,
					"onTouchcancel": onTouchEnd,
					"onClickCapture": onClick,
					"style": rootStyle.value
				}, attrs), [slots.default ? slots.default() : (0, import_vue$52.createVNode)(import_icon$15.default, {
					"name": props$1.icon,
					"class": bem$45("icon")
				}, null)]), [[import_vue$52.vShow, show.value]]);
				return props$1.teleport ? (0, import_vue$52.createVNode)(import_vue$52.Teleport, { "to": props$1.teleport }, { default: () => [Content] }) : Content;
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/floating-bubble/index.js
var require_floating_bubble = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/floating-bubble/index.js": ((exports, module) => {
	var __create$54 = Object.create;
	var __defProp$104 = Object.defineProperty;
	var __getOwnPropDesc$104 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$104 = Object.getOwnPropertyNames;
	var __getProtoOf$54 = Object.getPrototypeOf;
	var __hasOwnProp$104 = Object.prototype.hasOwnProperty;
	var __export$104 = (target, all) => {
		for (var name$111 in all) __defProp$104(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$104 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$104(from)) if (!__hasOwnProp$104.call(to, key) && key !== except) __defProp$104(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$104(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$54 = (mod, isNodeMode, target) => (target = mod != null ? __create$54(__getProtoOf$54(mod)) : {}, __copyProps$104(isNodeMode || !mod || !mod.__esModule ? __defProp$104(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$104 = (mod) => __copyProps$104(__defProp$104({}, "__esModule", { value: true }), mod);
	var stdin_exports$103 = {};
	__export$104(stdin_exports$103, {
		FloatingBubble: () => FloatingBubble,
		default: () => stdin_default$97,
		floatingBubbleProps: () => import_FloatingBubble2.floatingBubbleProps
	});
	module.exports = __toCommonJS$104(stdin_exports$103);
	var import_utils$97 = require_utils$9();
	var import_FloatingBubble = __toESM$54(require_FloatingBubble());
	var import_FloatingBubble2 = require_FloatingBubble();
	var FloatingBubble = (0, import_utils$97.withInstall)(import_FloatingBubble.default);
	var stdin_default$97 = FloatingBubble;
}) });

//#endregion
//#region node_modules/vant/lib/floating-panel/FloatingPanel.js
var require_FloatingPanel = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/floating-panel/FloatingPanel.js": ((exports, module) => {
	var __defProp$103 = Object.defineProperty;
	var __getOwnPropDesc$103 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$103 = Object.getOwnPropertyNames;
	var __hasOwnProp$103 = Object.prototype.hasOwnProperty;
	var __export$103 = (target, all) => {
		for (var name2 in all) __defProp$103(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$103 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$103(from)) if (!__hasOwnProp$103.call(to, key) && key !== except) __defProp$103(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$103(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$103 = (mod) => __copyProps$103(__defProp$103({}, "__esModule", { value: true }), mod);
	var stdin_exports$102 = {};
	__export$103(stdin_exports$102, {
		default: () => stdin_default$96,
		floatingPanelProps: () => floatingPanelProps
	});
	module.exports = __toCommonJS$103(stdin_exports$102);
	var import_vue$51 = require_vue();
	var import_utils$96 = require_utils$9();
	var import_use$28 = require_index_cjs$1();
	var import_use_lock_scroll = require_use_lock_scroll();
	var import_use_touch$7 = require_use_touch();
	var import_use_sync_prop_ref$1 = require_use_sync_prop_ref();
	var floatingPanelProps = {
		height: (0, import_utils$96.makeNumericProp)(0),
		anchors: (0, import_utils$96.makeArrayProp)(),
		duration: (0, import_utils$96.makeNumericProp)(.3),
		contentDraggable: import_utils$96.truthProp,
		lockScroll: Boolean,
		safeAreaInsetBottom: import_utils$96.truthProp
	};
	var [name$44, bem$44] = (0, import_utils$96.createNamespace)("floating-panel");
	var stdin_default$96 = (0, import_vue$51.defineComponent)({
		name: name$44,
		props: floatingPanelProps,
		emits: ["heightChange", "update:height"],
		setup(props$1, { emit, slots }) {
			const DAMP = .2;
			const rootRef = (0, import_vue$51.ref)();
			const contentRef = (0, import_vue$51.ref)();
			const height$1 = (0, import_use_sync_prop_ref$1.useSyncPropRef)(() => +props$1.height, (value) => emit("update:height", value));
			const boundary = (0, import_vue$51.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(import_utils$96.windowHeight.value * .6)
				};
			});
			const anchors = (0, import_vue$51.computed)(() => props$1.anchors.length >= 2 ? props$1.anchors : [boundary.value.min, boundary.value.max]);
			const dragging = (0, import_vue$51.ref)(false);
			const rootStyle = (0, import_vue$51.computed)(() => ({
				height: (0, import_utils$96.addUnit)(boundary.value.max),
				transform: `translateY(calc(100% + ${(0, import_utils$96.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 = (0, import_use_touch$7.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) (0, import_utils$96.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 = (0, import_utils$96.closest)(anchors.value, height$1.value);
				if (height$1.value !== -startY) emit("heightChange", { height: height$1.value });
			};
			(0, import_vue$51.watch)(boundary, () => {
				height$1.value = (0, import_utils$96.closest)(anchors.value, height$1.value);
			}, { immediate: true });
			(0, import_use_lock_scroll.useLockScroll)(rootRef, () => props$1.lockScroll || dragging.value);
			(0, import_use$28.useEventListener)("touchmove", onTouchmove, { target: rootRef });
			const renderHeader = () => {
				if (slots.header) return slots.header();
				return (0, import_vue$51.createVNode)("div", { "class": bem$44("header") }, [(0, import_vue$51.createVNode)("div", { "class": bem$44("header-bar") }, null)]);
			};
			return () => {
				var _a;
				return (0, import_vue$51.createVNode)("div", {
					"class": [bem$44(), { "van-safe-area-bottom": props$1.safeAreaInsetBottom }],
					"ref": rootRef,
					"style": rootStyle.value,
					"onTouchstartPassive": onTouchstart,
					"onTouchend": onTouchend,
					"onTouchcancel": onTouchend
				}, [renderHeader(), (0, import_vue$51.createVNode)("div", {
					"class": bem$44("content"),
					"ref": contentRef
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/floating-panel/index.js
var require_floating_panel = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/floating-panel/index.js": ((exports, module) => {
	var __create$53 = Object.create;
	var __defProp$102 = Object.defineProperty;
	var __getOwnPropDesc$102 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$102 = Object.getOwnPropertyNames;
	var __getProtoOf$53 = Object.getPrototypeOf;
	var __hasOwnProp$102 = Object.prototype.hasOwnProperty;
	var __export$102 = (target, all) => {
		for (var name$111 in all) __defProp$102(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$102 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$102(from)) if (!__hasOwnProp$102.call(to, key) && key !== except) __defProp$102(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$102(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$53 = (mod, isNodeMode, target) => (target = mod != null ? __create$53(__getProtoOf$53(mod)) : {}, __copyProps$102(isNodeMode || !mod || !mod.__esModule ? __defProp$102(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$102 = (mod) => __copyProps$102(__defProp$102({}, "__esModule", { value: true }), mod);
	var stdin_exports$101 = {};
	__export$102(stdin_exports$101, {
		FloatingPanel: () => FloatingPanel,
		default: () => stdin_default$95,
		floatingPanelProps: () => import_FloatingPanel2.floatingPanelProps
	});
	module.exports = __toCommonJS$102(stdin_exports$101);
	var import_utils$95 = require_utils$9();
	var import_FloatingPanel = __toESM$53(require_FloatingPanel());
	var import_FloatingPanel2 = require_FloatingPanel();
	var FloatingPanel = (0, import_utils$95.withInstall)(import_FloatingPanel.default);
	var stdin_default$95 = FloatingPanel;
}) });

//#endregion
//#region node_modules/vant/lib/grid/Grid.js
var require_Grid = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/grid/Grid.js": ((exports, module) => {
	var __defProp$101 = Object.defineProperty;
	var __getOwnPropDesc$101 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$101 = Object.getOwnPropertyNames;
	var __hasOwnProp$101 = Object.prototype.hasOwnProperty;
	var __export$101 = (target, all) => {
		for (var name2 in all) __defProp$101(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$101 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$101(from)) if (!__hasOwnProp$101.call(to, key) && key !== except) __defProp$101(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$101(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$101 = (mod) => __copyProps$101(__defProp$101({}, "__esModule", { value: true }), mod);
	var stdin_exports$100 = {};
	__export$101(stdin_exports$100, {
		GRID_KEY: () => GRID_KEY,
		default: () => stdin_default$94,
		gridProps: () => gridProps
	});
	module.exports = __toCommonJS$101(stdin_exports$100);
	var import_vue$50 = require_vue();
	var import_utils$94 = require_utils$9();
	var import_constant = require_constant();
	var import_use$27 = require_index_cjs$1();
	var [name$43, bem$43] = (0, import_utils$94.createNamespace)("grid");
	var gridProps = {
		square: Boolean,
		center: import_utils$94.truthProp,
		border: import_utils$94.truthProp,
		gutter: import_utils$94.numericProp,
		reverse: Boolean,
		iconSize: import_utils$94.numericProp,
		direction: String,
		clickable: Boolean,
		columnNum: (0, import_utils$94.makeNumericProp)(4)
	};
	var GRID_KEY = Symbol(name$43);
	var stdin_default$94 = (0, import_vue$50.defineComponent)({
		name: name$43,
		props: gridProps,
		setup(props$1, { slots }) {
			const { linkChildren } = (0, import_use$27.useChildren)(GRID_KEY);
			linkChildren({ props: props$1 });
			return () => {
				var _a;
				return (0, import_vue$50.createVNode)("div", {
					"style": { paddingLeft: (0, import_utils$94.addUnit)(props$1.gutter) },
					"class": [bem$43(), { [import_constant.BORDER_TOP]: props$1.border && !props$1.gutter }]
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/grid/index.js
var require_grid = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/grid/index.js": ((exports, module) => {
	var __create$52 = Object.create;
	var __defProp$100 = Object.defineProperty;
	var __getOwnPropDesc$100 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$100 = Object.getOwnPropertyNames;
	var __getProtoOf$52 = Object.getPrototypeOf;
	var __hasOwnProp$100 = Object.prototype.hasOwnProperty;
	var __export$100 = (target, all) => {
		for (var name$111 in all) __defProp$100(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$100 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$100(from)) if (!__hasOwnProp$100.call(to, key) && key !== except) __defProp$100(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$100(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$52 = (mod, isNodeMode, target) => (target = mod != null ? __create$52(__getProtoOf$52(mod)) : {}, __copyProps$100(isNodeMode || !mod || !mod.__esModule ? __defProp$100(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$100 = (mod) => __copyProps$100(__defProp$100({}, "__esModule", { value: true }), mod);
	var stdin_exports$99 = {};
	__export$100(stdin_exports$99, {
		Grid: () => Grid,
		default: () => stdin_default$93,
		gridProps: () => import_Grid2.gridProps
	});
	module.exports = __toCommonJS$100(stdin_exports$99);
	var import_utils$93 = require_utils$9();
	var import_Grid$1 = __toESM$52(require_Grid());
	var import_Grid2 = require_Grid();
	var Grid = (0, import_utils$93.withInstall)(import_Grid$1.default);
	var stdin_default$93 = Grid;
}) });

//#endregion
//#region node_modules/vant/lib/grid-item/GridItem.js
var require_GridItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/grid-item/GridItem.js": ((exports, module) => {
	var __defProp$99 = Object.defineProperty;
	var __getOwnPropDesc$99 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$99 = Object.getOwnPropertyNames;
	var __hasOwnProp$99 = Object.prototype.hasOwnProperty;
	var __export$99 = (target, all) => {
		for (var name2 in all) __defProp$99(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$99 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$99(from)) if (!__hasOwnProp$99.call(to, key) && key !== except) __defProp$99(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$99(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$99 = (mod) => __copyProps$99(__defProp$99({}, "__esModule", { value: true }), mod);
	var stdin_exports$98 = {};
	__export$99(stdin_exports$98, {
		default: () => stdin_default$92,
		gridItemProps: () => gridItemProps
	});
	module.exports = __toCommonJS$99(stdin_exports$98);
	var import_vue$49 = require_vue();
	var import_utils$92 = require_utils$9();
	var import_Grid = require_Grid();
	var import_use$26 = require_index_cjs$1();
	var import_use_route$2 = require_use_route();
	var import_icon$14 = require_icon();
	var import_badge$3 = require_badge();
	var [name$42, bem$42] = (0, import_utils$92.createNamespace)("grid-item");
	var gridItemProps = (0, import_utils$92.extend)({}, import_use_route$2.routeProps, {
		dot: Boolean,
		text: String,
		icon: String,
		badge: import_utils$92.numericProp,
		iconColor: String,
		iconPrefix: String,
		badgeProps: Object
	});
	var stdin_default$92 = (0, import_vue$49.defineComponent)({
		name: name$42,
		props: gridItemProps,
		setup(props$1, { slots }) {
			const { parent, index } = (0, import_use$26.useParent)(import_Grid.GRID_KEY);
			const route$1 = (0, import_use_route$2.useRoute)();
			if (!parent) {
				console.error("[Vant] <GridItem> must be a child component of <Grid>.");
				return;
			}
			const rootStyle = (0, import_vue$49.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 = (0, import_utils$92.addUnit)(gutter);
					style.paddingRight = gutterValue;
					if (index.value >= +columnNum) style.marginTop = gutterValue;
				}
				return style;
			});
			const contentStyle = (0, import_vue$49.computed)(() => {
				const { square, gutter } = parent.props;
				if (square && gutter) {
					const gutterValue = (0, import_utils$92.addUnit)(gutter);
					return {
						right: gutterValue,
						bottom: gutterValue,
						height: "auto"
					};
				}
			});
			const renderIcon = () => {
				if (slots.icon) return (0, import_vue$49.createVNode)(import_badge$3.Badge, (0, import_vue$49.mergeProps)({
					"dot": props$1.dot,
					"content": props$1.badge
				}, props$1.badgeProps), { default: slots.icon });
				if (props$1.icon) return (0, import_vue$49.createVNode)(import_icon$14.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 (0, import_vue$49.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
				}]), { [import_utils$92.BORDER]: border }];
				return (0, import_vue$49.createVNode)("div", {
					"class": [bem$42({ square })],
					"style": rootStyle.value
				}, [(0, import_vue$49.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/lib/grid-item/index.js
var require_grid_item = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/grid-item/index.js": ((exports, module) => {
	var __create$51 = Object.create;
	var __defProp$98 = Object.defineProperty;
	var __getOwnPropDesc$98 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$98 = Object.getOwnPropertyNames;
	var __getProtoOf$51 = Object.getPrototypeOf;
	var __hasOwnProp$98 = Object.prototype.hasOwnProperty;
	var __export$98 = (target, all) => {
		for (var name$111 in all) __defProp$98(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$98 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$98(from)) if (!__hasOwnProp$98.call(to, key) && key !== except) __defProp$98(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$98(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$51 = (mod, isNodeMode, target) => (target = mod != null ? __create$51(__getProtoOf$51(mod)) : {}, __copyProps$98(isNodeMode || !mod || !mod.__esModule ? __defProp$98(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$98 = (mod) => __copyProps$98(__defProp$98({}, "__esModule", { value: true }), mod);
	var stdin_exports$97 = {};
	__export$98(stdin_exports$97, {
		GridItem: () => GridItem,
		default: () => stdin_default$91,
		gridItemProps: () => import_GridItem2.gridItemProps
	});
	module.exports = __toCommonJS$98(stdin_exports$97);
	var import_utils$91 = require_utils$9();
	var import_GridItem = __toESM$51(require_GridItem());
	var import_GridItem2 = require_GridItem();
	var GridItem = (0, import_utils$91.withInstall)(import_GridItem.default);
	var stdin_default$91 = GridItem;
}) });

//#endregion
//#region node_modules/vant/lib/highlight/Highlight.js
var require_Highlight = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/highlight/Highlight.js": ((exports, module) => {
	var __defProp$97 = Object.defineProperty;
	var __getOwnPropDesc$97 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$97 = Object.getOwnPropertyNames;
	var __hasOwnProp$97 = Object.prototype.hasOwnProperty;
	var __export$97 = (target, all) => {
		for (var name2 in all) __defProp$97(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$97 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$97(from)) if (!__hasOwnProp$97.call(to, key) && key !== except) __defProp$97(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$97(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$97 = (mod) => __copyProps$97(__defProp$97({}, "__esModule", { value: true }), mod);
	var stdin_exports$96 = {};
	__export$97(stdin_exports$96, {
		default: () => stdin_default$90,
		highlightProps: () => highlightProps
	});
	module.exports = __toCommonJS$97(stdin_exports$96);
	var import_vue$48 = require_vue();
	var import_utils$90 = require_utils$9();
	var [name$41, bem$41] = (0, import_utils$90.createNamespace)("highlight");
	var highlightProps = {
		autoEscape: import_utils$90.truthProp,
		caseSensitive: Boolean,
		highlightClass: String,
		highlightTag: (0, import_utils$90.makeStringProp)("span"),
		keywords: (0, import_utils$90.makeRequiredProp)([String, Array]),
		sourceString: (0, import_utils$90.makeStringProp)(""),
		tag: (0, import_utils$90.makeStringProp)("div"),
		unhighlightClass: String,
		unhighlightTag: (0, import_utils$90.makeStringProp)("span")
	};
	var stdin_default$90 = (0, import_vue$48.defineComponent)({
		name: name$41,
		props: highlightProps,
		setup(props$1) {
			const highlightChunks = (0, import_vue$48.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 (0, import_vue$48.createVNode)(highlightTag, { "class": [bem$41("tag"), highlightClass] }, { default: () => [text] });
					return (0, import_vue$48.createVNode)(unhighlightTag, { "class": unhighlightClass }, { default: () => [text] });
				});
			};
			return () => {
				const { tag } = props$1;
				return (0, import_vue$48.createVNode)(tag, { "class": bem$41() }, { default: () => [renderContent()] });
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/highlight/index.js
var require_highlight = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/highlight/index.js": ((exports, module) => {
	var __create$50 = Object.create;
	var __defProp$96 = Object.defineProperty;
	var __getOwnPropDesc$96 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$96 = Object.getOwnPropertyNames;
	var __getProtoOf$50 = Object.getPrototypeOf;
	var __hasOwnProp$96 = Object.prototype.hasOwnProperty;
	var __export$96 = (target, all) => {
		for (var name$111 in all) __defProp$96(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$96 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$96(from)) if (!__hasOwnProp$96.call(to, key) && key !== except) __defProp$96(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$96(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$50 = (mod, isNodeMode, target) => (target = mod != null ? __create$50(__getProtoOf$50(mod)) : {}, __copyProps$96(isNodeMode || !mod || !mod.__esModule ? __defProp$96(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$96 = (mod) => __copyProps$96(__defProp$96({}, "__esModule", { value: true }), mod);
	var stdin_exports$95 = {};
	__export$96(stdin_exports$95, {
		Highlight: () => Highlight,
		default: () => stdin_default$89,
		highlightProps: () => import_Highlight2.highlightProps
	});
	module.exports = __toCommonJS$96(stdin_exports$95);
	var import_utils$89 = require_utils$9();
	var import_Highlight = __toESM$50(require_Highlight());
	var import_Highlight2 = require_Highlight();
	var Highlight = (0, import_utils$89.withInstall)(import_Highlight.default);
	var stdin_default$89 = Highlight;
}) });

//#endregion
//#region node_modules/vant/lib/image-preview/ImagePreviewItem.js
var require_ImagePreviewItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/image-preview/ImagePreviewItem.js": ((exports, module) => {
	var __defProp$95 = Object.defineProperty;
	var __getOwnPropDesc$95 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$95 = Object.getOwnPropertyNames;
	var __hasOwnProp$95 = Object.prototype.hasOwnProperty;
	var __export$95 = (target, all) => {
		for (var name$111 in all) __defProp$95(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$95 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$95(from)) if (!__hasOwnProp$95.call(to, key) && key !== except) __defProp$95(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$95(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$95 = (mod) => __copyProps$95(__defProp$95({}, "__esModule", { value: true }), mod);
	var stdin_exports$94 = {};
	__export$95(stdin_exports$94, { default: () => stdin_default$88 });
	module.exports = __toCommonJS$95(stdin_exports$94);
	var import_vue$47 = require_vue();
	var import_utils$88 = require_utils$9();
	var import_use_expose$12 = require_use_expose();
	var import_use_touch$6 = require_use_touch();
	var import_use$25 = require_index_cjs$1();
	var import_image$2 = require_image();
	var import_loading$5 = require_loading();
	var import_swipe_item$1 = require_swipe_item();
	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 = (0, import_utils$88.createNamespace)("image-preview")[1];
	var longImageRatio = 2.6;
	var imagePreviewItemProps = {
		src: String,
		show: Boolean,
		active: Number,
		minZoom: (0, import_utils$88.makeRequiredProp)(import_utils$88.numericProp),
		maxZoom: (0, import_utils$88.makeRequiredProp)(import_utils$88.numericProp),
		rootWidth: (0, import_utils$88.makeRequiredProp)(Number),
		rootHeight: (0, import_utils$88.makeRequiredProp)(Number),
		disableZoom: Boolean,
		doubleScale: Boolean,
		closeOnClickImage: Boolean,
		closeOnClickOverlay: Boolean,
		vertical: Boolean
	};
	var stdin_default$88 = (0, import_vue$47.defineComponent)({
		props: imagePreviewItemProps,
		emits: [
			"scale",
			"close",
			"longPress"
		],
		setup(props$1, { emit, slots }) {
			const state = (0, import_vue$47.reactive)({
				scale: 1,
				moveX: 0,
				moveY: 0,
				moving: false,
				zooming: false,
				initializing: false,
				imageRatio: 0
			});
			const touch = (0, import_use_touch$6.useTouch)();
			const imageRef = (0, import_vue$47.ref)();
			const swipeItem = (0, import_vue$47.ref)();
			const vertical = (0, import_vue$47.ref)(false);
			const isLongImage = (0, import_vue$47.ref)(false);
			let initialMoveY = 0;
			const imageStyle = (0, import_vue$47.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 = (0, import_vue$47.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 = (0, import_vue$47.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 = (0, import_utils$88.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 = (0, import_use$25.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 = (0, import_utils$88.clamp)(moveX, -maxMoveX.value, maxMoveX.value);
						state.moveY = (0, import_utils$88.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;
					(0, import_utils$88.preventDefault)(event, true);
					state.moveX = (0, import_utils$88.clamp)(moveX, -maxMoveX.value, maxMoveX.value);
					state.moveY = (0, import_utils$88.clamp)(moveY, -maxMoveY.value, maxMoveY.value);
				}
				if (state.zooming) {
					(0, import_utils$88.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 > import_utils$88.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 = (0, import_utils$88.clamp)(state.moveX, -maxMoveX.value, maxMoveX.value);
							state.moveY = (0, import_utils$88.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);
					}
				}
				(0, import_utils$88.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;
					(0, import_use$25.raf)(() => {
						state.initializing = false;
					});
				}
				resetScale();
			};
			const onLoad = (event) => {
				const { naturalWidth, naturalHeight } = event.target;
				state.imageRatio = naturalHeight / naturalWidth;
				resize();
			};
			(0, import_vue$47.watch)(() => props$1.active, resetScale);
			(0, import_vue$47.watch)(() => props$1.show, (value) => {
				if (!value) resetScale();
			});
			(0, import_vue$47.watch)(() => [props$1.rootWidth, props$1.rootHeight], resize);
			(0, import_use$25.useEventListener)("touchmove", onTouchMove, { target: (0, import_vue$47.computed)(() => {
				var _a;
				return (_a = swipeItem.value) == null ? void 0 : _a.$el;
			}) });
			(0, import_use_expose$12.useExpose)({ resetScale });
			return () => {
				const imageSlots = { loading: () => (0, import_vue$47.createVNode)(import_loading$5.Loading, { "type": "spinner" }, null) };
				return (0, import_vue$47.createVNode)(import_swipe_item$1.SwipeItem, {
					"ref": swipeItem,
					"class": bem$40("swipe-item"),
					"onTouchstartPassive": onTouchStart,
					"onTouchend": onTouchEnd,
					"onTouchcancel": onTouchEnd
				}, { default: () => [slots.image ? (0, import_vue$47.createVNode)("div", { "class": bem$40("image-wrap") }, [slots.image({
					src: props$1.src,
					onLoad,
					style: imageStyle.value
				})]) : (0, import_vue$47.createVNode)(import_image$2.Image, {
					"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/lib/image-preview/ImagePreview.js
var require_ImagePreview = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/image-preview/ImagePreview.js": ((exports, module) => {
	var __create$49 = Object.create;
	var __defProp$94 = Object.defineProperty;
	var __getOwnPropDesc$94 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$94 = Object.getOwnPropertyNames;
	var __getProtoOf$49 = Object.getPrototypeOf;
	var __hasOwnProp$94 = Object.prototype.hasOwnProperty;
	var __export$94 = (target, all) => {
		for (var name2 in all) __defProp$94(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$94 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$94(from)) if (!__hasOwnProp$94.call(to, key) && key !== except) __defProp$94(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$94(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$49 = (mod, isNodeMode, target) => (target = mod != null ? __create$49(__getProtoOf$49(mod)) : {}, __copyProps$94(isNodeMode || !mod || !mod.__esModule ? __defProp$94(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$94 = (mod) => __copyProps$94(__defProp$94({}, "__esModule", { value: true }), mod);
	var stdin_exports$93 = {};
	__export$94(stdin_exports$93, {
		default: () => stdin_default$87,
		imagePreviewProps: () => imagePreviewProps
	});
	module.exports = __toCommonJS$94(stdin_exports$93);
	var import_vue$46 = require_vue();
	var import_utils$87 = require_utils$9();
	var import_use$24 = require_index_cjs$1();
	var import_use_expose$11 = require_use_expose();
	var import_icon$13 = require_icon();
	var import_swipe$1 = require_swipe();
	var import_popup$4 = require_popup();
	var import_ImagePreviewItem = __toESM$49(require_ImagePreviewItem());
	var [name$40, bem$39] = (0, import_utils$87.createNamespace)("image-preview");
	var popupProps$1 = [
		"show",
		"teleport",
		"transition",
		"overlayStyle",
		"closeOnPopstate"
	];
	var imagePreviewProps = {
		show: Boolean,
		loop: import_utils$87.truthProp,
		images: (0, import_utils$87.makeArrayProp)(),
		minZoom: (0, import_utils$87.makeNumericProp)(1 / 3),
		maxZoom: (0, import_utils$87.makeNumericProp)(3),
		overlay: import_utils$87.truthProp,
		vertical: Boolean,
		closeable: Boolean,
		showIndex: import_utils$87.truthProp,
		className: import_utils$87.unknownProp,
		closeIcon: (0, import_utils$87.makeStringProp)("clear"),
		transition: String,
		beforeClose: Function,
		doubleScale: import_utils$87.truthProp,
		overlayClass: import_utils$87.unknownProp,
		overlayStyle: Object,
		swipeDuration: (0, import_utils$87.makeNumericProp)(300),
		startPosition: (0, import_utils$87.makeNumericProp)(0),
		showIndicators: Boolean,
		closeOnPopstate: import_utils$87.truthProp,
		closeOnClickImage: import_utils$87.truthProp,
		closeOnClickOverlay: import_utils$87.truthProp,
		closeIconPosition: (0, import_utils$87.makeStringProp)("top-right"),
		teleport: [String, Object]
	};
	var stdin_default$87 = (0, import_vue$46.defineComponent)({
		name: name$40,
		props: imagePreviewProps,
		emits: [
			"scale",
			"close",
			"closed",
			"change",
			"longPress",
			"update:show"
		],
		setup(props$1, { emit, slots }) {
			const swipeRef = (0, import_vue$46.ref)();
			const activedPreviewItemRef = (0, import_vue$46.ref)();
			const state = (0, import_vue$46.reactive)({
				active: 0,
				rootWidth: 0,
				rootHeight: 0,
				disableZoom: false
			});
			const resize = () => {
				if (swipeRef.value) {
					const rect = (0, import_use$24.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 = () => {
				(0, import_utils$87.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 (0, import_vue$46.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 (0, import_vue$46.createVNode)("div", { "class": bem$39("cover") }, [slots.cover()]);
			};
			const onDragStart = () => {
				state.disableZoom = true;
			};
			const onDragEnd = () => {
				state.disableZoom = false;
			};
			const renderImages = () => (0, import_vue$46.createVNode)(import_swipe$1.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) => (0, import_vue$46.createVNode)(import_ImagePreviewItem.default, {
				"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 (0, import_vue$46.createVNode)(import_icon$13.Icon, {
					"role": "button",
					"name": props$1.closeIcon,
					"class": [bem$39("close-icon", props$1.closeIconPosition), import_utils$87.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);
			};
			(0, import_use_expose$11.useExpose)({
				resetScale: () => {
					var _a;
					(_a = activedPreviewItemRef.value) == null || _a.resetScale();
				},
				swipeTo
			});
			(0, import_vue$46.onMounted)(resize);
			(0, import_vue$46.watch)([import_utils$87.windowWidth, import_utils$87.windowHeight], resize);
			(0, import_vue$46.watch)(() => props$1.startPosition, (value) => setActive(+value));
			(0, import_vue$46.watch)(() => props$1.show, (value) => {
				const { images, startPosition } = props$1;
				if (value) {
					setActive(+startPosition);
					(0, import_vue$46.nextTick)(() => {
						resize();
						swipeTo(+startPosition, { immediate: true });
					});
				} else emit("close", {
					index: state.active,
					url: images[state.active]
				});
			});
			return () => (0, import_vue$46.createVNode)(import_popup$4.Popup, (0, import_vue$46.mergeProps)({
				"class": [bem$39(), props$1.className],
				"overlayClass": [bem$39("overlay"), props$1.overlayClass],
				"onClosed": onClosed,
				"onUpdate:show": updateShow
			}, (0, import_utils$87.pick)(props$1, popupProps$1)), { default: () => [
				renderClose(),
				renderImages(),
				renderIndex(),
				renderCover()
			] });
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/image-preview/function-call.js
var require_function_call$1 = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/image-preview/function-call.js": ((exports, module) => {
	var __create$48 = Object.create;
	var __defProp$93 = Object.defineProperty;
	var __getOwnPropDesc$93 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$93 = Object.getOwnPropertyNames;
	var __getProtoOf$48 = Object.getPrototypeOf;
	var __hasOwnProp$93 = Object.prototype.hasOwnProperty;
	var __export$93 = (target, all) => {
		for (var name$111 in all) __defProp$93(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$93 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$93(from)) if (!__hasOwnProp$93.call(to, key) && key !== except) __defProp$93(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$93(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$48 = (mod, isNodeMode, target) => (target = mod != null ? __create$48(__getProtoOf$48(mod)) : {}, __copyProps$93(isNodeMode || !mod || !mod.__esModule ? __defProp$93(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$93 = (mod) => __copyProps$93(__defProp$93({}, "__esModule", { value: true }), mod);
	var stdin_exports$92 = {};
	__export$93(stdin_exports$92, { showImagePreview: () => showImagePreview });
	module.exports = __toCommonJS$93(stdin_exports$92);
	var import_vue$45 = require_vue();
	var import_utils$86 = require_utils$9();
	var import_mount_component$1 = require_mount_component();
	var import_ImagePreview$1 = __toESM$48(require_ImagePreview());
	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} = (0, import_mount_component$1.mountComponent)({ setup() {
			const { state, toggle } = (0, import_mount_component$1.usePopupState)();
			const onClosed = () => {
				state.images = [];
			};
			return () => (0, import_vue$45.createVNode)(import_ImagePreview$1.default, (0, import_vue$45.mergeProps)(state, {
				"onClosed": onClosed,
				"onUpdate:show": toggle
			}), null);
		} }));
	}
	var showImagePreview = (options, startPosition = 0) => {
		if (!import_utils$86.inBrowser) return;
		if (!instance$1) initInstance$1();
		options = Array.isArray(options) ? {
			images: options,
			startPosition
		} : options;
		instance$1.open((0, import_utils$86.extend)({}, defaultConfig, options));
		return instance$1;
	};
}) });

//#endregion
//#region node_modules/vant/lib/image-preview/index.js
var require_image_preview = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/image-preview/index.js": ((exports, module) => {
	var __create$47 = Object.create;
	var __defProp$92 = Object.defineProperty;
	var __getOwnPropDesc$92 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$92 = Object.getOwnPropertyNames;
	var __getProtoOf$47 = Object.getPrototypeOf;
	var __hasOwnProp$92 = Object.prototype.hasOwnProperty;
	var __export$92 = (target, all) => {
		for (var name$111 in all) __defProp$92(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$92 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$92(from)) if (!__hasOwnProp$92.call(to, key) && key !== except) __defProp$92(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$92(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$47 = (mod, isNodeMode, target) => (target = mod != null ? __create$47(__getProtoOf$47(mod)) : {}, __copyProps$92(isNodeMode || !mod || !mod.__esModule ? __defProp$92(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$92 = (mod) => __copyProps$92(__defProp$92({}, "__esModule", { value: true }), mod);
	var stdin_exports$91 = {};
	__export$92(stdin_exports$91, {
		ImagePreview: () => ImagePreview,
		default: () => stdin_default$86,
		imagePreviewProps: () => import_ImagePreview2.imagePreviewProps,
		showImagePreview: () => import_function_call$1.showImagePreview
	});
	module.exports = __toCommonJS$92(stdin_exports$91);
	var import_utils$85 = require_utils$9();
	var import_ImagePreview = __toESM$47(require_ImagePreview());
	var import_ImagePreview2 = require_ImagePreview();
	var import_function_call$1 = require_function_call$1();
	var ImagePreview = (0, import_utils$85.withInstall)(import_ImagePreview.default);
	var stdin_default$86 = ImagePreview;
}) });

//#endregion
//#region node_modules/vant/lib/index-bar/IndexBar.js
var require_IndexBar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/index-bar/IndexBar.js": ((exports, module) => {
	var __defProp$91 = Object.defineProperty;
	var __getOwnPropDesc$91 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$91 = Object.getOwnPropertyNames;
	var __hasOwnProp$91 = Object.prototype.hasOwnProperty;
	var __export$91 = (target, all) => {
		for (var name2 in all) __defProp$91(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$91 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$91(from)) if (!__hasOwnProp$91.call(to, key) && key !== except) __defProp$91(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$91(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$91 = (mod) => __copyProps$91(__defProp$91({}, "__esModule", { value: true }), mod);
	var stdin_exports$90 = {};
	__export$91(stdin_exports$90, {
		INDEX_BAR_KEY: () => INDEX_BAR_KEY,
		default: () => stdin_default$85,
		indexBarProps: () => indexBarProps
	});
	module.exports = __toCommonJS$91(stdin_exports$90);
	var import_vue$44 = require_vue();
	var import_utils$84 = require_utils$9();
	var import_use$23 = require_index_cjs$1();
	var import_use_touch$5 = require_use_touch();
	var import_use_expose$10 = require_use_expose();
	function genAlphabet() {
		const charCodeOfA = "A".charCodeAt(0);
		return Array(26).fill("").map((_, i) => String.fromCharCode(charCodeOfA + i));
	}
	var [name$39, bem$38] = (0, import_utils$84.createNamespace)("index-bar");
	var indexBarProps = {
		sticky: import_utils$84.truthProp,
		zIndex: import_utils$84.numericProp,
		teleport: [String, Object],
		highlightColor: String,
		stickyOffsetTop: (0, import_utils$84.makeNumberProp)(0),
		indexList: {
			type: Array,
			default: genAlphabet
		}
	};
	var INDEX_BAR_KEY = Symbol(name$39);
	var stdin_default$85 = (0, import_vue$44.defineComponent)({
		name: name$39,
		props: indexBarProps,
		emits: ["select", "change"],
		setup(props$1, { emit, slots }) {
			const root = (0, import_vue$44.ref)();
			const sidebar = (0, import_vue$44.ref)();
			const activeAnchor = (0, import_vue$44.ref)("");
			const touch = (0, import_use_touch$5.useTouch)();
			const scrollParent = (0, import_use$23.useScrollParent)(root);
			const { children, linkChildren } = (0, import_use$23.useChildren)(INDEX_BAR_KEY);
			let selectActiveIndex;
			linkChildren({ props: props$1 });
			const sidebarStyle = (0, import_vue$44.computed)(() => {
				if ((0, import_utils$84.isDef)(props$1.zIndex)) return { zIndex: +props$1.zIndex + 1 };
			});
			const highlightStyle = (0, import_vue$44.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 ((0, import_utils$84.isHidden)(root)) return;
				const { sticky, indexList } = props$1;
				const scrollTop = (0, import_utils$84.getScrollTop)(scrollParent.value);
				const scrollParentRect = (0, import_use$23.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 = () => {
				(0, import_vue$44.nextTick)(onScroll);
			};
			(0, import_use$23.useEventListener)("scroll", onScroll, {
				target: scrollParent,
				passive: true
			});
			(0, import_vue$44.onMounted)(init);
			(0, import_vue$44.watch)(() => props$1.indexList, init);
			(0, import_vue$44.watch)(activeAnchor, (value) => {
				if (value) emit("change", value);
			});
			const renderIndexes = () => props$1.indexList.map((index) => {
				const active = index === activeAnchor.value;
				return (0, import_vue$44.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 = (0, import_utils$84.getScrollTop)(scrollParent.value);
					const scrollParentRect = (0, import_use$23.useRect)(scrollParent);
					const { offsetHeight } = document.documentElement;
					match.$el.scrollIntoView();
					if (scrollTop === offsetHeight - scrollParentRect.height) {
						onScroll();
						return;
					}
					if (props$1.sticky && props$1.stickyOffsetTop) if ((0, import_utils$84.getRootScrollTop)() === offsetHeight - scrollParentRect.height) (0, import_utils$84.setRootScrollTop)((0, import_utils$84.getRootScrollTop)());
					else (0, import_utils$84.setRootScrollTop)((0, import_utils$84.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()) {
					(0, import_utils$84.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 = () => (0, import_vue$44.createVNode)("div", {
				"ref": sidebar,
				"class": bem$38("sidebar"),
				"style": sidebarStyle.value,
				"onClick": onClickSidebar,
				"onTouchstartPassive": touch.start
			}, [renderIndexes()]);
			(0, import_use_expose$10.useExpose)({ scrollTo });
			(0, import_use$23.useEventListener)("touchmove", onTouchMove, { target: sidebar });
			return () => {
				var _a;
				return (0, import_vue$44.createVNode)("div", {
					"ref": root,
					"class": bem$38()
				}, [props$1.teleport ? (0, import_vue$44.createVNode)(import_vue$44.Teleport, { "to": props$1.teleport }, { default: () => [renderSidebar()] }) : renderSidebar(), (_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/index-anchor/IndexAnchor.js
var require_IndexAnchor = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/index-anchor/IndexAnchor.js": ((exports, module) => {
	var __defProp$90 = Object.defineProperty;
	var __getOwnPropDesc$90 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$90 = Object.getOwnPropertyNames;
	var __hasOwnProp$90 = Object.prototype.hasOwnProperty;
	var __export$90 = (target, all) => {
		for (var name2 in all) __defProp$90(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$90 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$90(from)) if (!__hasOwnProp$90.call(to, key) && key !== except) __defProp$90(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$90(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$90 = (mod) => __copyProps$90(__defProp$90({}, "__esModule", { value: true }), mod);
	var stdin_exports$89 = {};
	__export$90(stdin_exports$89, {
		default: () => stdin_default$84,
		indexAnchorProps: () => indexAnchorProps
	});
	module.exports = __toCommonJS$90(stdin_exports$89);
	var import_vue$43 = require_vue();
	var import_utils$83 = require_utils$9();
	var import_IndexBar$1 = require_IndexBar();
	var import_dom = require_dom();
	var import_use$22 = require_index_cjs$1();
	var import_use_expose$9 = require_use_expose();
	var [name$38, bem$37] = (0, import_utils$83.createNamespace)("index-anchor");
	var indexAnchorProps = { index: import_utils$83.numericProp };
	var stdin_default$84 = (0, import_vue$43.defineComponent)({
		name: name$38,
		props: indexAnchorProps,
		setup(props$1, { slots }) {
			const state = (0, import_vue$43.reactive)({
				top: 0,
				left: null,
				rect: {
					top: 0,
					height: 0
				},
				width: null,
				active: false
			});
			const root = (0, import_vue$43.ref)();
			const { parent } = (0, import_use$22.useParent)(import_IndexBar$1.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 = (0, import_vue$43.computed)(() => {
				const { zIndex, highlightColor } = parent.props;
				if (isSticky()) return (0, import_utils$83.extend)((0, import_utils$83.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 = (0, import_use$22.useRect)(root);
				state.rect.height = rootRect.height;
				if (scrollParent === window || scrollParent === document.body) state.rect.top = rootRect.top + (0, import_dom.getRootScrollTop)();
				else state.rect.top = rootRect.top + (0, import_dom.getScrollTop)(scrollParent) - scrollParentRect.top;
				return state.rect;
			};
			(0, import_use_expose$9.useExpose)({
				state,
				getRect
			});
			return () => {
				const sticky = isSticky();
				return (0, import_vue$43.createVNode)("div", {
					"ref": root,
					"style": { height: sticky ? `${state.rect.height}px` : void 0 }
				}, [(0, import_vue$43.createVNode)("div", {
					"style": anchorStyle.value,
					"class": [bem$37({ sticky }), { [import_utils$83.BORDER_BOTTOM]: sticky }]
				}, [slots.default ? slots.default() : props$1.index])]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/index-anchor/index.js
var require_index_anchor = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/index-anchor/index.js": ((exports, module) => {
	var __create$46 = Object.create;
	var __defProp$89 = Object.defineProperty;
	var __getOwnPropDesc$89 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$89 = Object.getOwnPropertyNames;
	var __getProtoOf$46 = Object.getPrototypeOf;
	var __hasOwnProp$89 = Object.prototype.hasOwnProperty;
	var __export$89 = (target, all) => {
		for (var name$111 in all) __defProp$89(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$89 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$89(from)) if (!__hasOwnProp$89.call(to, key) && key !== except) __defProp$89(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$89(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$46 = (mod, isNodeMode, target) => (target = mod != null ? __create$46(__getProtoOf$46(mod)) : {}, __copyProps$89(isNodeMode || !mod || !mod.__esModule ? __defProp$89(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$89 = (mod) => __copyProps$89(__defProp$89({}, "__esModule", { value: true }), mod);
	var stdin_exports$88 = {};
	__export$89(stdin_exports$88, {
		IndexAnchor: () => IndexAnchor,
		default: () => stdin_default$83,
		indexAnchorProps: () => import_IndexAnchor2.indexAnchorProps
	});
	module.exports = __toCommonJS$89(stdin_exports$88);
	var import_utils$82 = require_utils$9();
	var import_IndexAnchor = __toESM$46(require_IndexAnchor());
	var import_IndexAnchor2 = require_IndexAnchor();
	var IndexAnchor = (0, import_utils$82.withInstall)(import_IndexAnchor.default);
	var stdin_default$83 = IndexAnchor;
}) });

//#endregion
//#region node_modules/vant/lib/index-bar/index.js
var require_index_bar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/index-bar/index.js": ((exports, module) => {
	var __create$45 = Object.create;
	var __defProp$88 = Object.defineProperty;
	var __getOwnPropDesc$88 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$88 = Object.getOwnPropertyNames;
	var __getProtoOf$45 = Object.getPrototypeOf;
	var __hasOwnProp$88 = Object.prototype.hasOwnProperty;
	var __export$88 = (target, all) => {
		for (var name$111 in all) __defProp$88(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$88 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$88(from)) if (!__hasOwnProp$88.call(to, key) && key !== except) __defProp$88(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$88(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$45 = (mod, isNodeMode, target) => (target = mod != null ? __create$45(__getProtoOf$45(mod)) : {}, __copyProps$88(isNodeMode || !mod || !mod.__esModule ? __defProp$88(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$88 = (mod) => __copyProps$88(__defProp$88({}, "__esModule", { value: true }), mod);
	var stdin_exports$87 = {};
	__export$88(stdin_exports$87, {
		IndexBar: () => IndexBar,
		default: () => stdin_default$82,
		indexBarProps: () => import_IndexBar2.indexBarProps
	});
	module.exports = __toCommonJS$88(stdin_exports$87);
	var import_utils$81 = require_utils$9();
	var import_IndexBar = __toESM$45(require_IndexBar());
	var import_IndexBar2 = require_IndexBar();
	var IndexBar = (0, import_utils$81.withInstall)(import_IndexBar.default);
	var stdin_default$82 = IndexBar;
}) });

//#endregion
//#region node_modules/vant/lib/list/List.js
var require_List = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/list/List.js": ((exports, module) => {
	var __defProp$87 = Object.defineProperty;
	var __getOwnPropDesc$87 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$87 = Object.getOwnPropertyNames;
	var __hasOwnProp$87 = Object.prototype.hasOwnProperty;
	var __export$87 = (target, all) => {
		for (var name2 in all) __defProp$87(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$87 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$87(from)) if (!__hasOwnProp$87.call(to, key) && key !== except) __defProp$87(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$87(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$87 = (mod) => __copyProps$87(__defProp$87({}, "__esModule", { value: true }), mod);
	var stdin_exports$86 = {};
	__export$87(stdin_exports$86, {
		default: () => stdin_default$81,
		listProps: () => listProps
	});
	module.exports = __toCommonJS$87(stdin_exports$86);
	var import_vue$42 = require_vue();
	var import_utils$80 = require_utils$9();
	var import_use$21 = require_index_cjs$1();
	var import_use_expose$8 = require_use_expose();
	var import_use_tab_status = require_use_tab_status();
	var import_loading$4 = require_loading();
	var [name$37, bem$36, t$7] = (0, import_utils$80.createNamespace)("list");
	var listProps = {
		error: Boolean,
		offset: (0, import_utils$80.makeNumericProp)(300),
		loading: Boolean,
		disabled: Boolean,
		finished: Boolean,
		scroller: Object,
		errorText: String,
		direction: (0, import_utils$80.makeStringProp)("down"),
		loadingText: String,
		finishedText: String,
		immediateCheck: import_utils$80.truthProp
	};
	var stdin_default$81 = (0, import_vue$42.defineComponent)({
		name: name$37,
		props: listProps,
		emits: [
			"load",
			"update:error",
			"update:loading"
		],
		setup(props$1, { emit, slots }) {
			const loading = (0, import_vue$42.ref)(props$1.loading);
			const root = (0, import_vue$42.ref)();
			const placeholder = (0, import_vue$42.ref)();
			const tabStatus = (0, import_use_tab_status.useAllTabStatus)();
			const scrollParent = (0, import_use$21.useScrollParent)(root);
			const scroller = (0, import_vue$42.computed)(() => props$1.scroller || scrollParent.value);
			const check = () => {
				(0, import_vue$42.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 = (0, import_use$21.useRect)(scroller);
					if (!scrollParentRect.height || (0, import_utils$80.isHidden)(root)) return;
					let isReachEdge = false;
					const placeholderRect = (0, import_use$21.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 (0, import_vue$42.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 (0, import_vue$42.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 (0, import_vue$42.createVNode)("div", { "class": bem$36("loading") }, [slots.loading ? slots.loading() : (0, import_vue$42.createVNode)(import_loading$4.Loading, { "class": bem$36("loading-icon") }, { default: () => [props$1.loadingText || t$7("loading")] })]);
			};
			(0, import_vue$42.watch)(() => [
				props$1.loading,
				props$1.finished,
				props$1.error
			], check);
			if (tabStatus) (0, import_vue$42.watch)(tabStatus, (tabActive) => {
				if (tabActive) check();
			});
			(0, import_vue$42.onUpdated)(() => {
				loading.value = props$1.loading;
			});
			(0, import_vue$42.onMounted)(() => {
				if (props$1.immediateCheck) check();
			});
			(0, import_use_expose$8.useExpose)({ check });
			(0, import_use$21.useEventListener)("scroll", check, {
				target: scroller,
				passive: true
			});
			return () => {
				var _a;
				const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
				const Placeholder = (0, import_vue$42.createVNode)("div", {
					"ref": placeholder,
					"class": bem$36("placeholder")
				}, null);
				return (0, import_vue$42.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/lib/list/index.js
var require_list = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/list/index.js": ((exports, module) => {
	var __create$44 = Object.create;
	var __defProp$86 = Object.defineProperty;
	var __getOwnPropDesc$86 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$86 = Object.getOwnPropertyNames;
	var __getProtoOf$44 = Object.getPrototypeOf;
	var __hasOwnProp$86 = Object.prototype.hasOwnProperty;
	var __export$86 = (target, all) => {
		for (var name$111 in all) __defProp$86(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$86 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$86(from)) if (!__hasOwnProp$86.call(to, key) && key !== except) __defProp$86(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$86(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$44 = (mod, isNodeMode, target) => (target = mod != null ? __create$44(__getProtoOf$44(mod)) : {}, __copyProps$86(isNodeMode || !mod || !mod.__esModule ? __defProp$86(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$86 = (mod) => __copyProps$86(__defProp$86({}, "__esModule", { value: true }), mod);
	var stdin_exports$85 = {};
	__export$86(stdin_exports$85, {
		List: () => List,
		default: () => stdin_default$80,
		listProps: () => import_List2.listProps
	});
	module.exports = __toCommonJS$86(stdin_exports$85);
	var import_utils$79 = require_utils$9();
	var import_List = __toESM$44(require_List());
	var import_List2 = require_List();
	var List = (0, import_utils$79.withInstall)(import_List.default);
	var stdin_default$80 = List;
}) });

//#endregion
//#region node_modules/vant/lib/nav-bar/NavBar.js
var require_NavBar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/nav-bar/NavBar.js": ((exports, module) => {
	var __defProp$85 = Object.defineProperty;
	var __getOwnPropDesc$85 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$85 = Object.getOwnPropertyNames;
	var __hasOwnProp$85 = Object.prototype.hasOwnProperty;
	var __export$85 = (target, all) => {
		for (var name2 in all) __defProp$85(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$85 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$85(from)) if (!__hasOwnProp$85.call(to, key) && key !== except) __defProp$85(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$85(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$85 = (mod) => __copyProps$85(__defProp$85({}, "__esModule", { value: true }), mod);
	var stdin_exports$84 = {};
	__export$85(stdin_exports$84, {
		default: () => stdin_default$79,
		navBarProps: () => navBarProps
	});
	module.exports = __toCommonJS$85(stdin_exports$84);
	var import_vue$41 = require_vue();
	var import_utils$78 = require_utils$9();
	var import_use_placeholder$2 = require_use_placeholder();
	var import_icon$12 = require_icon();
	var [name$36, bem$35] = (0, import_utils$78.createNamespace)("nav-bar");
	var navBarProps = {
		title: String,
		fixed: Boolean,
		zIndex: import_utils$78.numericProp,
		border: import_utils$78.truthProp,
		leftText: String,
		rightText: String,
		leftDisabled: Boolean,
		rightDisabled: Boolean,
		leftArrow: Boolean,
		placeholder: Boolean,
		safeAreaInsetTop: Boolean,
		clickable: import_utils$78.truthProp
	};
	var stdin_default$79 = (0, import_vue$41.defineComponent)({
		name: name$36,
		props: navBarProps,
		emits: ["clickLeft", "clickRight"],
		setup(props$1, { emit, slots }) {
			const navBarRef = (0, import_vue$41.ref)();
			const renderPlaceholder = (0, import_use_placeholder$2.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 && (0, import_vue$41.createVNode)(import_icon$12.Icon, {
					"class": bem$35("arrow"),
					"name": "arrow-left"
				}, null), props$1.leftText && (0, import_vue$41.createVNode)("span", { "class": bem$35("text") }, [props$1.leftText])];
			};
			const renderRight = () => {
				if (slots.right) return slots.right();
				return (0, import_vue$41.createVNode)("span", { "class": bem$35("text") }, [props$1.rightText]);
			};
			const renderNavBar = () => {
				const { title, fixed, border, zIndex } = props$1;
				const style = (0, import_utils$78.getZIndexStyle)(zIndex);
				const hasLeft = props$1.leftArrow || props$1.leftText || slots.left;
				const hasRight = props$1.rightText || slots.right;
				return (0, import_vue$41.createVNode)("div", {
					"ref": navBarRef,
					"style": style,
					"class": [bem$35({ fixed }), {
						[import_utils$78.BORDER_BOTTOM]: border,
						"van-safe-area-top": props$1.safeAreaInsetTop
					}]
				}, [(0, import_vue$41.createVNode)("div", { "class": bem$35("content") }, [
					hasLeft && (0, import_vue$41.createVNode)("div", {
						"class": [bem$35("left", { disabled: props$1.leftDisabled }), props$1.clickable && !props$1.leftDisabled ? import_utils$78.HAPTICS_FEEDBACK : ""],
						"onClick": onClickLeft
					}, [renderLeft()]),
					(0, import_vue$41.createVNode)("div", { "class": [bem$35("title"), "van-ellipsis"] }, [slots.title ? slots.title() : title]),
					hasRight && (0, import_vue$41.createVNode)("div", {
						"class": [bem$35("right", { disabled: props$1.rightDisabled }), props$1.clickable && !props$1.rightDisabled ? import_utils$78.HAPTICS_FEEDBACK : ""],
						"onClick": onClickRight
					}, [renderRight()])
				])]);
			};
			return () => {
				if (props$1.fixed && props$1.placeholder) return renderPlaceholder(renderNavBar);
				return renderNavBar();
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/nav-bar/index.js
var require_nav_bar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/nav-bar/index.js": ((exports, module) => {
	var __create$43 = Object.create;
	var __defProp$84 = Object.defineProperty;
	var __getOwnPropDesc$84 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$84 = Object.getOwnPropertyNames;
	var __getProtoOf$43 = Object.getPrototypeOf;
	var __hasOwnProp$84 = Object.prototype.hasOwnProperty;
	var __export$84 = (target, all) => {
		for (var name$111 in all) __defProp$84(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$84 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$84(from)) if (!__hasOwnProp$84.call(to, key) && key !== except) __defProp$84(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$84(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$43 = (mod, isNodeMode, target) => (target = mod != null ? __create$43(__getProtoOf$43(mod)) : {}, __copyProps$84(isNodeMode || !mod || !mod.__esModule ? __defProp$84(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$84 = (mod) => __copyProps$84(__defProp$84({}, "__esModule", { value: true }), mod);
	var stdin_exports$83 = {};
	__export$84(stdin_exports$83, {
		NavBar: () => NavBar,
		default: () => stdin_default$78,
		navBarProps: () => import_NavBar2.navBarProps
	});
	module.exports = __toCommonJS$84(stdin_exports$83);
	var import_utils$77 = require_utils$9();
	var import_NavBar = __toESM$43(require_NavBar());
	var import_NavBar2 = require_NavBar();
	var NavBar = (0, import_utils$77.withInstall)(import_NavBar.default);
	var stdin_default$78 = NavBar;
}) });

//#endregion
//#region node_modules/vant/lib/notice-bar/NoticeBar.js
var require_NoticeBar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/notice-bar/NoticeBar.js": ((exports, module) => {
	var __defProp$83 = Object.defineProperty;
	var __getOwnPropDesc$83 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$83 = Object.getOwnPropertyNames;
	var __hasOwnProp$83 = Object.prototype.hasOwnProperty;
	var __export$83 = (target, all) => {
		for (var name2 in all) __defProp$83(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$83 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$83(from)) if (!__hasOwnProp$83.call(to, key) && key !== except) __defProp$83(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$83(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$83 = (mod) => __copyProps$83(__defProp$83({}, "__esModule", { value: true }), mod);
	var stdin_exports$82 = {};
	__export$83(stdin_exports$82, {
		default: () => stdin_default$77,
		noticeBarProps: () => noticeBarProps
	});
	module.exports = __toCommonJS$83(stdin_exports$82);
	var import_vue$40 = require_vue();
	var import_utils$76 = require_utils$9();
	var import_use$20 = require_index_cjs$1();
	var import_use_expose$7 = require_use_expose();
	var import_on_popup_reopen = require_on_popup_reopen();
	var import_icon$11 = require_icon();
	var [name$35, bem$34] = (0, import_utils$76.createNamespace)("notice-bar");
	var noticeBarProps = {
		text: String,
		mode: String,
		color: String,
		delay: (0, import_utils$76.makeNumericProp)(1),
		speed: (0, import_utils$76.makeNumericProp)(60),
		leftIcon: String,
		wrapable: Boolean,
		background: String,
		scrollable: {
			type: Boolean,
			default: null
		}
	};
	var stdin_default$77 = (0, import_vue$40.defineComponent)({
		name: name$35,
		props: noticeBarProps,
		emits: ["close", "replay"],
		setup(props$1, { emit, slots }) {
			let wrapWidth = 0;
			let contentWidth = 0;
			let startTimer;
			const wrapRef = (0, import_vue$40.ref)();
			const contentRef = (0, import_vue$40.ref)();
			const state = (0, import_vue$40.reactive)({
				show: true,
				offset: 0,
				duration: 0
			});
			const renderLeftIcon = () => {
				if (slots["left-icon"]) return slots["left-icon"]();
				if (props$1.leftIcon) return (0, import_vue$40.createVNode)(import_icon$11.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 (0, import_vue$40.createVNode)(import_icon$11.Icon, {
					"name": name2,
					"class": bem$34("right-icon"),
					"onClick": onClickRightIcon
				}, null);
			};
			const onTransitionEnd = () => {
				state.offset = wrapWidth;
				state.duration = 0;
				(0, import_use$20.raf)(() => {
					(0, import_use$20.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 (0, import_vue$40.createVNode)("div", {
					"ref": wrapRef,
					"role": "marquee",
					"class": bem$34("wrap")
				}, [(0, import_vue$40.createVNode)("div", {
					"ref": contentRef,
					"style": style,
					"class": [bem$34("content"), { "van-ellipsis": ellipsis }],
					"onTransitionend": onTransitionEnd
				}, [slots.default ? slots.default() : props$1.text])]);
			};
			const reset$1 = () => {
				const { delay, speed, scrollable } = props$1;
				const ms = (0, import_utils$76.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 = (0, import_use$20.useRect)(wrapRef).width;
					const contentRefWidth = (0, import_use$20.useRect)(contentRef).width;
					if (scrollable || contentRefWidth > wrapRefWidth) (0, import_use$20.doubleRaf)(() => {
						wrapWidth = wrapRefWidth;
						contentWidth = contentRefWidth;
						state.offset = -contentWidth;
						state.duration = contentWidth / +speed;
					});
				}, ms);
			};
			(0, import_on_popup_reopen.onPopupReopen)(reset$1);
			(0, import_use$20.onMountedOrActivated)(reset$1);
			(0, import_use$20.useEventListener)("pageshow", reset$1);
			(0, import_use_expose$7.useExpose)({ reset: reset$1 });
			(0, import_vue$40.watch)(() => [props$1.text, props$1.scrollable], reset$1);
			return () => {
				const { color, wrapable, background } = props$1;
				return (0, import_vue$40.withDirectives)((0, import_vue$40.createVNode)("div", {
					"role": "alert",
					"class": bem$34({ wrapable }),
					"style": {
						color,
						background
					}
				}, [
					renderLeftIcon(),
					renderMarquee(),
					renderRightIcon()
				]), [[import_vue$40.vShow, state.show]]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/notice-bar/index.js
var require_notice_bar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/notice-bar/index.js": ((exports, module) => {
	var __create$42 = Object.create;
	var __defProp$82 = Object.defineProperty;
	var __getOwnPropDesc$82 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$82 = Object.getOwnPropertyNames;
	var __getProtoOf$42 = Object.getPrototypeOf;
	var __hasOwnProp$82 = Object.prototype.hasOwnProperty;
	var __export$82 = (target, all) => {
		for (var name$111 in all) __defProp$82(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$82 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$82(from)) if (!__hasOwnProp$82.call(to, key) && key !== except) __defProp$82(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$82(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$42 = (mod, isNodeMode, target) => (target = mod != null ? __create$42(__getProtoOf$42(mod)) : {}, __copyProps$82(isNodeMode || !mod || !mod.__esModule ? __defProp$82(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$82 = (mod) => __copyProps$82(__defProp$82({}, "__esModule", { value: true }), mod);
	var stdin_exports$81 = {};
	__export$82(stdin_exports$81, {
		NoticeBar: () => NoticeBar,
		default: () => stdin_default$76,
		noticeBarProps: () => import_NoticeBar2.noticeBarProps
	});
	module.exports = __toCommonJS$82(stdin_exports$81);
	var import_utils$75 = require_utils$9();
	var import_NoticeBar = __toESM$42(require_NoticeBar());
	var import_NoticeBar2 = require_NoticeBar();
	var NoticeBar = (0, import_utils$75.withInstall)(import_NoticeBar.default);
	var stdin_default$76 = NoticeBar;
}) });

//#endregion
//#region node_modules/vant/lib/notify/Notify.js
var require_Notify = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/notify/Notify.js": ((exports, module) => {
	var __defProp$81 = Object.defineProperty;
	var __getOwnPropDesc$81 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$81 = Object.getOwnPropertyNames;
	var __hasOwnProp$81 = Object.prototype.hasOwnProperty;
	var __export$81 = (target, all) => {
		for (var name2 in all) __defProp$81(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$81 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$81(from)) if (!__hasOwnProp$81.call(to, key) && key !== except) __defProp$81(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$81(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$81 = (mod) => __copyProps$81(__defProp$81({}, "__esModule", { value: true }), mod);
	var stdin_exports$80 = {};
	__export$81(stdin_exports$80, {
		default: () => stdin_default$75,
		notifyProps: () => notifyProps
	});
	module.exports = __toCommonJS$81(stdin_exports$80);
	var import_vue$39 = require_vue();
	var import_utils$74 = require_utils$9();
	var import_popup$3 = require_popup();
	var import_shared$1 = require_shared();
	var [name$34, bem$33] = (0, import_utils$74.createNamespace)("notify");
	var popupInheritProps = [
		"lockScroll",
		"position",
		"show",
		"teleport",
		"zIndex"
	];
	var notifyProps = (0, import_utils$74.extend)({}, import_shared$1.popupSharedProps, {
		type: (0, import_utils$74.makeStringProp)("danger"),
		color: String,
		message: import_utils$74.numericProp,
		position: (0, import_utils$74.makeStringProp)("top"),
		className: import_utils$74.unknownProp,
		background: String,
		lockScroll: Boolean
	});
	var stdin_default$75 = (0, import_vue$39.defineComponent)({
		name: name$34,
		props: notifyProps,
		emits: ["update:show"],
		setup(props$1, { emit, slots }) {
			const updateShow = (show) => emit("update:show", show);
			return () => (0, import_vue$39.createVNode)(import_popup$3.Popup, (0, import_vue$39.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
			}, (0, import_utils$74.pick)(props$1, popupInheritProps)), { default: () => [slots.default ? slots.default() : props$1.message] });
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/notify/function-call.js
var require_function_call = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/notify/function-call.js": ((exports, module) => {
	var __create$41 = Object.create;
	var __defProp$80 = Object.defineProperty;
	var __getOwnPropDesc$80 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$80 = Object.getOwnPropertyNames;
	var __getProtoOf$41 = Object.getPrototypeOf;
	var __hasOwnProp$80 = Object.prototype.hasOwnProperty;
	var __export$80 = (target, all) => {
		for (var name$111 in all) __defProp$80(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$80 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$80(from)) if (!__hasOwnProp$80.call(to, key) && key !== except) __defProp$80(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$80(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$41 = (mod, isNodeMode, target) => (target = mod != null ? __create$41(__getProtoOf$41(mod)) : {}, __copyProps$80(isNodeMode || !mod || !mod.__esModule ? __defProp$80(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$80 = (mod) => __copyProps$80(__defProp$80({}, "__esModule", { value: true }), mod);
	var stdin_exports$79 = {};
	__export$80(stdin_exports$79, {
		closeNotify: () => closeNotify,
		resetNotifyDefaultOptions: () => resetNotifyDefaultOptions,
		setNotifyDefaultOptions: () => setNotifyDefaultOptions,
		showNotify: () => showNotify
	});
	module.exports = __toCommonJS$80(stdin_exports$79);
	var import_vue$38 = require_vue();
	var import_utils$73 = require_utils$9();
	var import_mount_component = require_mount_component();
	var import_Notify$1 = __toESM$41(require_Notify());
	var timer;
	var instance;
	var parseOptions = (message) => (0, import_utils$73.isObject)(message) ? message : { message };
	function initInstance() {
		({instance} = (0, import_mount_component.mountComponent)({ setup() {
			const { state, toggle } = (0, import_mount_component.usePopupState)();
			return () => (0, import_vue$38.createVNode)(import_Notify$1.default, (0, import_vue$38.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 (!import_utils$73.inBrowser) return;
		if (!instance) initInstance();
		options = (0, import_utils$73.extend)({}, currentOptions, parseOptions(options));
		instance.open(options);
		clearTimeout(timer);
		if (options.duration > 0) timer = setTimeout(closeNotify, options.duration);
		return instance;
	}
	var setNotifyDefaultOptions = (options) => (0, import_utils$73.extend)(currentOptions, options);
	var resetNotifyDefaultOptions = () => {
		currentOptions = getDefaultOptions();
	};
}) });

//#endregion
//#region node_modules/vant/lib/notify/index.js
var require_notify = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/notify/index.js": ((exports, module) => {
	var __create$40 = Object.create;
	var __defProp$79 = Object.defineProperty;
	var __getOwnPropDesc$79 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$79 = Object.getOwnPropertyNames;
	var __getProtoOf$40 = Object.getPrototypeOf;
	var __hasOwnProp$79 = Object.prototype.hasOwnProperty;
	var __export$79 = (target, all) => {
		for (var name$111 in all) __defProp$79(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$79 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$79(from)) if (!__hasOwnProp$79.call(to, key) && key !== except) __defProp$79(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$79(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$40 = (mod, isNodeMode, target) => (target = mod != null ? __create$40(__getProtoOf$40(mod)) : {}, __copyProps$79(isNodeMode || !mod || !mod.__esModule ? __defProp$79(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$79 = (mod) => __copyProps$79(__defProp$79({}, "__esModule", { value: true }), mod);
	var stdin_exports$78 = {};
	__export$79(stdin_exports$78, {
		Notify: () => Notify,
		closeNotify: () => import_function_call.closeNotify,
		default: () => stdin_default$74,
		notifyProps: () => import_Notify2.notifyProps,
		resetNotifyDefaultOptions: () => import_function_call.resetNotifyDefaultOptions,
		setNotifyDefaultOptions: () => import_function_call.setNotifyDefaultOptions,
		showNotify: () => import_function_call.showNotify
	});
	module.exports = __toCommonJS$79(stdin_exports$78);
	var import_utils$72 = require_utils$9();
	var import_Notify = __toESM$40(require_Notify());
	var import_Notify2 = require_Notify();
	var import_function_call = require_function_call();
	var Notify = (0, import_utils$72.withInstall)(import_Notify.default);
	var stdin_default$74 = Notify;
}) });

//#endregion
//#region node_modules/vant/lib/number-keyboard/NumberKeyboardKey.js
var require_NumberKeyboardKey = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/number-keyboard/NumberKeyboardKey.js": ((exports, module) => {
	var __defProp$78 = Object.defineProperty;
	var __getOwnPropDesc$78 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$78 = Object.getOwnPropertyNames;
	var __hasOwnProp$78 = Object.prototype.hasOwnProperty;
	var __export$78 = (target, all) => {
		for (var name2 in all) __defProp$78(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$78 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$78(from)) if (!__hasOwnProp$78.call(to, key) && key !== except) __defProp$78(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$78(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$78 = (mod) => __copyProps$78(__defProp$78({}, "__esModule", { value: true }), mod);
	var stdin_exports$77 = {};
	__export$78(stdin_exports$77, { default: () => stdin_default$73 });
	module.exports = __toCommonJS$78(stdin_exports$77);
	var import_vue$37 = require_vue();
	var import_utils$71 = require_utils$9();
	var import_use_touch$4 = require_use_touch();
	var import_loading$3 = require_loading();
	var [name$33, bem$32] = (0, import_utils$71.createNamespace)("key");
	var CollapseIcon = (0, import_vue$37.createVNode)("svg", {
		"class": bem$32("collapse-icon"),
		"viewBox": "0 0 30 24"
	}, [(0, import_vue$37.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 = (0, import_vue$37.createVNode)("svg", {
		"class": bem$32("delete-icon"),
		"viewBox": "0 0 32 22"
	}, [(0, import_vue$37.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$73 = (0, import_vue$37.defineComponent)({
		name: name$33,
		props: {
			type: String,
			text: import_utils$71.numericProp,
			color: String,
			wider: Boolean,
			large: Boolean,
			loading: Boolean
		},
		emits: ["press"],
		setup(props$1, { emit, slots }) {
			const active = (0, import_vue$37.ref)(false);
			const touch = (0, import_use_touch$4.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) (0, import_utils$71.preventDefault)(event);
					active.value = false;
					emit("press", props$1.text, props$1.type);
				}
			};
			const renderContent = () => {
				if (props$1.loading) return (0, import_vue$37.createVNode)(import_loading$3.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 () => (0, import_vue$37.createVNode)("div", {
				"class": bem$32("wrapper", { wider: props$1.wider }),
				"onTouchstartPassive": onTouchStart,
				"onTouchmovePassive": onTouchMove,
				"onTouchend": onTouchEnd,
				"onTouchcancel": onTouchEnd
			}, [(0, import_vue$37.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/lib/number-keyboard/NumberKeyboard.js
var require_NumberKeyboard = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/number-keyboard/NumberKeyboard.js": ((exports, module) => {
	var __create$39 = Object.create;
	var __defProp$77 = Object.defineProperty;
	var __getOwnPropDesc$77 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$77 = Object.getOwnPropertyNames;
	var __getProtoOf$39 = Object.getPrototypeOf;
	var __hasOwnProp$77 = Object.prototype.hasOwnProperty;
	var __export$77 = (target, all) => {
		for (var name2 in all) __defProp$77(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$77 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$77(from)) if (!__hasOwnProp$77.call(to, key) && key !== except) __defProp$77(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$77(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$39 = (mod, isNodeMode, target) => (target = mod != null ? __create$39(__getProtoOf$39(mod)) : {}, __copyProps$77(isNodeMode || !mod || !mod.__esModule ? __defProp$77(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$77 = (mod) => __copyProps$77(__defProp$77({}, "__esModule", { value: true }), mod);
	var stdin_exports$76 = {};
	__export$77(stdin_exports$76, {
		default: () => stdin_default$72,
		numberKeyboardProps: () => numberKeyboardProps
	});
	module.exports = __toCommonJS$77(stdin_exports$76);
	var import_vue$36 = require_vue();
	var import_utils$70 = require_utils$9();
	var import_use$19 = require_index_cjs$1();
	var import_NumberKeyboardKey = __toESM$39(require_NumberKeyboardKey());
	var [name$32, bem$31] = (0, import_utils$70.createNamespace)("number-keyboard");
	var numberKeyboardProps = {
		show: Boolean,
		title: String,
		theme: (0, import_utils$70.makeStringProp)("default"),
		zIndex: import_utils$70.numericProp,
		teleport: [String, Object],
		maxlength: (0, import_utils$70.makeNumericProp)(Infinity),
		modelValue: (0, import_utils$70.makeStringProp)(""),
		transition: import_utils$70.truthProp,
		blurOnClose: import_utils$70.truthProp,
		showDeleteKey: import_utils$70.truthProp,
		randomKeyOrder: Boolean,
		closeButtonText: String,
		deleteButtonText: String,
		closeButtonLoading: Boolean,
		hideOnClickOutside: import_utils$70.truthProp,
		safeAreaInsetBottom: import_utils$70.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$72 = (0, import_vue$36.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 = (0, import_vue$36.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 = (0, import_vue$36.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 (0, import_vue$36.createVNode)("div", { "class": bem$31("header") }, [
					leftSlot && (0, import_vue$36.createVNode)("span", { "class": bem$31("title-left") }, [leftSlot()]),
					title && (0, import_vue$36.createVNode)("h2", { "class": bem$31("title") }, [title]),
					showClose && (0, import_vue$36.createVNode)("button", {
						"type": "button",
						"class": [bem$31("close"), import_utils$70.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 (0, import_vue$36.createVNode)(import_NumberKeyboardKey.default, {
					"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 (0, import_vue$36.createVNode)("div", { "class": bem$31("sidebar") }, [props$1.showDeleteKey && (0, import_vue$36.createVNode)(import_NumberKeyboardKey.default, {
					"large": true,
					"text": props$1.deleteButtonText,
					"type": "delete",
					"onPress": onPress
				}, { default: slots.delete }), (0, import_vue$36.createVNode)(import_NumberKeyboardKey.default, {
					"large": true,
					"text": props$1.closeButtonText,
					"type": "close",
					"color": "blue",
					"loading": props$1.closeButtonLoading,
					"onPress": onPress
				}, null)]);
			};
			(0, import_vue$36.watch)(() => props$1.show, (value) => {
				if (!props$1.transition) emit(value ? "show" : "hide");
			});
			if (props$1.hideOnClickOutside) (0, import_use$19.useClickAway)(root, onBlur, { eventName: "touchstart" });
			return () => {
				const Title = renderTitle();
				const Content = (0, import_vue$36.createVNode)(import_vue$36.Transition, { "name": props$1.transition ? "van-slide-up" : "" }, { default: () => [(0, import_vue$36.withDirectives)((0, import_vue$36.createVNode)("div", (0, import_vue$36.mergeProps)({
					"ref": root,
					"style": (0, import_utils$70.getZIndexStyle)(props$1.zIndex),
					"class": bem$31({
						unfit: !props$1.safeAreaInsetBottom,
						"with-title": !!Title
					}),
					"onAnimationend": onAnimationEnd,
					"onTouchstartPassive": import_utils$70.stopPropagation
				}, attrs), [Title, (0, import_vue$36.createVNode)("div", { "class": bem$31("body") }, [(0, import_vue$36.createVNode)("div", { "class": bem$31("keys") }, [renderKeys()]), renderSidebar()])]), [[import_vue$36.vShow, props$1.show]])] });
				if (props$1.teleport) return (0, import_vue$36.createVNode)(import_vue$36.Teleport, { "to": props$1.teleport }, { default: () => [Content] });
				return Content;
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/number-keyboard/index.js
var require_number_keyboard = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/number-keyboard/index.js": ((exports, module) => {
	var __create$38 = Object.create;
	var __defProp$76 = Object.defineProperty;
	var __getOwnPropDesc$76 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$76 = Object.getOwnPropertyNames;
	var __getProtoOf$38 = Object.getPrototypeOf;
	var __hasOwnProp$76 = Object.prototype.hasOwnProperty;
	var __export$76 = (target, all) => {
		for (var name$111 in all) __defProp$76(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$76 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$76(from)) if (!__hasOwnProp$76.call(to, key) && key !== except) __defProp$76(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$76(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$38 = (mod, isNodeMode, target) => (target = mod != null ? __create$38(__getProtoOf$38(mod)) : {}, __copyProps$76(isNodeMode || !mod || !mod.__esModule ? __defProp$76(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$76 = (mod) => __copyProps$76(__defProp$76({}, "__esModule", { value: true }), mod);
	var stdin_exports$75 = {};
	__export$76(stdin_exports$75, {
		NumberKeyboard: () => NumberKeyboard,
		default: () => stdin_default$71,
		numberKeyboardProps: () => import_NumberKeyboard2.numberKeyboardProps
	});
	module.exports = __toCommonJS$76(stdin_exports$75);
	var import_utils$69 = require_utils$9();
	var import_NumberKeyboard = __toESM$38(require_NumberKeyboard());
	var import_NumberKeyboard2 = require_NumberKeyboard();
	var NumberKeyboard = (0, import_utils$69.withInstall)(import_NumberKeyboard.default);
	var stdin_default$71 = NumberKeyboard;
}) });

//#endregion
//#region node_modules/vant/lib/pagination/Pagination.js
var require_Pagination = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/pagination/Pagination.js": ((exports, module) => {
	var __defProp$75 = Object.defineProperty;
	var __getOwnPropDesc$75 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$75 = Object.getOwnPropertyNames;
	var __hasOwnProp$75 = Object.prototype.hasOwnProperty;
	var __export$75 = (target, all) => {
		for (var name2 in all) __defProp$75(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$75 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$75(from)) if (!__hasOwnProp$75.call(to, key) && key !== except) __defProp$75(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$75(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$75 = (mod) => __copyProps$75(__defProp$75({}, "__esModule", { value: true }), mod);
	var stdin_exports$74 = {};
	__export$75(stdin_exports$74, {
		default: () => stdin_default$70,
		paginationProps: () => paginationProps
	});
	module.exports = __toCommonJS$75(stdin_exports$74);
	var import_vue$35 = require_vue();
	var import_utils$68 = require_utils$9();
	var [name$31, bem$30, t$6] = (0, import_utils$68.createNamespace)("pagination");
	var makePage = (number, text, active) => ({
		number,
		text,
		active
	});
	var paginationProps = {
		mode: (0, import_utils$68.makeStringProp)("multi"),
		prevText: String,
		nextText: String,
		pageCount: (0, import_utils$68.makeNumericProp)(0),
		modelValue: (0, import_utils$68.makeNumberProp)(0),
		totalItems: (0, import_utils$68.makeNumericProp)(0),
		showPageSize: (0, import_utils$68.makeNumericProp)(5),
		itemsPerPage: (0, import_utils$68.makeNumericProp)(10),
		forceEllipses: Boolean,
		showPrevButton: import_utils$68.truthProp,
		showNextButton: import_utils$68.truthProp
	};
	var stdin_default$70 = (0, import_vue$35.defineComponent)({
		name: name$31,
		props: paginationProps,
		emits: ["change", "update:modelValue"],
		setup(props$1, { emit, slots }) {
			const count = (0, import_vue$35.computed)(() => {
				const { pageCount, totalItems, itemsPerPage } = props$1;
				const count2 = +pageCount || Math.ceil(+totalItems / +itemsPerPage);
				return Math.max(1, count2);
			});
			const pages = (0, import_vue$35.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 = (0, import_utils$68.clamp)(value, 1, count.value);
				if (props$1.modelValue !== value) {
					emit("update:modelValue", value);
					if (emitChange) emit("change", value);
				}
			};
			(0, import_vue$35.watchEffect)(() => updateModelValue(props$1.modelValue));
			const renderDesc = () => (0, import_vue$35.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 (0, import_vue$35.createVNode)("li", { "class": [bem$30("item", {
					disabled,
					border: mode === "simple",
					prev: true
				}), import_utils$68.BORDER_SURROUND] }, [(0, import_vue$35.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 (0, import_vue$35.createVNode)("li", { "class": [bem$30("item", {
					disabled,
					border: mode === "simple",
					next: true
				}), import_utils$68.BORDER_SURROUND] }, [(0, import_vue$35.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) => (0, import_vue$35.createVNode)("li", { "class": [bem$30("item", {
				active: page.active,
				page: true
			}), import_utils$68.BORDER_SURROUND] }, [(0, import_vue$35.createVNode)("button", {
				"type": "button",
				"aria-current": page.active || void 0,
				"onClick": () => updateModelValue(page.number, true)
			}, [slots.page ? slots.page(page) : page.text])]));
			return () => (0, import_vue$35.createVNode)("nav", {
				"role": "navigation",
				"class": bem$30()
			}, [(0, import_vue$35.createVNode)("ul", { "class": bem$30("items") }, [
				renderPrevButton(),
				props$1.mode === "simple" ? renderDesc() : renderPages(),
				renderNextButton()
			])]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/pagination/index.js
var require_pagination = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/pagination/index.js": ((exports, module) => {
	var __create$37 = Object.create;
	var __defProp$74 = Object.defineProperty;
	var __getOwnPropDesc$74 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$74 = Object.getOwnPropertyNames;
	var __getProtoOf$37 = Object.getPrototypeOf;
	var __hasOwnProp$74 = Object.prototype.hasOwnProperty;
	var __export$74 = (target, all) => {
		for (var name$111 in all) __defProp$74(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$74 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$74(from)) if (!__hasOwnProp$74.call(to, key) && key !== except) __defProp$74(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$74(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$37 = (mod, isNodeMode, target) => (target = mod != null ? __create$37(__getProtoOf$37(mod)) : {}, __copyProps$74(isNodeMode || !mod || !mod.__esModule ? __defProp$74(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$74 = (mod) => __copyProps$74(__defProp$74({}, "__esModule", { value: true }), mod);
	var stdin_exports$73 = {};
	__export$74(stdin_exports$73, {
		Pagination: () => Pagination,
		default: () => stdin_default$69,
		paginationProps: () => import_Pagination2.paginationProps
	});
	module.exports = __toCommonJS$74(stdin_exports$73);
	var import_utils$67 = require_utils$9();
	var import_Pagination = __toESM$37(require_Pagination());
	var import_Pagination2 = require_Pagination();
	var Pagination = (0, import_utils$67.withInstall)(import_Pagination.default);
	var stdin_default$69 = Pagination;
}) });

//#endregion
//#region node_modules/vant/lib/password-input/PasswordInput.js
var require_PasswordInput = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/password-input/PasswordInput.js": ((exports, module) => {
	var __defProp$73 = Object.defineProperty;
	var __getOwnPropDesc$73 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$73 = Object.getOwnPropertyNames;
	var __hasOwnProp$73 = Object.prototype.hasOwnProperty;
	var __export$73 = (target, all) => {
		for (var name2 in all) __defProp$73(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$73 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$73(from)) if (!__hasOwnProp$73.call(to, key) && key !== except) __defProp$73(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$73(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$73 = (mod) => __copyProps$73(__defProp$73({}, "__esModule", { value: true }), mod);
	var stdin_exports$72 = {};
	__export$73(stdin_exports$72, {
		default: () => stdin_default$68,
		passwordInputProps: () => passwordInputProps
	});
	module.exports = __toCommonJS$73(stdin_exports$72);
	var import_vue$34 = require_vue();
	var import_utils$66 = require_utils$9();
	var [name$30, bem$29] = (0, import_utils$66.createNamespace)("password-input");
	var passwordInputProps = {
		info: String,
		mask: import_utils$66.truthProp,
		value: (0, import_utils$66.makeStringProp)(""),
		gutter: import_utils$66.numericProp,
		length: (0, import_utils$66.makeNumericProp)(6),
		focused: Boolean,
		errorInfo: String
	};
	var stdin_default$68 = (0, import_vue$34.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: (0, import_utils$66.addUnit)(gutter) };
					Points.push((0, import_vue$34.createVNode)("li", {
						"class": [{ [import_utils$66.BORDER_LEFT]: showBorder }, bem$29("item", { focus: showCursor })],
						"style": style
					}, [mask ? (0, import_vue$34.createVNode)("i", { "style": { visibility: char ? "visible" : "hidden" } }, null) : char, showCursor && (0, import_vue$34.createVNode)("div", { "class": bem$29("cursor") }, null)]));
				}
				return Points;
			};
			return () => {
				const info = props$1.errorInfo || props$1.info;
				return (0, import_vue$34.createVNode)("div", { "class": bem$29() }, [(0, import_vue$34.createVNode)("ul", {
					"class": [bem$29("security"), { [import_utils$66.BORDER_SURROUND]: !props$1.gutter }],
					"onTouchstartPassive": onTouchStart
				}, [renderPoints()]), info && (0, import_vue$34.createVNode)("div", { "class": bem$29(props$1.errorInfo ? "error-info" : "info") }, [info])]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/password-input/index.js
var require_password_input = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/password-input/index.js": ((exports, module) => {
	var __create$36 = Object.create;
	var __defProp$72 = Object.defineProperty;
	var __getOwnPropDesc$72 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$72 = Object.getOwnPropertyNames;
	var __getProtoOf$36 = Object.getPrototypeOf;
	var __hasOwnProp$72 = Object.prototype.hasOwnProperty;
	var __export$72 = (target, all) => {
		for (var name$111 in all) __defProp$72(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$72 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$72(from)) if (!__hasOwnProp$72.call(to, key) && key !== except) __defProp$72(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$72(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$36 = (mod, isNodeMode, target) => (target = mod != null ? __create$36(__getProtoOf$36(mod)) : {}, __copyProps$72(isNodeMode || !mod || !mod.__esModule ? __defProp$72(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$72 = (mod) => __copyProps$72(__defProp$72({}, "__esModule", { value: true }), mod);
	var stdin_exports$71 = {};
	__export$72(stdin_exports$71, {
		PasswordInput: () => PasswordInput,
		default: () => stdin_default$67,
		passwordInputProps: () => import_PasswordInput2.passwordInputProps
	});
	module.exports = __toCommonJS$72(stdin_exports$71);
	var import_utils$65 = require_utils$9();
	var import_PasswordInput = __toESM$36(require_PasswordInput());
	var import_PasswordInput2 = require_PasswordInput();
	var PasswordInput = (0, import_utils$65.withInstall)(import_PasswordInput.default);
	var stdin_default$67 = PasswordInput;
}) });

//#endregion
//#region node_modules/vant/lib/picker-group/index.js
var require_picker_group = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/picker-group/index.js": ((exports, module) => {
	var __create$35 = Object.create;
	var __defProp$71 = Object.defineProperty;
	var __getOwnPropDesc$71 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$71 = Object.getOwnPropertyNames;
	var __getProtoOf$35 = Object.getPrototypeOf;
	var __hasOwnProp$71 = Object.prototype.hasOwnProperty;
	var __export$71 = (target, all) => {
		for (var name$111 in all) __defProp$71(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$71 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$71(from)) if (!__hasOwnProp$71.call(to, key) && key !== except) __defProp$71(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$71(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$35 = (mod, isNodeMode, target) => (target = mod != null ? __create$35(__getProtoOf$35(mod)) : {}, __copyProps$71(isNodeMode || !mod || !mod.__esModule ? __defProp$71(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$71 = (mod) => __copyProps$71(__defProp$71({}, "__esModule", { value: true }), mod);
	var stdin_exports$70 = {};
	__export$71(stdin_exports$70, {
		PickerGroup: () => PickerGroup,
		default: () => stdin_default$66,
		pickerGroupProps: () => import_PickerGroup2.pickerGroupProps
	});
	module.exports = __toCommonJS$71(stdin_exports$70);
	var import_utils$64 = require_utils$9();
	var import_PickerGroup = __toESM$35(require_PickerGroup());
	var import_PickerGroup2 = require_PickerGroup();
	var PickerGroup = (0, import_utils$64.withInstall)(import_PickerGroup.default);
	var stdin_default$66 = PickerGroup;
}) });

//#endregion
//#region node_modules/@vant/popperjs/dist/index.cjs.js
var require_index_cjs = /* @__PURE__ */ __commonJS({ "node_modules/@vant/popperjs/dist/index.cjs.js": ((exports, module) => {
	var __defProp$70 = Object.defineProperty;
	var __getOwnPropDesc$70 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$70 = Object.getOwnPropertyNames;
	var __hasOwnProp$70 = Object.prototype.hasOwnProperty;
	var __export$70 = (target, all) => {
		for (var name$111 in all) __defProp$70(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$70 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$70(from)) if (!__hasOwnProp$70.call(to, key) && key !== except) __defProp$70(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$70(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$70 = (mod) => __copyProps$70(__defProp$70({}, "__esModule", { value: true }), mod);
	var src_exports = {};
	__export$70(src_exports, {
		createPopper: () => createPopper,
		offsetModifier: () => offset_default
	});
	module.exports = __toCommonJS$70(src_exports);
	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(node) {
		if ([
			"html",
			"body",
			"#document"
		].indexOf(getNodeName(node)) >= 0) return node.ownerDocument.body;
		if (isHTMLElement(node) && isScrollParent(node)) return node;
		return getScrollParent(getParentNode(node));
	}
	function listScrollParents(element, list) {
		var _element$ownerDocumen;
		if (list === void 0) list = [];
		var scrollParent = getScrollParent(element);
		var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
		var win = getWindow(scrollParent);
		var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
		var updatedList = list.concat(target);
		return isBody ? updatedList : 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/lib/popover/Popover.js
var require_Popover = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/popover/Popover.js": ((exports, module) => {
	var __defProp$69 = Object.defineProperty;
	var __getOwnPropDesc$69 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$69 = Object.getOwnPropertyNames;
	var __hasOwnProp$69 = Object.prototype.hasOwnProperty;
	var __export$69 = (target, all) => {
		for (var name2 in all) __defProp$69(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$69 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$69(from)) if (!__hasOwnProp$69.call(to, key) && key !== except) __defProp$69(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$69(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$69 = (mod) => __copyProps$69(__defProp$69({}, "__esModule", { value: true }), mod);
	var stdin_exports$69 = {};
	__export$69(stdin_exports$69, {
		default: () => stdin_default$65,
		popoverProps: () => popoverProps
	});
	module.exports = __toCommonJS$69(stdin_exports$69);
	var import_vue$33 = require_vue();
	var import_popperjs = require_index_cjs();
	var import_utils$63 = require_utils$9();
	var import_use$18 = require_index_cjs$1();
	var import_use_scope_id = require_use_scope_id();
	var import_use_sync_prop_ref = require_use_sync_prop_ref();
	var import_icon$10 = require_icon();
	var import_popup$2 = require_popup();
	var [name$29, bem$28] = (0, import_utils$63.createNamespace)("popover");
	var popupProps = [
		"overlay",
		"duration",
		"teleport",
		"overlayStyle",
		"overlayClass",
		"closeOnClickOverlay"
	];
	var popoverProps = {
		show: Boolean,
		theme: (0, import_utils$63.makeStringProp)("light"),
		overlay: Boolean,
		actions: (0, import_utils$63.makeArrayProp)(),
		actionsDirection: (0, import_utils$63.makeStringProp)("vertical"),
		trigger: (0, import_utils$63.makeStringProp)("click"),
		duration: import_utils$63.numericProp,
		showArrow: import_utils$63.truthProp,
		placement: (0, import_utils$63.makeStringProp)("bottom"),
		iconPrefix: String,
		overlayClass: import_utils$63.unknownProp,
		overlayStyle: Object,
		closeOnClickAction: import_utils$63.truthProp,
		closeOnClickOverlay: import_utils$63.truthProp,
		closeOnClickOutside: import_utils$63.truthProp,
		offset: {
			type: Array,
			default: () => [0, 8]
		},
		teleport: {
			type: [String, Object],
			default: "body"
		}
	};
	var stdin_default$65 = (0, import_vue$33.defineComponent)({
		name: name$29,
		props: popoverProps,
		emits: [
			"select",
			"touchstart",
			"update:show"
		],
		setup(props$1, { emit, slots, attrs }) {
			let popper;
			const popupRef = (0, import_vue$33.ref)();
			const wrapperRef = (0, import_vue$33.ref)();
			const popoverRef = (0, import_vue$33.ref)();
			const show = (0, import_use_sync_prop_ref.useSyncPropRef)(() => props$1.show, (value) => emit("update:show", value));
			const getPopoverOptions = () => ({
				placement: props$1.placement,
				modifiers: [{
					name: "computeStyles",
					options: {
						adaptive: false,
						gpuAcceleration: false
					}
				}, (0, import_utils$63.extend)({}, import_popperjs.offsetModifier, { options: { offset: props$1.offset } })]
			});
			const createPopperInstance = () => {
				if (wrapperRef.value && popoverRef.value) return (0, import_popperjs.createPopper)(wrapperRef.value, popoverRef.value.popupRef.value, getPopoverOptions());
				return null;
			};
			const updateLocation = () => {
				(0, import_vue$33.nextTick)(() => {
					if (!show.value) return;
					if (!popper) {
						popper = createPopperInstance();
						if (import_utils$63.inBrowser) {
							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 && (0, import_vue$33.createVNode)(import_icon$10.Icon, {
					"name": action.icon,
					"classPrefix": props$1.iconPrefix,
					"class": bem$28("action-icon")
				}, null), (0, import_vue$33.createVNode)("div", { "class": [bem$28("action-text"), { [import_utils$63.BORDER_BOTTOM]: props$1.actionsDirection === "vertical" }] }, [action.text])];
			};
			const renderAction = (action, index) => {
				const { icon, color, disabled, className } = action;
				return (0, import_vue$33.createVNode)("div", {
					"role": "menuitem",
					"class": [
						bem$28("action", {
							disabled,
							"with-icon": icon
						}),
						{ [import_utils$63.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)]);
			};
			(0, import_vue$33.onMounted)(() => {
				updateLocation();
				(0, import_vue$33.watchEffect)(() => {
					var _a;
					popupRef.value = (_a = popoverRef.value) == null ? void 0 : _a.popupRef.value;
				});
			});
			(0, import_vue$33.onBeforeUnmount)(() => {
				if (popper) {
					if (import_utils$63.inBrowser) {
						window.removeEventListener("animationend", updateLocation);
						window.removeEventListener("transitionend", updateLocation);
					}
					popper.destroy();
					popper = null;
				}
			});
			(0, import_vue$33.watch)(() => [
				show.value,
				props$1.offset,
				props$1.placement
			], updateLocation);
			(0, import_use$18.useClickAway)([wrapperRef, popupRef], onClickAway, { eventName: "touchstart" });
			return () => {
				var _a;
				return (0, import_vue$33.createVNode)(import_vue$33.Fragment, null, [(0, import_vue$33.createVNode)("span", {
					"ref": wrapperRef,
					"class": bem$28("wrapper"),
					"onClick": onClickWrapper
				}, [(_a = slots.reference) == null ? void 0 : _a.call(slots)]), (0, import_vue$33.createVNode)(import_popup$2.Popup, (0, import_vue$33.mergeProps)({
					"ref": popoverRef,
					"show": show.value,
					"class": bem$28([props$1.theme]),
					"position": "",
					"transition": "van-popover-zoom",
					"lockScroll": false,
					"onUpdate:show": updateShow
				}, attrs, (0, import_use_scope_id.useScopeId)(), (0, import_utils$63.pick)(props$1, popupProps)), { default: () => [props$1.showArrow && (0, import_vue$33.createVNode)("div", { "class": bem$28("arrow") }, null), (0, import_vue$33.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/lib/popover/index.js
var require_popover = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/popover/index.js": ((exports, module) => {
	var __create$34 = Object.create;
	var __defProp$68 = Object.defineProperty;
	var __getOwnPropDesc$68 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$68 = Object.getOwnPropertyNames;
	var __getProtoOf$34 = Object.getPrototypeOf;
	var __hasOwnProp$68 = Object.prototype.hasOwnProperty;
	var __export$68 = (target, all) => {
		for (var name$111 in all) __defProp$68(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$68 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$68(from)) if (!__hasOwnProp$68.call(to, key) && key !== except) __defProp$68(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$68(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$34 = (mod, isNodeMode, target) => (target = mod != null ? __create$34(__getProtoOf$34(mod)) : {}, __copyProps$68(isNodeMode || !mod || !mod.__esModule ? __defProp$68(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$68 = (mod) => __copyProps$68(__defProp$68({}, "__esModule", { value: true }), mod);
	var stdin_exports$68 = {};
	__export$68(stdin_exports$68, {
		Popover: () => Popover,
		default: () => stdin_default$64,
		popoverProps: () => import_Popover2.popoverProps
	});
	module.exports = __toCommonJS$68(stdin_exports$68);
	var import_utils$62 = require_utils$9();
	var import_Popover = __toESM$34(require_Popover());
	var import_Popover2 = require_Popover();
	var Popover = (0, import_utils$62.withInstall)(import_Popover.default);
	var stdin_default$64 = Popover;
}) });

//#endregion
//#region node_modules/vant/lib/progress/Progress.js
var require_Progress = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/progress/Progress.js": ((exports, module) => {
	var __defProp$67 = Object.defineProperty;
	var __getOwnPropDesc$67 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$67 = Object.getOwnPropertyNames;
	var __hasOwnProp$67 = Object.prototype.hasOwnProperty;
	var __export$67 = (target, all) => {
		for (var name2 in all) __defProp$67(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$67 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$67(from)) if (!__hasOwnProp$67.call(to, key) && key !== except) __defProp$67(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$67(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$67 = (mod) => __copyProps$67(__defProp$67({}, "__esModule", { value: true }), mod);
	var stdin_exports$67 = {};
	__export$67(stdin_exports$67, {
		default: () => stdin_default$63,
		progressProps: () => progressProps
	});
	module.exports = __toCommonJS$67(stdin_exports$67);
	var import_vue$32 = require_vue();
	var import_utils$61 = require_utils$9();
	var [name$28, bem$27] = (0, import_utils$61.createNamespace)("progress");
	var progressProps = {
		color: String,
		inactive: Boolean,
		pivotText: String,
		textColor: String,
		showPivot: import_utils$61.truthProp,
		pivotColor: String,
		trackColor: String,
		strokeWidth: import_utils$61.numericProp,
		percentage: {
			type: import_utils$61.numericProp,
			default: 0,
			validator: (value) => +value >= 0 && +value <= 100
		}
	};
	var stdin_default$63 = (0, import_vue$32.defineComponent)({
		name: name$28,
		props: progressProps,
		setup(props$1) {
			const background = (0, import_vue$32.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 (0, import_vue$32.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: (0, import_utils$61.addUnit)(strokeWidth)
				};
				const portionStyle = {
					width: `${safePercentage}%`,
					background: background.value
				};
				return (0, import_vue$32.createVNode)("div", {
					"class": bem$27(),
					"style": rootStyle
				}, [(0, import_vue$32.createVNode)("span", {
					"class": bem$27("portion", { inactive: props$1.inactive }),
					"style": portionStyle
				}, null), renderPivot()]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/progress/index.js
var require_progress = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/progress/index.js": ((exports, module) => {
	var __create$33 = Object.create;
	var __defProp$66 = Object.defineProperty;
	var __getOwnPropDesc$66 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$66 = Object.getOwnPropertyNames;
	var __getProtoOf$33 = Object.getPrototypeOf;
	var __hasOwnProp$66 = Object.prototype.hasOwnProperty;
	var __export$66 = (target, all) => {
		for (var name$111 in all) __defProp$66(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$66 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$66(from)) if (!__hasOwnProp$66.call(to, key) && key !== except) __defProp$66(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$66(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$33 = (mod, isNodeMode, target) => (target = mod != null ? __create$33(__getProtoOf$33(mod)) : {}, __copyProps$66(isNodeMode || !mod || !mod.__esModule ? __defProp$66(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$66 = (mod) => __copyProps$66(__defProp$66({}, "__esModule", { value: true }), mod);
	var stdin_exports$66 = {};
	__export$66(stdin_exports$66, {
		Progress: () => Progress,
		default: () => stdin_default$62,
		progressProps: () => import_Progress2.progressProps
	});
	module.exports = __toCommonJS$66(stdin_exports$66);
	var import_utils$60 = require_utils$9();
	var import_Progress = __toESM$33(require_Progress());
	var import_Progress2 = require_Progress();
	var Progress = (0, import_utils$60.withInstall)(import_Progress.default);
	var stdin_default$62 = Progress;
}) });

//#endregion
//#region node_modules/vant/lib/pull-refresh/PullRefresh.js
var require_PullRefresh = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/pull-refresh/PullRefresh.js": ((exports, module) => {
	var __defProp$65 = Object.defineProperty;
	var __getOwnPropDesc$65 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$65 = Object.getOwnPropertyNames;
	var __hasOwnProp$65 = Object.prototype.hasOwnProperty;
	var __export$65 = (target, all) => {
		for (var name2 in all) __defProp$65(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$65 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$65(from)) if (!__hasOwnProp$65.call(to, key) && key !== except) __defProp$65(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$65(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$65 = (mod) => __copyProps$65(__defProp$65({}, "__esModule", { value: true }), mod);
	var stdin_exports$65 = {};
	__export$65(stdin_exports$65, {
		default: () => stdin_default$61,
		pullRefreshProps: () => pullRefreshProps
	});
	module.exports = __toCommonJS$65(stdin_exports$65);
	var import_vue$31 = require_vue();
	var import_utils$59 = require_utils$9();
	var import_use$17 = require_index_cjs$1();
	var import_use_touch$3 = require_use_touch();
	var import_loading$2 = require_loading();
	var [name$27, bem$26, t$5] = (0, import_utils$59.createNamespace)("pull-refresh");
	var DEFAULT_HEAD_HEIGHT = 50;
	var TEXT_STATUS = [
		"pulling",
		"loosing",
		"success"
	];
	var pullRefreshProps = {
		disabled: Boolean,
		modelValue: Boolean,
		headHeight: (0, import_utils$59.makeNumericProp)(DEFAULT_HEAD_HEIGHT),
		successText: String,
		pullingText: String,
		loosingText: String,
		loadingText: String,
		pullDistance: import_utils$59.numericProp,
		successDuration: (0, import_utils$59.makeNumericProp)(500),
		animationDuration: (0, import_utils$59.makeNumericProp)(300)
	};
	var stdin_default$61 = (0, import_vue$31.defineComponent)({
		name: name$27,
		props: pullRefreshProps,
		emits: [
			"change",
			"refresh",
			"update:modelValue"
		],
		setup(props$1, { emit, slots }) {
			let reachTop;
			const root = (0, import_vue$31.ref)();
			const track = (0, import_vue$31.ref)();
			const scrollParent = (0, import_use$17.useScrollParent)(root);
			const state = (0, import_vue$31.reactive)({
				status: "normal",
				distance: 0,
				duration: 0
			});
			const touch = (0, import_use_touch$3.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((0, import_vue$31.createVNode)("div", { "class": bem$26("text") }, [getStatusText()]));
				if (status === "loading") nodes.push((0, import_vue$31.createVNode)(import_loading$2.Loading, { "class": bem$26("loading") }, { default: getStatusText }));
				return nodes;
			};
			const showSuccessTip = () => {
				state.status = "success";
				setTimeout(() => {
					setStatus(0);
				}, +props$1.successDuration);
			};
			const checkPosition = (event) => {
				reachTop = (0, import_utils$59.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()) {
						(0, import_utils$59.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);
						(0, import_vue$31.nextTick)(() => emit("refresh"));
					} else setStatus(0);
				}
			};
			(0, import_vue$31.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);
			});
			(0, import_use$17.useEventListener)("touchmove", onTouchMove, { target: track });
			return () => {
				var _a;
				const trackStyle = {
					transitionDuration: `${state.duration}ms`,
					transform: state.distance ? `translate3d(0,${state.distance}px, 0)` : ""
				};
				return (0, import_vue$31.createVNode)("div", {
					"ref": root,
					"class": bem$26()
				}, [(0, import_vue$31.createVNode)("div", {
					"ref": track,
					"class": bem$26("track"),
					"style": trackStyle,
					"onTouchstartPassive": onTouchStart,
					"onTouchend": onTouchEnd,
					"onTouchcancel": onTouchEnd
				}, [(0, import_vue$31.createVNode)("div", {
					"class": bem$26("head"),
					"style": getHeadStyle()
				}, [renderStatus()]), (_a = slots.default) == null ? void 0 : _a.call(slots)])]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/pull-refresh/index.js
var require_pull_refresh = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/pull-refresh/index.js": ((exports, module) => {
	var __create$32 = Object.create;
	var __defProp$64 = Object.defineProperty;
	var __getOwnPropDesc$64 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$64 = Object.getOwnPropertyNames;
	var __getProtoOf$32 = Object.getPrototypeOf;
	var __hasOwnProp$64 = Object.prototype.hasOwnProperty;
	var __export$64 = (target, all) => {
		for (var name$111 in all) __defProp$64(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$64 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$64(from)) if (!__hasOwnProp$64.call(to, key) && key !== except) __defProp$64(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$64(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$32 = (mod, isNodeMode, target) => (target = mod != null ? __create$32(__getProtoOf$32(mod)) : {}, __copyProps$64(isNodeMode || !mod || !mod.__esModule ? __defProp$64(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$64 = (mod) => __copyProps$64(__defProp$64({}, "__esModule", { value: true }), mod);
	var stdin_exports$64 = {};
	__export$64(stdin_exports$64, {
		PullRefresh: () => PullRefresh,
		default: () => stdin_default$60,
		pullRefreshProps: () => import_PullRefresh2.pullRefreshProps
	});
	module.exports = __toCommonJS$64(stdin_exports$64);
	var import_utils$58 = require_utils$9();
	var import_PullRefresh = __toESM$32(require_PullRefresh());
	var import_PullRefresh2 = require_PullRefresh();
	var PullRefresh = (0, import_utils$58.withInstall)(import_PullRefresh.default);
	var stdin_default$60 = PullRefresh;
}) });

//#endregion
//#region node_modules/vant/lib/rate/Rate.js
var require_Rate = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/rate/Rate.js": ((exports, module) => {
	var __defProp$63 = Object.defineProperty;
	var __getOwnPropDesc$63 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$63 = Object.getOwnPropertyNames;
	var __hasOwnProp$63 = Object.prototype.hasOwnProperty;
	var __export$63 = (target, all) => {
		for (var name2 in all) __defProp$63(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$63 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$63(from)) if (!__hasOwnProp$63.call(to, key) && key !== except) __defProp$63(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$63(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$63 = (mod) => __copyProps$63(__defProp$63({}, "__esModule", { value: true }), mod);
	var stdin_exports$63 = {};
	__export$63(stdin_exports$63, {
		default: () => stdin_default$59,
		rateProps: () => rateProps
	});
	module.exports = __toCommonJS$63(stdin_exports$63);
	var import_vue$30 = require_vue();
	var import_utils$57 = require_utils$9();
	var import_use$16 = require_index_cjs$1();
	var import_use_refs = require_use_refs();
	var import_use_touch$2 = require_use_touch();
	var import_icon$9 = require_icon();
	var [name$26, bem$25] = (0, import_utils$57.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: import_utils$57.numericProp,
		icon: (0, import_utils$57.makeStringProp)("star"),
		color: String,
		count: (0, import_utils$57.makeNumericProp)(5),
		gutter: import_utils$57.numericProp,
		clearable: Boolean,
		readonly: Boolean,
		disabled: Boolean,
		voidIcon: (0, import_utils$57.makeStringProp)("star-o"),
		allowHalf: Boolean,
		voidColor: String,
		touchable: import_utils$57.truthProp,
		iconPrefix: String,
		modelValue: (0, import_utils$57.makeNumberProp)(0),
		disabledColor: String
	};
	var stdin_default$59 = (0, import_vue$30.defineComponent)({
		name: name$26,
		props: rateProps,
		emits: ["change", "update:modelValue"],
		setup(props$1, { emit }) {
			const touch = (0, import_use_touch$2.useTouch)();
			const [itemRefs, setItemRefs] = (0, import_use_refs.useRefs)();
			const groupRef = (0, import_vue$30.ref)();
			const unselectable = (0, import_vue$30.computed)(() => props$1.readonly || props$1.disabled);
			const untouchable = (0, import_vue$30.computed)(() => unselectable.value || !props$1.touchable);
			const list = (0, import_vue$30.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 = (0, import_use$16.useRect)(groupRef);
				const rects = itemRefs.value.map(import_use$16.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];
					(0, import_utils$57.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: (0, import_utils$57.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 (0, import_vue$30.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
				}, [(0, import_vue$30.createVNode)(import_icon$9.Icon, {
					"size": size,
					"name": isFull ? icon : voidIcon,
					"class": bem$25("icon", {
						disabled,
						full: isFull
					}),
					"color": disabled ? disabledColor : isFull ? color : voidColor,
					"classPrefix": iconPrefix
				}, null), renderHalf && (0, import_vue$30.createVNode)(import_icon$9.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)]);
			};
			(0, import_use$16.useCustomFieldValue)(() => props$1.modelValue);
			(0, import_use$16.useEventListener)("touchmove", onTouchMove, { target: groupRef });
			return () => (0, import_vue$30.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/lib/rate/index.js
var require_rate = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/rate/index.js": ((exports, module) => {
	var __create$31 = Object.create;
	var __defProp$62 = Object.defineProperty;
	var __getOwnPropDesc$62 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$62 = Object.getOwnPropertyNames;
	var __getProtoOf$31 = Object.getPrototypeOf;
	var __hasOwnProp$62 = Object.prototype.hasOwnProperty;
	var __export$62 = (target, all) => {
		for (var name$111 in all) __defProp$62(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$62 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$62(from)) if (!__hasOwnProp$62.call(to, key) && key !== except) __defProp$62(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$62(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$31 = (mod, isNodeMode, target) => (target = mod != null ? __create$31(__getProtoOf$31(mod)) : {}, __copyProps$62(isNodeMode || !mod || !mod.__esModule ? __defProp$62(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$62 = (mod) => __copyProps$62(__defProp$62({}, "__esModule", { value: true }), mod);
	var stdin_exports$62 = {};
	__export$62(stdin_exports$62, {
		Rate: () => Rate,
		default: () => stdin_default$58,
		rateProps: () => import_Rate2.rateProps
	});
	module.exports = __toCommonJS$62(stdin_exports$62);
	var import_utils$56 = require_utils$9();
	var import_Rate = __toESM$31(require_Rate());
	var import_Rate2 = require_Rate();
	var Rate = (0, import_utils$56.withInstall)(import_Rate.default);
	var stdin_default$58 = Rate;
}) });

//#endregion
//#region node_modules/vant/lib/rolling-text/RollingTextItem.js
var require_RollingTextItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/rolling-text/RollingTextItem.js": ((exports, module) => {
	var __defProp$61 = Object.defineProperty;
	var __getOwnPropDesc$61 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$61 = Object.getOwnPropertyNames;
	var __hasOwnProp$61 = Object.prototype.hasOwnProperty;
	var __export$61 = (target, all) => {
		for (var name2 in all) __defProp$61(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$61 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$61(from)) if (!__hasOwnProp$61.call(to, key) && key !== except) __defProp$61(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$61(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$61 = (mod) => __copyProps$61(__defProp$61({}, "__esModule", { value: true }), mod);
	var stdin_exports$61 = {};
	__export$61(stdin_exports$61, {
		default: () => stdin_default$57,
		props: () => props
	});
	module.exports = __toCommonJS$61(stdin_exports$61);
	var import_vue$29 = require_vue();
	var import_utils$55 = require_utils$9();
	var props = {
		figureArr: (0, import_utils$55.makeArrayProp)(),
		delay: Number,
		duration: (0, import_utils$55.makeNumberProp)(2),
		isStart: Boolean,
		direction: (0, import_utils$55.makeStringProp)("down"),
		height: (0, import_utils$55.makeNumberProp)(40)
	};
	var [name$25, bem$24] = (0, import_utils$55.createNamespace)("rolling-text-item");
	var stdin_default$57 = (0, import_vue$29.defineComponent)({
		name: name$25,
		props,
		setup(props2) {
			const newFigureArr = (0, import_vue$29.computed)(() => props2.direction === "down" ? props2.figureArr.slice().reverse() : props2.figureArr);
			const translatePx = (0, import_vue$29.computed)(() => {
				return `-${props2.height * (props2.figureArr.length - 1)}px`;
			});
			const itemStyle = (0, import_vue$29.computed)(() => ({ lineHeight: (0, import_utils$55.addUnit)(props2.height) }));
			const rootStyle = (0, import_vue$29.computed)(() => ({
				height: (0, import_utils$55.addUnit)(props2.height),
				"--van-translate": translatePx.value,
				"--van-duration": props2.duration + "s",
				"--van-delay": props2.delay + "s"
			}));
			return () => (0, import_vue$29.createVNode)("div", {
				"class": bem$24([props2.direction]),
				"style": rootStyle.value
			}, [(0, import_vue$29.createVNode)("div", { "class": bem$24("box", { animate: props2.isStart }) }, [Array.isArray(newFigureArr.value) && newFigureArr.value.map((figure) => (0, import_vue$29.createVNode)("div", {
				"class": bem$24("item"),
				"style": itemStyle.value
			}, [figure]))])]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/rolling-text/RollingText.js
var require_RollingText = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/rolling-text/RollingText.js": ((exports, module) => {
	var __create$30 = Object.create;
	var __defProp$60 = Object.defineProperty;
	var __getOwnPropDesc$60 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$60 = Object.getOwnPropertyNames;
	var __getProtoOf$30 = Object.getPrototypeOf;
	var __hasOwnProp$60 = Object.prototype.hasOwnProperty;
	var __export$60 = (target, all) => {
		for (var name2 in all) __defProp$60(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$60 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$60(from)) if (!__hasOwnProp$60.call(to, key) && key !== except) __defProp$60(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$60(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$30 = (mod, isNodeMode, target) => (target = mod != null ? __create$30(__getProtoOf$30(mod)) : {}, __copyProps$60(isNodeMode || !mod || !mod.__esModule ? __defProp$60(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$60 = (mod) => __copyProps$60(__defProp$60({}, "__esModule", { value: true }), mod);
	var stdin_exports$60 = {};
	__export$60(stdin_exports$60, {
		default: () => stdin_default$56,
		rollingTextProps: () => rollingTextProps
	});
	module.exports = __toCommonJS$60(stdin_exports$60);
	var import_vue$28 = require_vue();
	var import_use$15 = require_index_cjs$1();
	var import_utils$54 = require_utils$9();
	var import_use_expose$6 = require_use_expose();
	var import_RollingTextItem = __toESM$30(require_RollingTextItem());
	var [name$24, bem$23] = (0, import_utils$54.createNamespace)("rolling-text");
	var rollingTextProps = {
		startNum: (0, import_utils$54.makeNumberProp)(0),
		targetNum: Number,
		textList: (0, import_utils$54.makeArrayProp)(),
		duration: (0, import_utils$54.makeNumberProp)(2),
		autoStart: import_utils$54.truthProp,
		direction: (0, import_utils$54.makeStringProp)("down"),
		stopOrder: (0, import_utils$54.makeStringProp)("ltr"),
		height: (0, import_utils$54.makeNumberProp)(40)
	};
	var CIRCLE_NUM = 2;
	var stdin_default$56 = (0, import_vue$28.defineComponent)({
		name: name$24,
		props: rollingTextProps,
		setup(props$1) {
			const isCustomType = (0, import_vue$28.computed)(() => Array.isArray(props$1.textList) && props$1.textList.length);
			const itemLength = (0, import_vue$28.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 = (0, import_vue$28.computed)(() => {
				if (isCustomType.value) return new Array(itemLength.value).fill("");
				return (0, import_utils$54.padZero)(props$1.targetNum, itemLength.value).split("");
			});
			const startNumArr = (0, import_vue$28.computed)(() => (0, import_utils$54.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 = (0, import_vue$28.ref)(props$1.autoStart);
			const start$1 = () => {
				rolling.value = true;
			};
			const reset$1 = () => {
				rolling.value = false;
				if (props$1.autoStart) (0, import_use$15.raf)(() => start$1());
			};
			(0, import_vue$28.watch)(() => props$1.autoStart, (value) => {
				if (value) start$1();
			});
			(0, import_use_expose$6.useExpose)({
				start: start$1,
				reset: reset$1
			});
			return () => (0, import_vue$28.createVNode)("div", { "class": bem$23() }, [targetNumArr.value.map((_, i) => (0, import_vue$28.createVNode)(import_RollingTextItem.default, {
				"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/lib/rolling-text/index.js
var require_rolling_text = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/rolling-text/index.js": ((exports, module) => {
	var __create$29 = Object.create;
	var __defProp$59 = Object.defineProperty;
	var __getOwnPropDesc$59 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$59 = Object.getOwnPropertyNames;
	var __getProtoOf$29 = Object.getPrototypeOf;
	var __hasOwnProp$59 = Object.prototype.hasOwnProperty;
	var __export$59 = (target, all) => {
		for (var name$111 in all) __defProp$59(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$59 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$59(from)) if (!__hasOwnProp$59.call(to, key) && key !== except) __defProp$59(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$59(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$29 = (mod, isNodeMode, target) => (target = mod != null ? __create$29(__getProtoOf$29(mod)) : {}, __copyProps$59(isNodeMode || !mod || !mod.__esModule ? __defProp$59(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$59 = (mod) => __copyProps$59(__defProp$59({}, "__esModule", { value: true }), mod);
	var stdin_exports$59 = {};
	__export$59(stdin_exports$59, {
		RollingText: () => RollingText,
		default: () => stdin_default$55,
		rollingTextProps: () => import_RollingText2.rollingTextProps
	});
	module.exports = __toCommonJS$59(stdin_exports$59);
	var import_utils$53 = require_utils$9();
	var import_RollingText = __toESM$29(require_RollingText());
	var import_RollingText2 = require_RollingText();
	var RollingText = (0, import_utils$53.withInstall)(import_RollingText.default);
	var stdin_default$55 = RollingText;
}) });

//#endregion
//#region node_modules/vant/lib/row/index.js
var require_row = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/row/index.js": ((exports, module) => {
	var __create$28 = Object.create;
	var __defProp$58 = Object.defineProperty;
	var __getOwnPropDesc$58 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$58 = Object.getOwnPropertyNames;
	var __getProtoOf$28 = Object.getPrototypeOf;
	var __hasOwnProp$58 = Object.prototype.hasOwnProperty;
	var __export$58 = (target, all) => {
		for (var name$111 in all) __defProp$58(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$58 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$58(from)) if (!__hasOwnProp$58.call(to, key) && key !== except) __defProp$58(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$58(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$28 = (mod, isNodeMode, target) => (target = mod != null ? __create$28(__getProtoOf$28(mod)) : {}, __copyProps$58(isNodeMode || !mod || !mod.__esModule ? __defProp$58(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$58 = (mod) => __copyProps$58(__defProp$58({}, "__esModule", { value: true }), mod);
	var stdin_exports$58 = {};
	__export$58(stdin_exports$58, {
		Row: () => Row,
		default: () => stdin_default$54,
		rowProps: () => import_Row2.rowProps
	});
	module.exports = __toCommonJS$58(stdin_exports$58);
	var import_utils$52 = require_utils$9();
	var import_Row = __toESM$28(require_Row());
	var import_Row2 = require_Row();
	var Row = (0, import_utils$52.withInstall)(import_Row.default);
	var stdin_default$54 = Row;
}) });

//#endregion
//#region node_modules/vant/lib/search/Search.js
var require_Search = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/search/Search.js": ((exports, module) => {
	var __defProp$57 = Object.defineProperty;
	var __getOwnPropDesc$57 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$57 = Object.getOwnPropertyNames;
	var __hasOwnProp$57 = Object.prototype.hasOwnProperty;
	var __export$57 = (target, all) => {
		for (var name2 in all) __defProp$57(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$57 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$57(from)) if (!__hasOwnProp$57.call(to, key) && key !== except) __defProp$57(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$57(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$57 = (mod) => __copyProps$57(__defProp$57({}, "__esModule", { value: true }), mod);
	var stdin_exports$57 = {};
	__export$57(stdin_exports$57, {
		default: () => stdin_default$53,
		searchProps: () => searchProps
	});
	module.exports = __toCommonJS$57(stdin_exports$57);
	var import_vue$27 = require_vue();
	var import_utils$51 = require_utils$9();
	var import_Field = require_Field();
	var import_use_id = require_use_id();
	var import_use_expose$5 = require_use_expose();
	var import_field$1 = require_field();
	var [name$23, bem$22, t$4] = (0, import_utils$51.createNamespace)("search");
	var searchProps = (0, import_utils$51.extend)({}, import_Field.fieldSharedProps, {
		label: String,
		shape: (0, import_utils$51.makeStringProp)("square"),
		leftIcon: (0, import_utils$51.makeStringProp)("search"),
		clearable: import_utils$51.truthProp,
		actionText: String,
		background: String,
		showAction: Boolean
	});
	var stdin_default$53 = (0, import_vue$27.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 = (0, import_use_id.useId)();
			const fieldRef = (0, import_vue$27.ref)();
			const onCancel = () => {
				if (!slots.action) {
					emit("update:modelValue", "");
					emit("cancel");
				}
			};
			const onKeypress = (event) => {
				if (event.keyCode === 13) {
					(0, import_utils$51.preventDefault)(event);
					emit("search", props$1.modelValue);
				}
			};
			const getInputId = () => props$1.id || `${id}-input`;
			const renderLabel = () => {
				if (slots.label || props$1.label) return (0, import_vue$27.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 (0, import_vue$27.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(import_Field.fieldSharedProps);
			const renderField = () => {
				const fieldAttrs = (0, import_utils$51.extend)({}, attrs, (0, import_utils$51.pick)(props$1, fieldPropNames), { id: getInputId() });
				const onInput = (value) => emit("update:modelValue", value);
				return (0, import_vue$27.createVNode)(import_field$1.Field, (0, import_vue$27.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), (0, import_utils$51.pick)(slots, ["left-icon", "right-icon"]));
			};
			(0, import_use_expose$5.useExpose)({
				focus,
				blur
			});
			return () => {
				var _a;
				return (0, import_vue$27.createVNode)("div", {
					"class": bem$22({ "show-action": props$1.showAction }),
					"style": { background: props$1.background }
				}, [
					(_a = slots.left) == null ? void 0 : _a.call(slots),
					(0, import_vue$27.createVNode)("div", { "class": bem$22("content", props$1.shape) }, [renderLabel(), renderField()]),
					renderAction()
				]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/search/index.js
var require_search = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/search/index.js": ((exports, module) => {
	var __create$27 = Object.create;
	var __defProp$56 = Object.defineProperty;
	var __getOwnPropDesc$56 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$56 = Object.getOwnPropertyNames;
	var __getProtoOf$27 = Object.getPrototypeOf;
	var __hasOwnProp$56 = Object.prototype.hasOwnProperty;
	var __export$56 = (target, all) => {
		for (var name$111 in all) __defProp$56(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$56 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$56(from)) if (!__hasOwnProp$56.call(to, key) && key !== except) __defProp$56(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$56(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$27 = (mod, isNodeMode, target) => (target = mod != null ? __create$27(__getProtoOf$27(mod)) : {}, __copyProps$56(isNodeMode || !mod || !mod.__esModule ? __defProp$56(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$56 = (mod) => __copyProps$56(__defProp$56({}, "__esModule", { value: true }), mod);
	var stdin_exports$56 = {};
	__export$56(stdin_exports$56, {
		Search: () => Search,
		default: () => stdin_default$52,
		searchProps: () => import_Search2.searchProps
	});
	module.exports = __toCommonJS$56(stdin_exports$56);
	var import_utils$50 = require_utils$9();
	var import_Search = __toESM$27(require_Search());
	var import_Search2 = require_Search();
	var Search = (0, import_utils$50.withInstall)(import_Search.default);
	var stdin_default$52 = Search;
}) });

//#endregion
//#region node_modules/vant/lib/share-sheet/ShareSheet.js
var require_ShareSheet = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/share-sheet/ShareSheet.js": ((exports, module) => {
	var __defProp$55 = Object.defineProperty;
	var __getOwnPropDesc$55 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$55 = Object.getOwnPropertyNames;
	var __hasOwnProp$55 = Object.prototype.hasOwnProperty;
	var __export$55 = (target, all) => {
		for (var name2 in all) __defProp$55(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$55 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$55(from)) if (!__hasOwnProp$55.call(to, key) && key !== except) __defProp$55(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$55(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$55 = (mod) => __copyProps$55(__defProp$55({}, "__esModule", { value: true }), mod);
	var stdin_exports$55 = {};
	__export$55(stdin_exports$55, {
		default: () => stdin_default$51,
		shareSheetProps: () => shareSheetProps
	});
	module.exports = __toCommonJS$55(stdin_exports$55);
	var import_vue$26 = require_vue();
	var import_utils$49 = require_utils$9();
	var import_shared = require_shared();
	var import_icon$8 = require_icon();
	var import_popup$1 = require_popup();
	var isImage = (name2) => name2 == null ? void 0 : name2.includes("/");
	var popupInheritKeys = [
		...import_shared.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] = (0, import_utils$49.createNamespace)("share-sheet");
	var shareSheetProps = (0, import_utils$49.extend)({}, import_shared.popupSharedProps, {
		title: String,
		round: import_utils$49.truthProp,
		options: (0, import_utils$49.makeArrayProp)(),
		cancelText: String,
		description: String,
		closeOnPopstate: import_utils$49.truthProp,
		safeAreaInsetBottom: import_utils$49.truthProp
	});
	var stdin_default$51 = (0, import_vue$26.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 (0, import_vue$26.createVNode)("div", { "class": bem$21("header") }, [title && (0, import_vue$26.createVNode)("h2", { "class": bem$21("title") }, [title]), description && (0, import_vue$26.createVNode)("span", { "class": bem$21("description") }, [description])]);
			};
			const renderIcon = (icon) => {
				if (isImage(icon)) return (0, import_vue$26.createVNode)("img", {
					"src": icon,
					"class": bem$21("image-icon")
				}, null);
				return (0, import_vue$26.createVNode)("div", { "class": bem$21("icon", [icon]) }, [(0, import_vue$26.createVNode)(import_icon$8.Icon, { "name": iconMap[icon] || icon }, null)]);
			};
			const renderOption = (option, index) => {
				const { name: name2, icon, className, description } = option;
				return (0, import_vue$26.createVNode)("div", {
					"role": "button",
					"tabindex": 0,
					"class": [
						bem$21("option"),
						className,
						import_utils$49.HAPTICS_FEEDBACK
					],
					"onClick": () => onSelect(option, index)
				}, [
					renderIcon(icon),
					name2 && (0, import_vue$26.createVNode)("span", { "class": bem$21("name") }, [name2]),
					description && (0, import_vue$26.createVNode)("span", { "class": bem$21("option-description") }, [description])
				]);
			};
			const renderOptions = (options, border) => (0, import_vue$26.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 (0, import_vue$26.createVNode)("button", {
					"type": "button",
					"class": bem$21("cancel"),
					"onClick": onCancel
				}, [slots.cancel ? slots.cancel() : cancelText]);
			};
			return () => (0, import_vue$26.createVNode)(import_popup$1.Popup, (0, import_vue$26.mergeProps)({
				"class": bem$21(),
				"position": "bottom",
				"onUpdate:show": updateShow
			}, (0, import_utils$49.pick)(props$1, popupInheritKeys)), { default: () => [
				renderHeader(),
				renderRows(),
				renderCancelButton()
			] });
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/share-sheet/index.js
var require_share_sheet = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/share-sheet/index.js": ((exports, module) => {
	var __create$26 = Object.create;
	var __defProp$54 = Object.defineProperty;
	var __getOwnPropDesc$54 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$54 = Object.getOwnPropertyNames;
	var __getProtoOf$26 = Object.getPrototypeOf;
	var __hasOwnProp$54 = Object.prototype.hasOwnProperty;
	var __export$54 = (target, all) => {
		for (var name$111 in all) __defProp$54(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$54 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$54(from)) if (!__hasOwnProp$54.call(to, key) && key !== except) __defProp$54(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$54(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$26 = (mod, isNodeMode, target) => (target = mod != null ? __create$26(__getProtoOf$26(mod)) : {}, __copyProps$54(isNodeMode || !mod || !mod.__esModule ? __defProp$54(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$54 = (mod) => __copyProps$54(__defProp$54({}, "__esModule", { value: true }), mod);
	var stdin_exports$54 = {};
	__export$54(stdin_exports$54, {
		ShareSheet: () => ShareSheet,
		default: () => stdin_default$50,
		shareSheetProps: () => import_ShareSheet2.shareSheetProps
	});
	module.exports = __toCommonJS$54(stdin_exports$54);
	var import_utils$48 = require_utils$9();
	var import_ShareSheet = __toESM$26(require_ShareSheet());
	var import_ShareSheet2 = require_ShareSheet();
	var ShareSheet = (0, import_utils$48.withInstall)(import_ShareSheet.default);
	var stdin_default$50 = ShareSheet;
}) });

//#endregion
//#region node_modules/vant/lib/sidebar/Sidebar.js
var require_Sidebar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/sidebar/Sidebar.js": ((exports, module) => {
	var __defProp$53 = Object.defineProperty;
	var __getOwnPropDesc$53 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$53 = Object.getOwnPropertyNames;
	var __hasOwnProp$53 = Object.prototype.hasOwnProperty;
	var __export$53 = (target, all) => {
		for (var name2 in all) __defProp$53(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$53 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$53(from)) if (!__hasOwnProp$53.call(to, key) && key !== except) __defProp$53(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$53(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$53 = (mod) => __copyProps$53(__defProp$53({}, "__esModule", { value: true }), mod);
	var stdin_exports$53 = {};
	__export$53(stdin_exports$53, {
		SIDEBAR_KEY: () => SIDEBAR_KEY,
		default: () => stdin_default$49,
		sidebarProps: () => sidebarProps
	});
	module.exports = __toCommonJS$53(stdin_exports$53);
	var import_vue$25 = require_vue();
	var import_utils$47 = require_utils$9();
	var import_use$14 = require_index_cjs$1();
	var [name$21, bem$20] = (0, import_utils$47.createNamespace)("sidebar");
	var SIDEBAR_KEY = Symbol(name$21);
	var sidebarProps = { modelValue: (0, import_utils$47.makeNumericProp)(0) };
	var stdin_default$49 = (0, import_vue$25.defineComponent)({
		name: name$21,
		props: sidebarProps,
		emits: ["change", "update:modelValue"],
		setup(props$1, { emit, slots }) {
			const { linkChildren } = (0, import_use$14.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 (0, import_vue$25.createVNode)("div", {
					"role": "tablist",
					"class": bem$20()
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/sidebar/index.js
var require_sidebar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/sidebar/index.js": ((exports, module) => {
	var __create$25 = Object.create;
	var __defProp$52 = Object.defineProperty;
	var __getOwnPropDesc$52 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$52 = Object.getOwnPropertyNames;
	var __getProtoOf$25 = Object.getPrototypeOf;
	var __hasOwnProp$52 = Object.prototype.hasOwnProperty;
	var __export$52 = (target, all) => {
		for (var name$111 in all) __defProp$52(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$52 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$52(from)) if (!__hasOwnProp$52.call(to, key) && key !== except) __defProp$52(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$52(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$25 = (mod, isNodeMode, target) => (target = mod != null ? __create$25(__getProtoOf$25(mod)) : {}, __copyProps$52(isNodeMode || !mod || !mod.__esModule ? __defProp$52(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$52 = (mod) => __copyProps$52(__defProp$52({}, "__esModule", { value: true }), mod);
	var stdin_exports$52 = {};
	__export$52(stdin_exports$52, {
		Sidebar: () => Sidebar,
		default: () => stdin_default$48,
		sidebarProps: () => import_Sidebar2.sidebarProps
	});
	module.exports = __toCommonJS$52(stdin_exports$52);
	var import_utils$46 = require_utils$9();
	var import_Sidebar$1 = __toESM$25(require_Sidebar());
	var import_Sidebar2 = require_Sidebar();
	var Sidebar = (0, import_utils$46.withInstall)(import_Sidebar$1.default);
	var stdin_default$48 = Sidebar;
}) });

//#endregion
//#region node_modules/vant/lib/sidebar-item/SidebarItem.js
var require_SidebarItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/sidebar-item/SidebarItem.js": ((exports, module) => {
	var __defProp$51 = Object.defineProperty;
	var __getOwnPropDesc$51 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$51 = Object.getOwnPropertyNames;
	var __hasOwnProp$51 = Object.prototype.hasOwnProperty;
	var __export$51 = (target, all) => {
		for (var name2 in all) __defProp$51(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$51 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$51(from)) if (!__hasOwnProp$51.call(to, key) && key !== except) __defProp$51(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$51(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$51 = (mod) => __copyProps$51(__defProp$51({}, "__esModule", { value: true }), mod);
	var stdin_exports$51 = {};
	__export$51(stdin_exports$51, {
		default: () => stdin_default$47,
		sidebarItemProps: () => sidebarItemProps
	});
	module.exports = __toCommonJS$51(stdin_exports$51);
	var import_vue$24 = require_vue();
	var import_utils$45 = require_utils$9();
	var import_Sidebar = require_Sidebar();
	var import_use$13 = require_index_cjs$1();
	var import_use_route$1 = require_use_route();
	var import_badge$2 = require_badge();
	var [name$20, bem$19] = (0, import_utils$45.createNamespace)("sidebar-item");
	var sidebarItemProps = (0, import_utils$45.extend)({}, import_use_route$1.routeProps, {
		dot: Boolean,
		title: String,
		badge: import_utils$45.numericProp,
		disabled: Boolean,
		badgeProps: Object
	});
	var stdin_default$47 = (0, import_vue$24.defineComponent)({
		name: name$20,
		props: sidebarItemProps,
		emits: ["click"],
		setup(props$1, { emit, slots }) {
			const route$1 = (0, import_use_route$1.useRoute)();
			const { parent, index } = (0, import_use$13.useParent)(import_Sidebar.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 (0, import_vue$24.createVNode)("div", {
					"role": "tab",
					"class": bem$19({
						select: selected,
						disabled
					}),
					"tabindex": disabled ? void 0 : 0,
					"aria-selected": selected,
					"onClick": onClick
				}, [(0, import_vue$24.createVNode)(import_badge$2.Badge, (0, import_vue$24.mergeProps)({
					"dot": dot,
					"class": bem$19("text"),
					"content": badge
				}, props$1.badgeProps), { default: () => [slots.title ? slots.title() : title] })]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/sidebar-item/index.js
var require_sidebar_item = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/sidebar-item/index.js": ((exports, module) => {
	var __create$24 = Object.create;
	var __defProp$50 = Object.defineProperty;
	var __getOwnPropDesc$50 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$50 = Object.getOwnPropertyNames;
	var __getProtoOf$24 = Object.getPrototypeOf;
	var __hasOwnProp$50 = Object.prototype.hasOwnProperty;
	var __export$50 = (target, all) => {
		for (var name$111 in all) __defProp$50(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$50 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$50(from)) if (!__hasOwnProp$50.call(to, key) && key !== except) __defProp$50(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$50(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$24 = (mod, isNodeMode, target) => (target = mod != null ? __create$24(__getProtoOf$24(mod)) : {}, __copyProps$50(isNodeMode || !mod || !mod.__esModule ? __defProp$50(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$50 = (mod) => __copyProps$50(__defProp$50({}, "__esModule", { value: true }), mod);
	var stdin_exports$50 = {};
	__export$50(stdin_exports$50, {
		SidebarItem: () => SidebarItem,
		default: () => stdin_default$46,
		sidebarItemProps: () => import_SidebarItem2.sidebarItemProps
	});
	module.exports = __toCommonJS$50(stdin_exports$50);
	var import_utils$44 = require_utils$9();
	var import_SidebarItem = __toESM$24(require_SidebarItem());
	var import_SidebarItem2 = require_SidebarItem();
	var SidebarItem = (0, import_utils$44.withInstall)(import_SidebarItem.default);
	var stdin_default$46 = SidebarItem;
}) });

//#endregion
//#region node_modules/vant/lib/signature/Signature.js
var require_Signature = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/signature/Signature.js": ((exports, module) => {
	var __defProp$49 = Object.defineProperty;
	var __getOwnPropDesc$49 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$49 = Object.getOwnPropertyNames;
	var __hasOwnProp$49 = Object.prototype.hasOwnProperty;
	var __export$49 = (target, all) => {
		for (var name2 in all) __defProp$49(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$49 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$49(from)) if (!__hasOwnProp$49.call(to, key) && key !== except) __defProp$49(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$49(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$49 = (mod) => __copyProps$49(__defProp$49({}, "__esModule", { value: true }), mod);
	var stdin_exports$49 = {};
	__export$49(stdin_exports$49, {
		default: () => stdin_default$45,
		signatureProps: () => signatureProps
	});
	module.exports = __toCommonJS$49(stdin_exports$49);
	var import_vue$23 = require_vue();
	var import_utils$43 = require_utils$9();
	var import_use$12 = require_index_cjs$1();
	var import_use_expose$4 = require_use_expose();
	var import_button$2 = require_button();
	var [name$19, bem$18, t$2] = (0, import_utils$43.createNamespace)("signature");
	var signatureProps = {
		tips: String,
		type: (0, import_utils$43.makeStringProp)("png"),
		penColor: (0, import_utils$43.makeStringProp)("#000"),
		lineWidth: (0, import_utils$43.makeNumberProp)(3),
		clearButtonText: String,
		backgroundColor: (0, import_utils$43.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$45 = (0, import_vue$23.defineComponent)({
		name: name$19,
		props: signatureProps,
		emits: [
			"submit",
			"clear",
			"start",
			"end",
			"signing"
		],
		setup(props$1, { emit, slots }) {
			const canvasRef = (0, import_vue$23.ref)();
			const wrapRef = (0, import_vue$23.ref)();
			const ctx = (0, import_vue$23.computed)(() => {
				if (!canvasRef.value) return null;
				return canvasRef.value.getContext("2d");
			});
			const isRenderCanvas = import_utils$43.inBrowser ? 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 = (0, import_use$12.useRect)(canvasRef);
				emit("start");
			};
			const touchMove = (event) => {
				if (!ctx.value) return false;
				(0, import_utils$43.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) => {
				(0, import_utils$43.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 = import_utils$43.inBrowser ? 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);
				}
			};
			(0, import_vue$23.watch)(import_utils$43.windowWidth, resize);
			(0, import_vue$23.onMounted)(initialize);
			(0, import_use_expose$4.useExpose)({
				resize,
				clear,
				submit
			});
			return () => (0, import_vue$23.createVNode)("div", { "class": bem$18() }, [(0, import_vue$23.createVNode)("div", {
				"class": bem$18("content"),
				"ref": wrapRef
			}, [isRenderCanvas ? (0, import_vue$23.createVNode)("canvas", {
				"ref": canvasRef,
				"onTouchstartPassive": touchStart,
				"onTouchmove": touchMove,
				"onTouchend": touchEnd
			}, null) : slots.tips ? slots.tips() : (0, import_vue$23.createVNode)("p", null, [props$1.tips])]), (0, import_vue$23.createVNode)("div", { "class": bem$18("footer") }, [(0, import_vue$23.createVNode)(import_button$2.Button, {
				"size": "small",
				"onClick": clear
			}, { default: () => [props$1.clearButtonText || t$2("clear")] }), (0, import_vue$23.createVNode)(import_button$2.Button, {
				"type": "primary",
				"size": "small",
				"onClick": submit
			}, { default: () => [props$1.confirmButtonText || t$2("confirm")] })])]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/signature/index.js
var require_signature = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/signature/index.js": ((exports, module) => {
	var __create$23 = Object.create;
	var __defProp$48 = Object.defineProperty;
	var __getOwnPropDesc$48 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$48 = Object.getOwnPropertyNames;
	var __getProtoOf$23 = Object.getPrototypeOf;
	var __hasOwnProp$48 = Object.prototype.hasOwnProperty;
	var __export$48 = (target, all) => {
		for (var name$111 in all) __defProp$48(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$48 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$48(from)) if (!__hasOwnProp$48.call(to, key) && key !== except) __defProp$48(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$48(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$23 = (mod, isNodeMode, target) => (target = mod != null ? __create$23(__getProtoOf$23(mod)) : {}, __copyProps$48(isNodeMode || !mod || !mod.__esModule ? __defProp$48(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$48 = (mod) => __copyProps$48(__defProp$48({}, "__esModule", { value: true }), mod);
	var stdin_exports$48 = {};
	__export$48(stdin_exports$48, {
		Signature: () => Signature,
		default: () => stdin_default$44
	});
	module.exports = __toCommonJS$48(stdin_exports$48);
	var import_utils$42 = require_utils$9();
	var import_Signature = __toESM$23(require_Signature());
	var Signature = (0, import_utils$42.withInstall)(import_Signature.default);
	var stdin_default$44 = Signature;
}) });

//#endregion
//#region node_modules/vant/lib/skeleton-title/SkeletonTitle.js
var require_SkeletonTitle = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton-title/SkeletonTitle.js": ((exports, module) => {
	var __defProp$47 = Object.defineProperty;
	var __getOwnPropDesc$47 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$47 = Object.getOwnPropertyNames;
	var __hasOwnProp$47 = Object.prototype.hasOwnProperty;
	var __export$47 = (target, all) => {
		for (var name2 in all) __defProp$47(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$47 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$47(from)) if (!__hasOwnProp$47.call(to, key) && key !== except) __defProp$47(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$47(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$47 = (mod) => __copyProps$47(__defProp$47({}, "__esModule", { value: true }), mod);
	var stdin_exports$47 = {};
	__export$47(stdin_exports$47, {
		default: () => stdin_default$43,
		skeletonTitleProps: () => skeletonTitleProps
	});
	module.exports = __toCommonJS$47(stdin_exports$47);
	var import_vue$22 = require_vue();
	var import_utils$41 = require_utils$9();
	var [name$18, bem$17] = (0, import_utils$41.createNamespace)("skeleton-title");
	var skeletonTitleProps = {
		round: Boolean,
		titleWidth: import_utils$41.numericProp
	};
	var stdin_default$43 = (0, import_vue$22.defineComponent)({
		name: name$18,
		props: skeletonTitleProps,
		setup(props$1) {
			return () => (0, import_vue$22.createVNode)("h3", {
				"class": bem$17([{ round: props$1.round }]),
				"style": { width: (0, import_utils$41.addUnit)(props$1.titleWidth) }
			}, null);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/skeleton-title/index.js
var require_skeleton_title = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton-title/index.js": ((exports, module) => {
	var __create$22 = Object.create;
	var __defProp$46 = Object.defineProperty;
	var __getOwnPropDesc$46 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$46 = Object.getOwnPropertyNames;
	var __getProtoOf$22 = Object.getPrototypeOf;
	var __hasOwnProp$46 = Object.prototype.hasOwnProperty;
	var __export$46 = (target, all) => {
		for (var name$111 in all) __defProp$46(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$46 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$46(from)) if (!__hasOwnProp$46.call(to, key) && key !== except) __defProp$46(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$46(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$22 = (mod, isNodeMode, target) => (target = mod != null ? __create$22(__getProtoOf$22(mod)) : {}, __copyProps$46(isNodeMode || !mod || !mod.__esModule ? __defProp$46(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$46 = (mod) => __copyProps$46(__defProp$46({}, "__esModule", { value: true }), mod);
	var stdin_exports$46 = {};
	__export$46(stdin_exports$46, {
		SkeletonTitle: () => SkeletonTitle,
		default: () => stdin_default$42,
		skeletonTitleProps: () => import_SkeletonTitle2.skeletonTitleProps
	});
	module.exports = __toCommonJS$46(stdin_exports$46);
	var import_SkeletonTitle = __toESM$22(require_SkeletonTitle());
	var import_utils$40 = require_utils$9();
	var import_SkeletonTitle2 = require_SkeletonTitle();
	var SkeletonTitle = (0, import_utils$40.withInstall)(import_SkeletonTitle.default);
	var stdin_default$42 = SkeletonTitle;
}) });

//#endregion
//#region node_modules/vant/lib/skeleton-avatar/SkeletonAvatar.js
var require_SkeletonAvatar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton-avatar/SkeletonAvatar.js": ((exports, module) => {
	var __defProp$45 = Object.defineProperty;
	var __getOwnPropDesc$45 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$45 = Object.getOwnPropertyNames;
	var __hasOwnProp$45 = Object.prototype.hasOwnProperty;
	var __export$45 = (target, all) => {
		for (var name2 in all) __defProp$45(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$45 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$45(from)) if (!__hasOwnProp$45.call(to, key) && key !== except) __defProp$45(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$45(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$45 = (mod) => __copyProps$45(__defProp$45({}, "__esModule", { value: true }), mod);
	var stdin_exports$45 = {};
	__export$45(stdin_exports$45, {
		default: () => stdin_default$41,
		skeletonAvatarProps: () => skeletonAvatarProps
	});
	module.exports = __toCommonJS$45(stdin_exports$45);
	var import_vue$21 = require_vue();
	var import_utils$39 = require_utils$9();
	var [name$17, bem$16] = (0, import_utils$39.createNamespace)("skeleton-avatar");
	var skeletonAvatarProps = {
		avatarSize: import_utils$39.numericProp,
		avatarShape: (0, import_utils$39.makeStringProp)("round")
	};
	var stdin_default$41 = (0, import_vue$21.defineComponent)({
		name: name$17,
		props: skeletonAvatarProps,
		setup(props$1) {
			return () => (0, import_vue$21.createVNode)("div", {
				"class": bem$16([props$1.avatarShape]),
				"style": (0, import_utils$39.getSizeStyle)(props$1.avatarSize)
			}, null);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/skeleton-avatar/index.js
var require_skeleton_avatar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton-avatar/index.js": ((exports, module) => {
	var __create$21 = Object.create;
	var __defProp$44 = Object.defineProperty;
	var __getOwnPropDesc$44 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$44 = Object.getOwnPropertyNames;
	var __getProtoOf$21 = Object.getPrototypeOf;
	var __hasOwnProp$44 = Object.prototype.hasOwnProperty;
	var __export$44 = (target, all) => {
		for (var name$111 in all) __defProp$44(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$44 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$44(from)) if (!__hasOwnProp$44.call(to, key) && key !== except) __defProp$44(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$44(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$21 = (mod, isNodeMode, target) => (target = mod != null ? __create$21(__getProtoOf$21(mod)) : {}, __copyProps$44(isNodeMode || !mod || !mod.__esModule ? __defProp$44(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$44 = (mod) => __copyProps$44(__defProp$44({}, "__esModule", { value: true }), mod);
	var stdin_exports$44 = {};
	__export$44(stdin_exports$44, {
		SkeletonAvatar: () => SkeletonAvatar,
		default: () => stdin_default$40,
		skeletonAvatarProps: () => import_SkeletonAvatar2.skeletonAvatarProps
	});
	module.exports = __toCommonJS$44(stdin_exports$44);
	var import_utils$38 = require_utils$9();
	var import_SkeletonAvatar = __toESM$21(require_SkeletonAvatar());
	var import_SkeletonAvatar2 = require_SkeletonAvatar();
	var SkeletonAvatar = (0, import_utils$38.withInstall)(import_SkeletonAvatar.default);
	var stdin_default$40 = SkeletonAvatar;
}) });

//#endregion
//#region node_modules/vant/lib/skeleton-paragraph/SkeletonParagraph.js
var require_SkeletonParagraph = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton-paragraph/SkeletonParagraph.js": ((exports, module) => {
	var __defProp$43 = Object.defineProperty;
	var __getOwnPropDesc$43 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$43 = Object.getOwnPropertyNames;
	var __hasOwnProp$43 = Object.prototype.hasOwnProperty;
	var __export$43 = (target, all) => {
		for (var name2 in all) __defProp$43(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$43 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$43(from)) if (!__hasOwnProp$43.call(to, key) && key !== except) __defProp$43(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$43(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$43 = (mod) => __copyProps$43(__defProp$43({}, "__esModule", { value: true }), mod);
	var stdin_exports$43 = {};
	__export$43(stdin_exports$43, {
		DEFAULT_ROW_WIDTH: () => DEFAULT_ROW_WIDTH,
		default: () => stdin_default$39,
		skeletonParagraphProps: () => skeletonParagraphProps
	});
	module.exports = __toCommonJS$43(stdin_exports$43);
	var import_vue$20 = require_vue();
	var import_utils$37 = require_utils$9();
	var DEFAULT_ROW_WIDTH = "100%";
	var skeletonParagraphProps = {
		round: Boolean,
		rowWidth: {
			type: import_utils$37.numericProp,
			default: DEFAULT_ROW_WIDTH
		}
	};
	var [name$16, bem$15] = (0, import_utils$37.createNamespace)("skeleton-paragraph");
	var stdin_default$39 = (0, import_vue$20.defineComponent)({
		name: name$16,
		props: skeletonParagraphProps,
		setup(props$1) {
			return () => (0, import_vue$20.createVNode)("div", {
				"class": bem$15([{ round: props$1.round }]),
				"style": { width: props$1.rowWidth }
			}, null);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/skeleton-paragraph/index.js
var require_skeleton_paragraph = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton-paragraph/index.js": ((exports, module) => {
	var __create$20 = Object.create;
	var __defProp$42 = Object.defineProperty;
	var __getOwnPropDesc$42 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$42 = Object.getOwnPropertyNames;
	var __getProtoOf$20 = Object.getPrototypeOf;
	var __hasOwnProp$42 = Object.prototype.hasOwnProperty;
	var __export$42 = (target, all) => {
		for (var name$111 in all) __defProp$42(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$42 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$42(from)) if (!__hasOwnProp$42.call(to, key) && key !== except) __defProp$42(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$42(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$20 = (mod, isNodeMode, target) => (target = mod != null ? __create$20(__getProtoOf$20(mod)) : {}, __copyProps$42(isNodeMode || !mod || !mod.__esModule ? __defProp$42(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$42 = (mod) => __copyProps$42(__defProp$42({}, "__esModule", { value: true }), mod);
	var stdin_exports$42 = {};
	__export$42(stdin_exports$42, {
		DEFAULT_ROW_WIDTH: () => import_SkeletonParagraph2.DEFAULT_ROW_WIDTH,
		SkeletonParagraph: () => SkeletonParagraph,
		default: () => stdin_default$38,
		skeletonParagraphProps: () => import_SkeletonParagraph2.skeletonParagraphProps
	});
	module.exports = __toCommonJS$42(stdin_exports$42);
	var import_SkeletonParagraph = __toESM$20(require_SkeletonParagraph());
	var import_utils$36 = require_utils$9();
	var import_SkeletonParagraph2 = require_SkeletonParagraph();
	var SkeletonParagraph = (0, import_utils$36.withInstall)(import_SkeletonParagraph.default);
	var stdin_default$38 = SkeletonParagraph;
}) });

//#endregion
//#region node_modules/vant/lib/skeleton/Skeleton.js
var require_Skeleton = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton/Skeleton.js": ((exports, module) => {
	var __create$19 = Object.create;
	var __defProp$41 = Object.defineProperty;
	var __getOwnPropDesc$41 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$41 = Object.getOwnPropertyNames;
	var __getProtoOf$19 = Object.getPrototypeOf;
	var __hasOwnProp$41 = Object.prototype.hasOwnProperty;
	var __export$41 = (target, all) => {
		for (var name2 in all) __defProp$41(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$41 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$41(from)) if (!__hasOwnProp$41.call(to, key) && key !== except) __defProp$41(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$41(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$19 = (mod, isNodeMode, target) => (target = mod != null ? __create$19(__getProtoOf$19(mod)) : {}, __copyProps$41(isNodeMode || !mod || !mod.__esModule ? __defProp$41(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$41 = (mod) => __copyProps$41(__defProp$41({}, "__esModule", { value: true }), mod);
	var stdin_exports$41 = {};
	__export$41(stdin_exports$41, {
		default: () => stdin_default$37,
		skeletonProps: () => skeletonProps
	});
	module.exports = __toCommonJS$41(stdin_exports$41);
	var import_vue$19 = require_vue();
	var import_utils$35 = require_utils$9();
	var import_skeleton_title$1 = __toESM$19(require_skeleton_title());
	var import_skeleton_avatar$1 = __toESM$19(require_skeleton_avatar());
	var import_skeleton_paragraph$1 = __toESM$19(require_skeleton_paragraph());
	var [name$15, bem$14] = (0, import_utils$35.createNamespace)("skeleton");
	var DEFAULT_LAST_ROW_WIDTH = "60%";
	var skeletonProps = {
		row: (0, import_utils$35.makeNumericProp)(0),
		round: Boolean,
		title: Boolean,
		titleWidth: import_utils$35.numericProp,
		avatar: Boolean,
		avatarSize: import_utils$35.numericProp,
		avatarShape: (0, import_utils$35.makeStringProp)("round"),
		loading: import_utils$35.truthProp,
		animate: import_utils$35.truthProp,
		rowWidth: {
			type: [
				Number,
				String,
				Array
			],
			default: import_skeleton_paragraph$1.DEFAULT_ROW_WIDTH
		}
	};
	var stdin_default$37 = (0, import_vue$19.defineComponent)({
		name: name$15,
		inheritAttrs: false,
		props: skeletonProps,
		setup(props$1, { slots, attrs }) {
			const renderAvatar = () => {
				if (props$1.avatar) return (0, import_vue$19.createVNode)(import_skeleton_avatar$1.default, {
					"avatarShape": props$1.avatarShape,
					"avatarSize": props$1.avatarSize
				}, null);
			};
			const renderTitle = () => {
				if (props$1.title) return (0, import_vue$19.createVNode)(import_skeleton_title$1.default, {
					"round": props$1.round,
					"titleWidth": props$1.titleWidth
				}, null);
			};
			const getRowWidth = (index) => {
				const { rowWidth } = props$1;
				if (rowWidth === import_skeleton_paragraph$1.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) => (0, import_vue$19.createVNode)(import_skeleton_paragraph$1.default, {
				"key": i,
				"round": props$1.round,
				"rowWidth": (0, import_utils$35.addUnit)(getRowWidth(i))
			}, null));
			const renderContents = () => {
				if (slots.template) return slots.template();
				return (0, import_vue$19.createVNode)(import_vue$19.Fragment, null, [renderAvatar(), (0, import_vue$19.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 (0, import_vue$19.createVNode)("div", (0, import_vue$19.mergeProps)({ "class": bem$14({
					animate: props$1.animate,
					round: props$1.round
				}) }, attrs), [renderContents()]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/skeleton/index.js
var require_skeleton = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton/index.js": ((exports, module) => {
	var __create$18 = Object.create;
	var __defProp$40 = Object.defineProperty;
	var __getOwnPropDesc$40 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$40 = Object.getOwnPropertyNames;
	var __getProtoOf$18 = Object.getPrototypeOf;
	var __hasOwnProp$40 = Object.prototype.hasOwnProperty;
	var __export$40 = (target, all) => {
		for (var name$111 in all) __defProp$40(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$40 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$40(from)) if (!__hasOwnProp$40.call(to, key) && key !== except) __defProp$40(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$40(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$18 = (mod, isNodeMode, target) => (target = mod != null ? __create$18(__getProtoOf$18(mod)) : {}, __copyProps$40(isNodeMode || !mod || !mod.__esModule ? __defProp$40(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$40 = (mod) => __copyProps$40(__defProp$40({}, "__esModule", { value: true }), mod);
	var stdin_exports$40 = {};
	__export$40(stdin_exports$40, {
		Skeleton: () => Skeleton,
		default: () => stdin_default$36,
		skeletonProps: () => import_Skeleton2.skeletonProps
	});
	module.exports = __toCommonJS$40(stdin_exports$40);
	var import_Skeleton = __toESM$18(require_Skeleton());
	var import_utils$34 = require_utils$9();
	var import_Skeleton2 = require_Skeleton();
	var Skeleton = (0, import_utils$34.withInstall)(import_Skeleton.default);
	var stdin_default$36 = Skeleton;
}) });

//#endregion
//#region node_modules/vant/lib/skeleton-image/SkeletonImage.js
var require_SkeletonImage = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton-image/SkeletonImage.js": ((exports, module) => {
	var __defProp$39 = Object.defineProperty;
	var __getOwnPropDesc$39 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$39 = Object.getOwnPropertyNames;
	var __hasOwnProp$39 = Object.prototype.hasOwnProperty;
	var __export$39 = (target, all) => {
		for (var name2 in all) __defProp$39(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$39 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$39(from)) if (!__hasOwnProp$39.call(to, key) && key !== except) __defProp$39(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$39(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$39 = (mod) => __copyProps$39(__defProp$39({}, "__esModule", { value: true }), mod);
	var stdin_exports$39 = {};
	__export$39(stdin_exports$39, {
		default: () => stdin_default$35,
		skeletonImageProps: () => skeletonImageProps
	});
	module.exports = __toCommonJS$39(stdin_exports$39);
	var import_vue$18 = require_vue();
	var import_utils$33 = require_utils$9();
	var import_icon$7 = require_icon();
	var [name$14, bem$13] = (0, import_utils$33.createNamespace)("skeleton-image");
	var skeletonImageProps = {
		imageSize: import_utils$33.numericProp,
		imageShape: (0, import_utils$33.makeStringProp)("square")
	};
	var stdin_default$35 = (0, import_vue$18.defineComponent)({
		name: name$14,
		props: skeletonImageProps,
		setup(props$1) {
			return () => (0, import_vue$18.createVNode)("div", {
				"class": bem$13([props$1.imageShape]),
				"style": (0, import_utils$33.getSizeStyle)(props$1.imageSize)
			}, [(0, import_vue$18.createVNode)(import_icon$7.Icon, {
				"name": "photo",
				"class": bem$13("icon")
			}, null)]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/skeleton-image/index.js
var require_skeleton_image = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/skeleton-image/index.js": ((exports, module) => {
	var __create$17 = Object.create;
	var __defProp$38 = Object.defineProperty;
	var __getOwnPropDesc$38 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$38 = Object.getOwnPropertyNames;
	var __getProtoOf$17 = Object.getPrototypeOf;
	var __hasOwnProp$38 = Object.prototype.hasOwnProperty;
	var __export$38 = (target, all) => {
		for (var name$111 in all) __defProp$38(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$38 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$38(from)) if (!__hasOwnProp$38.call(to, key) && key !== except) __defProp$38(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$38(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$17 = (mod, isNodeMode, target) => (target = mod != null ? __create$17(__getProtoOf$17(mod)) : {}, __copyProps$38(isNodeMode || !mod || !mod.__esModule ? __defProp$38(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$38 = (mod) => __copyProps$38(__defProp$38({}, "__esModule", { value: true }), mod);
	var stdin_exports$38 = {};
	__export$38(stdin_exports$38, {
		SkeletonImage: () => SkeletonImage,
		default: () => stdin_default$34,
		skeletonImageProps: () => import_SkeletonImage2.skeletonImageProps
	});
	module.exports = __toCommonJS$38(stdin_exports$38);
	var import_SkeletonImage = __toESM$17(require_SkeletonImage());
	var import_utils$32 = require_utils$9();
	var import_SkeletonImage2 = require_SkeletonImage();
	var SkeletonImage = (0, import_utils$32.withInstall)(import_SkeletonImage.default);
	var stdin_default$34 = SkeletonImage;
}) });

//#endregion
//#region node_modules/vant/lib/slider/Slider.js
var require_Slider = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/slider/Slider.js": ((exports, module) => {
	var __defProp$37 = Object.defineProperty;
	var __getOwnPropDesc$37 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$37 = Object.getOwnPropertyNames;
	var __hasOwnProp$37 = Object.prototype.hasOwnProperty;
	var __export$37 = (target, all) => {
		for (var name2 in all) __defProp$37(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$37 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$37(from)) if (!__hasOwnProp$37.call(to, key) && key !== except) __defProp$37(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$37(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$37 = (mod) => __copyProps$37(__defProp$37({}, "__esModule", { value: true }), mod);
	var stdin_exports$37 = {};
	__export$37(stdin_exports$37, {
		default: () => stdin_default$33,
		sliderProps: () => sliderProps
	});
	module.exports = __toCommonJS$37(stdin_exports$37);
	var import_vue$17 = require_vue();
	var import_utils$31 = require_utils$9();
	var import_use$11 = require_index_cjs$1();
	var import_use_touch$1 = require_use_touch();
	var [name$13, bem$12] = (0, import_utils$31.createNamespace)("slider");
	var sliderProps = {
		min: (0, import_utils$31.makeNumericProp)(0),
		max: (0, import_utils$31.makeNumericProp)(100),
		step: (0, import_utils$31.makeNumericProp)(1),
		range: Boolean,
		reverse: Boolean,
		disabled: Boolean,
		readonly: Boolean,
		vertical: Boolean,
		barHeight: import_utils$31.numericProp,
		buttonSize: import_utils$31.numericProp,
		activeColor: String,
		inactiveColor: String,
		modelValue: {
			type: [Number, Array],
			default: 0
		}
	};
	var stdin_default$33 = (0, import_vue$17.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 = (0, import_vue$17.ref)();
			const slider = [(0, import_vue$17.ref)(), (0, import_vue$17.ref)()];
			const dragStatus = (0, import_vue$17.ref)();
			const touch = (0, import_use_touch$1.useTouch)();
			const scope = (0, import_vue$17.computed)(() => Number(props$1.max) - Number(props$1.min));
			const wrapperStyle = (0, import_vue$17.computed)(() => {
				const crossAxis = props$1.vertical ? "width" : "height";
				return {
					background: props$1.inactiveColor,
					[crossAxis]: (0, import_utils$31.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 = (0, import_vue$17.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 = (0, import_utils$31.clamp)(value, min, max);
				const diff = Math.round((value - min) / step) * step;
				return (0, import_utils$31.addNumber)(min, diff);
			};
			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 (!(0, import_utils$31.isSameValue)(value, props$1.modelValue)) emit("update:modelValue", value);
				if (end$1 && !(0, import_utils$31.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 = (0, import_use$11.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);
				(0, import_utils$31.preventDefault)(event, true);
				touch.move(event);
				dragStatus.value = "dragging";
				const rect = (0, import_use$11.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 (0, import_vue$17.createVNode)("div", {
					"class": bem$12("button"),
					"style": (0, import_utils$31.getSizeStyle)(props$1.buttonSize)
				}, null);
			};
			const renderButton = (index) => {
				const current2 = typeof index === "number" ? props$1.modelValue[index] : props$1.modelValue;
				return (0, import_vue$17.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": import_utils$31.stopPropagation
				}, [renderButtonContent(current2, index)]);
			};
			updateValue(props$1.modelValue);
			(0, import_use$11.useCustomFieldValue)(() => props$1.modelValue);
			slider.forEach((item) => {
				(0, import_use$11.useEventListener)("touchmove", onTouchMove, { target: item });
			});
			return () => (0, import_vue$17.createVNode)("div", {
				"ref": root,
				"style": wrapperStyle.value,
				"class": bem$12({
					vertical: props$1.vertical,
					disabled: props$1.disabled
				}),
				"onClick": onClick
			}, [(0, import_vue$17.createVNode)("div", {
				"class": bem$12("bar"),
				"style": barStyle.value
			}, [props$1.range ? [renderButton(0), renderButton(1)] : renderButton()])]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/slider/index.js
var require_slider = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/slider/index.js": ((exports, module) => {
	var __create$16 = Object.create;
	var __defProp$36 = Object.defineProperty;
	var __getOwnPropDesc$36 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$36 = Object.getOwnPropertyNames;
	var __getProtoOf$16 = Object.getPrototypeOf;
	var __hasOwnProp$36 = Object.prototype.hasOwnProperty;
	var __export$36 = (target, all) => {
		for (var name$111 in all) __defProp$36(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$36 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$36(from)) if (!__hasOwnProp$36.call(to, key) && key !== except) __defProp$36(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$36(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$16 = (mod, isNodeMode, target) => (target = mod != null ? __create$16(__getProtoOf$16(mod)) : {}, __copyProps$36(isNodeMode || !mod || !mod.__esModule ? __defProp$36(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$36 = (mod) => __copyProps$36(__defProp$36({}, "__esModule", { value: true }), mod);
	var stdin_exports$36 = {};
	__export$36(stdin_exports$36, {
		Slider: () => Slider,
		default: () => stdin_default$32,
		sliderProps: () => import_Slider2.sliderProps
	});
	module.exports = __toCommonJS$36(stdin_exports$36);
	var import_utils$30 = require_utils$9();
	var import_Slider = __toESM$16(require_Slider());
	var import_Slider2 = require_Slider();
	var Slider = (0, import_utils$30.withInstall)(import_Slider.default);
	var stdin_default$32 = Slider;
}) });

//#endregion
//#region node_modules/vant/lib/space/Space.js
var require_Space = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/space/Space.js": ((exports, module) => {
	var __defProp$35 = Object.defineProperty;
	var __getOwnPropDesc$35 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$35 = Object.getOwnPropertyNames;
	var __hasOwnProp$35 = Object.prototype.hasOwnProperty;
	var __export$35 = (target, all) => {
		for (var name2 in all) __defProp$35(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$35 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$35(from)) if (!__hasOwnProp$35.call(to, key) && key !== except) __defProp$35(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$35(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$35 = (mod) => __copyProps$35(__defProp$35({}, "__esModule", { value: true }), mod);
	var stdin_exports$35 = {};
	__export$35(stdin_exports$35, {
		default: () => stdin_default$31,
		spaceProps: () => spaceProps
	});
	module.exports = __toCommonJS$35(stdin_exports$35);
	var import_vue$16 = require_vue();
	var [name$12, bem$11] = (0, require_utils$9().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 === import_vue$16.Fragment) nodes.push(...filterEmpty(child.children));
			else nodes.push(child);
		});
		return nodes.filter((c) => {
			var _a;
			return !(c && (c.type === import_vue$16.Comment || c.type === import_vue$16.Fragment && ((_a = c.children) == null ? void 0 : _a.length) === 0 || c.type === import_vue$16.Text && c.children.trim() === ""));
		});
	}
	var stdin_default$31 = (0, import_vue$16.defineComponent)({
		name: name$12,
		props: spaceProps,
		setup(props$1, { slots }) {
			const mergedAlign = (0, import_vue$16.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 (0, import_vue$16.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) => (0, import_vue$16.createVNode)("div", {
					"key": `item-${i}`,
					"class": `${name$12}-item`,
					"style": getMarginStyle(i === children.length - 1)
				}, [c]))]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/space/index.js
var require_space = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/space/index.js": ((exports, module) => {
	var __create$15 = Object.create;
	var __defProp$34 = Object.defineProperty;
	var __getOwnPropDesc$34 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$34 = Object.getOwnPropertyNames;
	var __getProtoOf$15 = Object.getPrototypeOf;
	var __hasOwnProp$34 = Object.prototype.hasOwnProperty;
	var __export$34 = (target, all) => {
		for (var name$111 in all) __defProp$34(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$34 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$34(from)) if (!__hasOwnProp$34.call(to, key) && key !== except) __defProp$34(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$34(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$15 = (mod, isNodeMode, target) => (target = mod != null ? __create$15(__getProtoOf$15(mod)) : {}, __copyProps$34(isNodeMode || !mod || !mod.__esModule ? __defProp$34(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$34 = (mod) => __copyProps$34(__defProp$34({}, "__esModule", { value: true }), mod);
	var stdin_exports$34 = {};
	__export$34(stdin_exports$34, {
		Space: () => Space,
		default: () => stdin_default$30,
		spaceProps: () => import_Space2.spaceProps
	});
	module.exports = __toCommonJS$34(stdin_exports$34);
	var import_utils$29 = require_utils$9();
	var import_Space = __toESM$15(require_Space());
	var import_Space2 = require_Space();
	var Space = (0, import_utils$29.withInstall)(import_Space.default);
	var stdin_default$30 = Space;
}) });

//#endregion
//#region node_modules/vant/lib/steps/Steps.js
var require_Steps = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/steps/Steps.js": ((exports, module) => {
	var __defProp$33 = Object.defineProperty;
	var __getOwnPropDesc$33 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$33 = Object.getOwnPropertyNames;
	var __hasOwnProp$33 = Object.prototype.hasOwnProperty;
	var __export$33 = (target, all) => {
		for (var name2 in all) __defProp$33(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$33 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$33(from)) if (!__hasOwnProp$33.call(to, key) && key !== except) __defProp$33(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$33(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$33 = (mod) => __copyProps$33(__defProp$33({}, "__esModule", { value: true }), mod);
	var stdin_exports$33 = {};
	__export$33(stdin_exports$33, {
		STEPS_KEY: () => STEPS_KEY,
		default: () => stdin_default$29,
		stepsProps: () => stepsProps
	});
	module.exports = __toCommonJS$33(stdin_exports$33);
	var import_vue$15 = require_vue();
	var import_utils$28 = require_utils$9();
	var import_use$10 = require_index_cjs$1();
	var [name$11, bem$10] = (0, import_utils$28.createNamespace)("steps");
	var stepsProps = {
		active: (0, import_utils$28.makeNumericProp)(0),
		direction: (0, import_utils$28.makeStringProp)("horizontal"),
		activeIcon: (0, import_utils$28.makeStringProp)("checked"),
		iconPrefix: String,
		finishIcon: String,
		activeColor: String,
		inactiveIcon: String,
		inactiveColor: String
	};
	var STEPS_KEY = Symbol(name$11);
	var stdin_default$29 = (0, import_vue$15.defineComponent)({
		name: name$11,
		props: stepsProps,
		emits: ["clickStep"],
		setup(props$1, { emit, slots }) {
			const { linkChildren } = (0, import_use$10.useChildren)(STEPS_KEY);
			const onClickStep = (index) => emit("clickStep", index);
			linkChildren({
				props: props$1,
				onClickStep
			});
			return () => {
				var _a;
				return (0, import_vue$15.createVNode)("div", { "class": bem$10([props$1.direction]) }, [(0, import_vue$15.createVNode)("div", { "class": bem$10("items") }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/step/Step.js
var require_Step = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/step/Step.js": ((exports, module) => {
	var __defProp$32 = Object.defineProperty;
	var __getOwnPropDesc$32 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$32 = Object.getOwnPropertyNames;
	var __hasOwnProp$32 = Object.prototype.hasOwnProperty;
	var __export$32 = (target, all) => {
		for (var name2 in all) __defProp$32(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$32 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$32(from)) if (!__hasOwnProp$32.call(to, key) && key !== except) __defProp$32(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$32(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$32 = (mod) => __copyProps$32(__defProp$32({}, "__esModule", { value: true }), mod);
	var stdin_exports$32 = {};
	__export$32(stdin_exports$32, { default: () => stdin_default$28 });
	module.exports = __toCommonJS$32(stdin_exports$32);
	var import_vue$14 = require_vue();
	var import_utils$27 = require_utils$9();
	var import_Steps$1 = require_Steps();
	var import_use$9 = require_index_cjs$1();
	var import_icon$6 = require_icon();
	var [name$10, bem$9] = (0, import_utils$27.createNamespace)("step");
	var stdin_default$28 = (0, import_vue$14.defineComponent)({
		name: name$10,
		setup(props$1, { slots }) {
			const { parent, index } = (0, import_use$9.useParent)(import_Steps$1.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 = (0, import_vue$14.computed)(() => ({ background: getStatus() === "finish" ? parentProps.activeColor : parentProps.inactiveColor }));
			const titleStyle = (0, import_vue$14.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 (0, import_vue$14.createVNode)(import_icon$6.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 (0, import_vue$14.createVNode)(import_icon$6.Icon, {
						"class": bem$9("icon", "finish"),
						"name": finishIcon,
						"color": activeColor,
						"classPrefix": iconPrefix
					}, null);
				}
				if (slots["inactive-icon"]) return slots["inactive-icon"]();
				if (inactiveIcon) return (0, import_vue$14.createVNode)(import_icon$6.Icon, {
					"class": bem$9("icon"),
					"name": inactiveIcon,
					"classPrefix": iconPrefix
				}, null);
				return (0, import_vue$14.createVNode)("i", {
					"class": bem$9("circle"),
					"style": lineStyle.value
				}, null);
			};
			return () => {
				var _a;
				const status = getStatus();
				return (0, import_vue$14.createVNode)("div", { "class": [import_utils$27.BORDER, bem$9([parentProps.direction, { [status]: status }])] }, [
					(0, import_vue$14.createVNode)("div", {
						"class": bem$9("title", { active: isActive() }),
						"style": titleStyle.value,
						"onClick": onClickStep
					}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]),
					(0, import_vue$14.createVNode)("div", {
						"class": bem$9("circle-container"),
						"onClick": onClickStep
					}, [renderCircle()]),
					(0, import_vue$14.createVNode)("div", {
						"class": bem$9("line"),
						"style": lineStyle.value
					}, null)
				]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/step/index.js
var require_step = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/step/index.js": ((exports, module) => {
	var __create$14 = Object.create;
	var __defProp$31 = Object.defineProperty;
	var __getOwnPropDesc$31 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$31 = Object.getOwnPropertyNames;
	var __getProtoOf$14 = Object.getPrototypeOf;
	var __hasOwnProp$31 = Object.prototype.hasOwnProperty;
	var __export$31 = (target, all) => {
		for (var name$111 in all) __defProp$31(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$31 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$31(from)) if (!__hasOwnProp$31.call(to, key) && key !== except) __defProp$31(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$31(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$14 = (mod, isNodeMode, target) => (target = mod != null ? __create$14(__getProtoOf$14(mod)) : {}, __copyProps$31(isNodeMode || !mod || !mod.__esModule ? __defProp$31(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$31 = (mod) => __copyProps$31(__defProp$31({}, "__esModule", { value: true }), mod);
	var stdin_exports$31 = {};
	__export$31(stdin_exports$31, {
		Step: () => Step,
		default: () => stdin_default$27
	});
	module.exports = __toCommonJS$31(stdin_exports$31);
	var import_utils$26 = require_utils$9();
	var import_Step = __toESM$14(require_Step());
	var Step = (0, import_utils$26.withInstall)(import_Step.default);
	var stdin_default$27 = Step;
}) });

//#endregion
//#region node_modules/vant/lib/stepper/Stepper.js
var require_Stepper = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/stepper/Stepper.js": ((exports, module) => {
	var __defProp$30 = Object.defineProperty;
	var __getOwnPropDesc$30 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$30 = Object.getOwnPropertyNames;
	var __hasOwnProp$30 = Object.prototype.hasOwnProperty;
	var __export$30 = (target, all) => {
		for (var name2 in all) __defProp$30(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$30 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$30(from)) if (!__hasOwnProp$30.call(to, key) && key !== except) __defProp$30(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$30(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$30 = (mod) => __copyProps$30(__defProp$30({}, "__esModule", { value: true }), mod);
	var stdin_exports$30 = {};
	__export$30(stdin_exports$30, {
		default: () => stdin_default$26,
		stepperProps: () => stepperProps
	});
	module.exports = __toCommonJS$30(stdin_exports$30);
	var import_vue$13 = require_vue();
	var import_utils$25 = require_utils$9();
	var import_use$8 = require_index_cjs$1();
	var [name$9, bem$8] = (0, import_utils$25.createNamespace)("stepper");
	var LONG_PRESS_INTERVAL = 200;
	var isEqual = (value1, value2) => String(value1) === String(value2);
	var stepperProps = {
		min: (0, import_utils$25.makeNumericProp)(1),
		max: (0, import_utils$25.makeNumericProp)(Infinity),
		name: (0, import_utils$25.makeNumericProp)(""),
		step: (0, import_utils$25.makeNumericProp)(1),
		theme: String,
		integer: Boolean,
		disabled: Boolean,
		showPlus: import_utils$25.truthProp,
		showMinus: import_utils$25.truthProp,
		showInput: import_utils$25.truthProp,
		longPress: import_utils$25.truthProp,
		autoFixed: import_utils$25.truthProp,
		allowEmpty: Boolean,
		modelValue: import_utils$25.numericProp,
		inputWidth: import_utils$25.numericProp,
		buttonSize: import_utils$25.numericProp,
		placeholder: String,
		disablePlus: Boolean,
		disableMinus: Boolean,
		disableInput: Boolean,
		beforeChange: Function,
		defaultValue: (0, import_utils$25.makeNumericProp)(1),
		decimalLength: import_utils$25.numericProp
	};
	var stdin_default$26 = (0, import_vue$13.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 = (0, import_utils$25.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 ((0, import_utils$25.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 = (0, import_vue$13.ref)();
			const current$1 = (0, import_vue$13.ref)(getInitialValue());
			const minusDisabled = (0, import_vue$13.computed)(() => props$1.disabled || props$1.disableMinus || +current$1.value <= +props$1.min);
			const plusDisabled = (0, import_vue$13.computed)(() => props$1.disabled || props$1.disablePlus || +current$1.value >= +props$1.max);
			const inputStyle = (0, import_vue$13.computed)(() => ({
				width: (0, import_utils$25.addUnit)(props$1.inputWidth),
				height: (0, import_utils$25.addUnit)(props$1.buttonSize)
			}));
			const buttonStyle = (0, import_vue$13.computed)(() => (0, import_utils$25.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) (0, import_utils$25.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((0, import_utils$25.addNumber)(+current$1.value, diff)));
				emit(actionType);
			};
			const onInput = (event) => {
				const input = event.target;
				const { value } = input;
				const { decimalLength } = props$1;
				let formatted = (0, import_utils$25.formatNumber)(String(value), !props$1.integer);
				if ((0, import_utils$25.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;
				(0, import_vue$13.nextTick)(() => {
					emit("blur", event);
					(0, import_utils$25.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();
					}, import_utils$25.LONG_PRESS_START_TIME);
				}
			};
			const onTouchEnd = (event) => {
				if (props$1.longPress) {
					clearTimeout(longPressTimer);
					if (isLongPress) (0, import_utils$25.preventDefault)(event);
				}
			};
			const onMousedown = (event) => {
				if (props$1.disableInput) (0, import_utils$25.preventDefault)(event);
			};
			const createListeners = (type) => ({
				onClick: (event) => {
					(0, import_utils$25.preventDefault)(event);
					actionType = type;
					onChange();
				},
				onTouchstartPassive: () => {
					actionType = type;
					onTouchStart();
				},
				onTouchend: onTouchEnd,
				onTouchcancel: onTouchEnd
			});
			(0, import_vue$13.watch)(() => [
				props$1.max,
				props$1.min,
				props$1.integer,
				props$1.decimalLength
			], check);
			(0, import_vue$13.watch)(() => props$1.modelValue, (value) => {
				if (!isEqual(value, current$1.value)) current$1.value = format$2(value);
			});
			(0, import_vue$13.watch)(current$1, (value) => {
				emit("update:modelValue", value);
				emit("change", value, { name: props$1.name });
			});
			(0, import_use$8.useCustomFieldValue)(() => props$1.modelValue);
			return () => (0, import_vue$13.createVNode)("div", {
				"role": "group",
				"class": bem$8([props$1.theme])
			}, [
				(0, import_vue$13.withDirectives)((0, import_vue$13.createVNode)("button", (0, import_vue$13.mergeProps)({
					"type": "button",
					"style": buttonStyle.value,
					"class": [bem$8("minus", { disabled: minusDisabled.value }), { [import_utils$25.HAPTICS_FEEDBACK]: !minusDisabled.value }],
					"aria-disabled": minusDisabled.value || void 0
				}, createListeners("minus")), null), [[import_vue$13.vShow, props$1.showMinus]]),
				(0, import_vue$13.withDirectives)((0, import_vue$13.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), [[import_vue$13.vShow, props$1.showInput]]),
				(0, import_vue$13.withDirectives)((0, import_vue$13.createVNode)("button", (0, import_vue$13.mergeProps)({
					"type": "button",
					"style": buttonStyle.value,
					"class": [bem$8("plus", { disabled: plusDisabled.value }), { [import_utils$25.HAPTICS_FEEDBACK]: !plusDisabled.value }],
					"aria-disabled": plusDisabled.value || void 0
				}, createListeners("plus")), null), [[import_vue$13.vShow, props$1.showPlus]])
			]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/stepper/index.js
var require_stepper = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/stepper/index.js": ((exports, module) => {
	var __create$13 = Object.create;
	var __defProp$29 = Object.defineProperty;
	var __getOwnPropDesc$29 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$29 = Object.getOwnPropertyNames;
	var __getProtoOf$13 = Object.getPrototypeOf;
	var __hasOwnProp$29 = Object.prototype.hasOwnProperty;
	var __export$29 = (target, all) => {
		for (var name$111 in all) __defProp$29(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$29 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$29(from)) if (!__hasOwnProp$29.call(to, key) && key !== except) __defProp$29(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$29(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$13 = (mod, isNodeMode, target) => (target = mod != null ? __create$13(__getProtoOf$13(mod)) : {}, __copyProps$29(isNodeMode || !mod || !mod.__esModule ? __defProp$29(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$29 = (mod) => __copyProps$29(__defProp$29({}, "__esModule", { value: true }), mod);
	var stdin_exports$29 = {};
	__export$29(stdin_exports$29, {
		Stepper: () => Stepper,
		default: () => stdin_default$25,
		stepperProps: () => import_Stepper2.stepperProps
	});
	module.exports = __toCommonJS$29(stdin_exports$29);
	var import_utils$24 = require_utils$9();
	var import_Stepper = __toESM$13(require_Stepper());
	var import_Stepper2 = require_Stepper();
	var Stepper = (0, import_utils$24.withInstall)(import_Stepper.default);
	var stdin_default$25 = Stepper;
}) });

//#endregion
//#region node_modules/vant/lib/steps/index.js
var require_steps = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/steps/index.js": ((exports, module) => {
	var __create$12 = Object.create;
	var __defProp$28 = Object.defineProperty;
	var __getOwnPropDesc$28 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$28 = Object.getOwnPropertyNames;
	var __getProtoOf$12 = Object.getPrototypeOf;
	var __hasOwnProp$28 = Object.prototype.hasOwnProperty;
	var __export$28 = (target, all) => {
		for (var name$111 in all) __defProp$28(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$28 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$28(from)) if (!__hasOwnProp$28.call(to, key) && key !== except) __defProp$28(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$28(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$12 = (mod, isNodeMode, target) => (target = mod != null ? __create$12(__getProtoOf$12(mod)) : {}, __copyProps$28(isNodeMode || !mod || !mod.__esModule ? __defProp$28(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$28 = (mod) => __copyProps$28(__defProp$28({}, "__esModule", { value: true }), mod);
	var stdin_exports$28 = {};
	__export$28(stdin_exports$28, {
		Steps: () => Steps,
		default: () => stdin_default$24,
		stepsProps: () => import_Steps2.stepsProps
	});
	module.exports = __toCommonJS$28(stdin_exports$28);
	var import_utils$23 = require_utils$9();
	var import_Steps = __toESM$12(require_Steps());
	var import_Steps2 = require_Steps();
	var Steps = (0, import_utils$23.withInstall)(import_Steps.default);
	var stdin_default$24 = Steps;
}) });

//#endregion
//#region node_modules/vant/lib/submit-bar/SubmitBar.js
var require_SubmitBar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/submit-bar/SubmitBar.js": ((exports, module) => {
	var __defProp$27 = Object.defineProperty;
	var __getOwnPropDesc$27 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$27 = Object.getOwnPropertyNames;
	var __hasOwnProp$27 = Object.prototype.hasOwnProperty;
	var __export$27 = (target, all) => {
		for (var name2 in all) __defProp$27(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$27 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$27(from)) if (!__hasOwnProp$27.call(to, key) && key !== except) __defProp$27(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$27(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$27 = (mod) => __copyProps$27(__defProp$27({}, "__esModule", { value: true }), mod);
	var stdin_exports$27 = {};
	__export$27(stdin_exports$27, {
		default: () => stdin_default$23,
		submitBarProps: () => submitBarProps
	});
	module.exports = __toCommonJS$27(stdin_exports$27);
	var import_vue$12 = require_vue();
	var import_utils$22 = require_utils$9();
	var import_icon$5 = require_icon();
	var import_button$1 = require_button();
	var import_use_placeholder$1 = require_use_placeholder();
	var [name$8, bem$7, t$1] = (0, import_utils$22.createNamespace)("submit-bar");
	var submitBarProps = {
		tip: String,
		label: String,
		price: Number,
		tipIcon: String,
		loading: Boolean,
		currency: (0, import_utils$22.makeStringProp)("¥"),
		disabled: Boolean,
		textAlign: String,
		buttonText: String,
		buttonType: (0, import_utils$22.makeStringProp)("danger"),
		buttonColor: String,
		suffixLabel: String,
		placeholder: Boolean,
		decimalLength: (0, import_utils$22.makeNumericProp)(2),
		safeAreaInsetBottom: import_utils$22.truthProp
	};
	var stdin_default$23 = (0, import_vue$12.defineComponent)({
		name: name$8,
		props: submitBarProps,
		emits: ["submit"],
		setup(props$1, { emit, slots }) {
			const root = (0, import_vue$12.ref)();
			const renderPlaceholder = (0, import_use_placeholder$1.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 (0, import_vue$12.createVNode)("div", {
						"class": bem$7("text"),
						"style": { textAlign }
					}, [
						(0, import_vue$12.createVNode)("span", null, [label || t$1("label")]),
						(0, import_vue$12.createVNode)("span", { "class": bem$7("price") }, [
							currency,
							(0, import_vue$12.createVNode)("span", { "class": bem$7("price-integer") }, [pricePair[0]]),
							decimal
						]),
						suffixLabel && (0, import_vue$12.createVNode)("span", { "class": bem$7("suffix-label") }, [suffixLabel])
					]);
				}
			};
			const renderTip = () => {
				var _a;
				const { tip, tipIcon } = props$1;
				if (slots.tip || tip) return (0, import_vue$12.createVNode)("div", { "class": bem$7("tip") }, [
					tipIcon && (0, import_vue$12.createVNode)(import_icon$5.Icon, {
						"class": bem$7("tip-icon"),
						"name": tipIcon
					}, null),
					tip && (0, import_vue$12.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 (0, import_vue$12.createVNode)(import_button$1.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 (0, import_vue$12.createVNode)("div", {
					"ref": root,
					"class": [bem$7(), { "van-safe-area-bottom": props$1.safeAreaInsetBottom }]
				}, [
					(_a = slots.top) == null ? void 0 : _a.call(slots),
					renderTip(),
					(0, import_vue$12.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/lib/submit-bar/index.js
var require_submit_bar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/submit-bar/index.js": ((exports, module) => {
	var __create$11 = Object.create;
	var __defProp$26 = Object.defineProperty;
	var __getOwnPropDesc$26 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$26 = Object.getOwnPropertyNames;
	var __getProtoOf$11 = Object.getPrototypeOf;
	var __hasOwnProp$26 = Object.prototype.hasOwnProperty;
	var __export$26 = (target, all) => {
		for (var name$111 in all) __defProp$26(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$26 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$26(from)) if (!__hasOwnProp$26.call(to, key) && key !== except) __defProp$26(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$26(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$11 = (mod, isNodeMode, target) => (target = mod != null ? __create$11(__getProtoOf$11(mod)) : {}, __copyProps$26(isNodeMode || !mod || !mod.__esModule ? __defProp$26(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$26 = (mod) => __copyProps$26(__defProp$26({}, "__esModule", { value: true }), mod);
	var stdin_exports$26 = {};
	__export$26(stdin_exports$26, {
		SubmitBar: () => SubmitBar,
		default: () => stdin_default$22,
		submitBarProps: () => import_SubmitBar2.submitBarProps
	});
	module.exports = __toCommonJS$26(stdin_exports$26);
	var import_utils$21 = require_utils$9();
	var import_SubmitBar = __toESM$11(require_SubmitBar());
	var import_SubmitBar2 = require_SubmitBar();
	var SubmitBar = (0, import_utils$21.withInstall)(import_SubmitBar.default);
	var stdin_default$22 = SubmitBar;
}) });

//#endregion
//#region node_modules/vant/lib/swipe-cell/SwipeCell.js
var require_SwipeCell = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/swipe-cell/SwipeCell.js": ((exports, module) => {
	var __defProp$25 = Object.defineProperty;
	var __getOwnPropDesc$25 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$25 = Object.getOwnPropertyNames;
	var __hasOwnProp$25 = Object.prototype.hasOwnProperty;
	var __export$25 = (target, all) => {
		for (var name2 in all) __defProp$25(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$25 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$25(from)) if (!__hasOwnProp$25.call(to, key) && key !== except) __defProp$25(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$25(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$25 = (mod) => __copyProps$25(__defProp$25({}, "__esModule", { value: true }), mod);
	var stdin_exports$25 = {};
	__export$25(stdin_exports$25, {
		default: () => stdin_default$21,
		swipeCellProps: () => swipeCellProps
	});
	module.exports = __toCommonJS$25(stdin_exports$25);
	var import_vue$11 = require_vue();
	var import_utils$20 = require_utils$9();
	var import_use$7 = require_index_cjs$1();
	var import_use_touch = require_use_touch();
	var import_use_expose$3 = require_use_expose();
	var [name$7, bem$6] = (0, import_utils$20.createNamespace)("swipe-cell");
	var swipeCellProps = {
		name: (0, import_utils$20.makeNumericProp)(""),
		disabled: Boolean,
		leftWidth: import_utils$20.numericProp,
		rightWidth: import_utils$20.numericProp,
		beforeClose: Function,
		stopPropagation: Boolean
	};
	var stdin_default$21 = (0, import_vue$11.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 = (0, import_vue$11.ref)();
			const leftRef = (0, import_vue$11.ref)();
			const rightRef = (0, import_vue$11.ref)();
			const state = (0, import_vue$11.reactive)({
				offset: 0,
				dragging: false
			});
			const touch = (0, import_use_touch.useTouch)();
			const getWidthByRef = (ref2) => ref2.value ? (0, import_use$7.useRect)(ref2).width : 0;
			const leftWidth = (0, import_vue$11.computed)(() => (0, import_utils$20.isDef)(props$1.leftWidth) ? +props$1.leftWidth : getWidthByRef(leftRef));
			const rightWidth = (0, import_vue$11.computed)(() => (0, import_utils$20.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) (0, import_utils$20.preventDefault)(event, props$1.stopPropagation);
					state.offset = (0, import_utils$20.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;
					(0, import_utils$20.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 (0, import_vue$11.createVNode)("div", {
					"ref": ref2,
					"class": bem$6(side),
					"onClick": getClickHandler(side)
				}, [contentSlot()]);
			};
			(0, import_use_expose$3.useExpose)({
				open,
				close
			});
			(0, import_use$7.useClickAway)(root, (event) => onClick("outside", event), { eventName: "touchstart" });
			(0, import_use$7.useEventListener)("touchmove", onTouchMove, { target: root });
			return () => {
				var _a;
				const wrapperStyle = {
					transform: `translate3d(${state.offset}px, 0, 0)`,
					transitionDuration: state.dragging ? "0s" : ".6s"
				};
				return (0, import_vue$11.createVNode)("div", {
					"ref": root,
					"class": bem$6(),
					"onClick": getClickHandler("cell"),
					"onTouchstartPassive": onTouchStart,
					"onTouchend": onTouchEnd,
					"onTouchcancel": onTouchEnd
				}, [(0, import_vue$11.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/lib/swipe-cell/index.js
var require_swipe_cell = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/swipe-cell/index.js": ((exports, module) => {
	var __create$10 = Object.create;
	var __defProp$24 = Object.defineProperty;
	var __getOwnPropDesc$24 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$24 = Object.getOwnPropertyNames;
	var __getProtoOf$10 = Object.getPrototypeOf;
	var __hasOwnProp$24 = Object.prototype.hasOwnProperty;
	var __export$24 = (target, all) => {
		for (var name$111 in all) __defProp$24(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$24 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$24(from)) if (!__hasOwnProp$24.call(to, key) && key !== except) __defProp$24(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$24(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$10 = (mod, isNodeMode, target) => (target = mod != null ? __create$10(__getProtoOf$10(mod)) : {}, __copyProps$24(isNodeMode || !mod || !mod.__esModule ? __defProp$24(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$24 = (mod) => __copyProps$24(__defProp$24({}, "__esModule", { value: true }), mod);
	var stdin_exports$24 = {};
	__export$24(stdin_exports$24, {
		SwipeCell: () => SwipeCell,
		default: () => stdin_default$20,
		swipeCellProps: () => import_SwipeCell2.swipeCellProps
	});
	module.exports = __toCommonJS$24(stdin_exports$24);
	var import_utils$19 = require_utils$9();
	var import_SwipeCell = __toESM$10(require_SwipeCell());
	var import_SwipeCell2 = require_SwipeCell();
	var SwipeCell = (0, import_utils$19.withInstall)(import_SwipeCell.default);
	var stdin_default$20 = SwipeCell;
}) });

//#endregion
//#region node_modules/vant/lib/tabbar/Tabbar.js
var require_Tabbar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tabbar/Tabbar.js": ((exports, module) => {
	var __defProp$23 = Object.defineProperty;
	var __getOwnPropDesc$23 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$23 = Object.getOwnPropertyNames;
	var __hasOwnProp$23 = Object.prototype.hasOwnProperty;
	var __export$23 = (target, all) => {
		for (var name2 in all) __defProp$23(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$23 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$23(from)) if (!__hasOwnProp$23.call(to, key) && key !== except) __defProp$23(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$23(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$23 = (mod) => __copyProps$23(__defProp$23({}, "__esModule", { value: true }), mod);
	var stdin_exports$23 = {};
	__export$23(stdin_exports$23, {
		TABBAR_KEY: () => TABBAR_KEY,
		default: () => stdin_default$19,
		tabbarProps: () => tabbarProps
	});
	module.exports = __toCommonJS$23(stdin_exports$23);
	var import_vue$10 = require_vue();
	var import_utils$18 = require_utils$9();
	var import_use$6 = require_index_cjs$1();
	var import_use_placeholder = require_use_placeholder();
	var [name$6, bem$5] = (0, import_utils$18.createNamespace)("tabbar");
	var tabbarProps = {
		route: Boolean,
		fixed: import_utils$18.truthProp,
		border: import_utils$18.truthProp,
		zIndex: import_utils$18.numericProp,
		placeholder: Boolean,
		activeColor: String,
		beforeChange: Function,
		inactiveColor: String,
		modelValue: (0, import_utils$18.makeNumericProp)(0),
		safeAreaInsetBottom: {
			type: Boolean,
			default: null
		}
	};
	var TABBAR_KEY = Symbol(name$6);
	var stdin_default$19 = (0, import_vue$10.defineComponent)({
		name: name$6,
		props: tabbarProps,
		emits: ["change", "update:modelValue"],
		setup(props$1, { emit, slots }) {
			const root = (0, import_vue$10.ref)();
			const { linkChildren } = (0, import_use$6.useChildren)(TABBAR_KEY);
			const renderPlaceholder = (0, import_use_placeholder.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 (0, import_vue$10.createVNode)("div", {
					"ref": root,
					"role": "tablist",
					"style": (0, import_utils$18.getZIndexStyle)(zIndex),
					"class": [bem$5({ fixed }), {
						[import_utils$18.BORDER_TOP_BOTTOM]: border,
						"van-safe-area-bottom": enableSafeArea()
					}]
				}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
			};
			const setActive = (active, afterChange) => {
				(0, import_utils$18.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/lib/tabbar/index.js
var require_tabbar = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tabbar/index.js": ((exports, module) => {
	var __create$9 = Object.create;
	var __defProp$22 = Object.defineProperty;
	var __getOwnPropDesc$22 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$22 = Object.getOwnPropertyNames;
	var __getProtoOf$9 = Object.getPrototypeOf;
	var __hasOwnProp$22 = Object.prototype.hasOwnProperty;
	var __export$22 = (target, all) => {
		for (var name$111 in all) __defProp$22(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$22 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$22(from)) if (!__hasOwnProp$22.call(to, key) && key !== except) __defProp$22(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$22(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$9 = (mod, isNodeMode, target) => (target = mod != null ? __create$9(__getProtoOf$9(mod)) : {}, __copyProps$22(isNodeMode || !mod || !mod.__esModule ? __defProp$22(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$22 = (mod) => __copyProps$22(__defProp$22({}, "__esModule", { value: true }), mod);
	var stdin_exports$22 = {};
	__export$22(stdin_exports$22, {
		Tabbar: () => Tabbar,
		default: () => stdin_default$18,
		tabbarProps: () => import_Tabbar2.tabbarProps
	});
	module.exports = __toCommonJS$22(stdin_exports$22);
	var import_utils$17 = require_utils$9();
	var import_Tabbar$1 = __toESM$9(require_Tabbar());
	var import_Tabbar2 = require_Tabbar();
	var Tabbar = (0, import_utils$17.withInstall)(import_Tabbar$1.default);
	var stdin_default$18 = Tabbar;
}) });

//#endregion
//#region node_modules/vant/lib/tabbar-item/TabbarItem.js
var require_TabbarItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tabbar-item/TabbarItem.js": ((exports, module) => {
	var __defProp$21 = Object.defineProperty;
	var __getOwnPropDesc$21 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$21 = Object.getOwnPropertyNames;
	var __hasOwnProp$21 = Object.prototype.hasOwnProperty;
	var __export$21 = (target, all) => {
		for (var name2 in all) __defProp$21(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$21 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$21(from)) if (!__hasOwnProp$21.call(to, key) && key !== except) __defProp$21(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$21(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$21 = (mod) => __copyProps$21(__defProp$21({}, "__esModule", { value: true }), mod);
	var stdin_exports$21 = {};
	__export$21(stdin_exports$21, {
		default: () => stdin_default$17,
		tabbarItemProps: () => tabbarItemProps
	});
	module.exports = __toCommonJS$21(stdin_exports$21);
	var import_vue$9 = require_vue();
	var import_utils$16 = require_utils$9();
	var import_Tabbar = require_Tabbar();
	var import_use$5 = require_index_cjs$1();
	var import_use_route = require_use_route();
	var import_icon$4 = require_icon();
	var import_badge$1 = require_badge();
	var [name$5, bem$4] = (0, import_utils$16.createNamespace)("tabbar-item");
	var tabbarItemProps = (0, import_utils$16.extend)({}, import_use_route.routeProps, {
		dot: Boolean,
		icon: String,
		name: import_utils$16.numericProp,
		badge: import_utils$16.numericProp,
		badgeProps: Object,
		iconPrefix: String
	});
	var stdin_default$17 = (0, import_vue$9.defineComponent)({
		name: name$5,
		props: tabbarItemProps,
		emits: ["click"],
		setup(props$1, { emit, slots }) {
			const route$1 = (0, import_use_route.useRoute)();
			const vm = (0, import_vue$9.getCurrentInstance)().proxy;
			const { parent, index } = (0, import_use$5.useParent)(import_Tabbar.TABBAR_KEY);
			if (!parent) {
				console.error("[Vant] <TabbarItem> must be a child component of <Tabbar>.");
				return;
			}
			const active = (0, import_vue$9.computed)(() => {
				var _a;
				const { route: route2, modelValue } = parent.props;
				if (route2 && "$route" in vm) {
					const { $route } = vm;
					const { to } = props$1;
					const config = (0, import_utils$16.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 (0, import_vue$9.createVNode)(import_icon$4.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 (0, import_vue$9.createVNode)("div", {
					"role": "tab",
					"class": bem$4({ active: active.value }),
					"style": { color },
					"tabindex": 0,
					"aria-selected": active.value,
					"onClick": onClick
				}, [(0, import_vue$9.createVNode)(import_badge$1.Badge, (0, import_vue$9.mergeProps)({
					"dot": dot,
					"class": bem$4("icon"),
					"content": badge
				}, props$1.badgeProps), { default: renderIcon }), (0, import_vue$9.createVNode)("div", { "class": bem$4("text") }, [(_a = slots.default) == null ? void 0 : _a.call(slots, { active: active.value })])]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/tabbar-item/index.js
var require_tabbar_item = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tabbar-item/index.js": ((exports, module) => {
	var __create$8 = Object.create;
	var __defProp$20 = Object.defineProperty;
	var __getOwnPropDesc$20 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$20 = Object.getOwnPropertyNames;
	var __getProtoOf$8 = Object.getPrototypeOf;
	var __hasOwnProp$20 = Object.prototype.hasOwnProperty;
	var __export$20 = (target, all) => {
		for (var name$111 in all) __defProp$20(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$20 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$20(from)) if (!__hasOwnProp$20.call(to, key) && key !== except) __defProp$20(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$20(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$8 = (mod, isNodeMode, target) => (target = mod != null ? __create$8(__getProtoOf$8(mod)) : {}, __copyProps$20(isNodeMode || !mod || !mod.__esModule ? __defProp$20(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$20 = (mod) => __copyProps$20(__defProp$20({}, "__esModule", { value: true }), mod);
	var stdin_exports$20 = {};
	__export$20(stdin_exports$20, {
		TabbarItem: () => TabbarItem,
		default: () => stdin_default$16,
		tabbarItemProps: () => import_TabbarItem2.tabbarItemProps
	});
	module.exports = __toCommonJS$20(stdin_exports$20);
	var import_utils$15 = require_utils$9();
	var import_TabbarItem = __toESM$8(require_TabbarItem());
	var import_TabbarItem2 = require_TabbarItem();
	var TabbarItem = (0, import_utils$15.withInstall)(import_TabbarItem.default);
	var stdin_default$16 = TabbarItem;
}) });

//#endregion
//#region node_modules/vant/lib/text-ellipsis/TextEllipsis.js
var require_TextEllipsis = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/text-ellipsis/TextEllipsis.js": ((exports, module) => {
	var __defProp$19 = Object.defineProperty;
	var __getOwnPropDesc$19 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$19 = Object.getOwnPropertyNames;
	var __hasOwnProp$19 = Object.prototype.hasOwnProperty;
	var __export$19 = (target, all) => {
		for (var name2 in all) __defProp$19(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$19 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$19(from)) if (!__hasOwnProp$19.call(to, key) && key !== except) __defProp$19(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$19(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$19 = (mod) => __copyProps$19(__defProp$19({}, "__esModule", { value: true }), mod);
	var stdin_exports$19 = {};
	__export$19(stdin_exports$19, {
		default: () => stdin_default$15,
		textEllipsisProps: () => textEllipsisProps
	});
	module.exports = __toCommonJS$19(stdin_exports$19);
	var import_vue$8 = require_vue();
	var import_utils$14 = require_utils$9();
	var import_use_expose$2 = require_use_expose();
	var [name$4, bem$3] = (0, import_utils$14.createNamespace)("text-ellipsis");
	var textEllipsisProps = {
		rows: (0, import_utils$14.makeNumericProp)(1),
		dots: (0, import_utils$14.makeStringProp)("..."),
		content: (0, import_utils$14.makeStringProp)(""),
		expandText: (0, import_utils$14.makeStringProp)(""),
		collapseText: (0, import_utils$14.makeStringProp)(""),
		position: (0, import_utils$14.makeStringProp)("end")
	};
	var stdin_default$15 = (0, import_vue$8.defineComponent)({
		name: name$4,
		props: textEllipsisProps,
		emits: ["clickAction"],
		setup(props$1, { emit, slots }) {
			const text = (0, import_vue$8.ref)(props$1.content);
			const expanded = (0, import_vue$8.ref)(false);
			const hasAction = (0, import_vue$8.ref)(false);
			const root = (0, import_vue$8.ref)();
			const actionRef = (0, import_vue$8.ref)();
			let needRecalculate = false;
			const actionText = (0, import_vue$8.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 (0, import_vue$8.createVNode)("span", {
					"ref": actionRef,
					"class": bem$3("action"),
					"onClick": onClickAction
				}, [action]);
			};
			(0, import_vue$8.onMounted)(() => {
				calcEllipsised();
				if (slots.action) (0, import_vue$8.nextTick)(calcEllipsised);
			});
			(0, import_vue$8.onActivated)(() => {
				if (needRecalculate) {
					needRecalculate = false;
					calcEllipsised();
				}
			});
			(0, import_vue$8.watch)([import_utils$14.windowWidth, () => [
				props$1.content,
				props$1.rows,
				props$1.position
			]], calcEllipsised);
			(0, import_use_expose$2.useExpose)({ toggle });
			return () => (0, import_vue$8.createVNode)("div", {
				"ref": root,
				"class": bem$3()
			}, [expanded.value ? props$1.content : text.value, hasAction.value ? renderAction() : null]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/text-ellipsis/index.js
var require_text_ellipsis = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/text-ellipsis/index.js": ((exports, module) => {
	var __create$7 = Object.create;
	var __defProp$18 = Object.defineProperty;
	var __getOwnPropDesc$18 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$18 = Object.getOwnPropertyNames;
	var __getProtoOf$7 = Object.getPrototypeOf;
	var __hasOwnProp$18 = Object.prototype.hasOwnProperty;
	var __export$18 = (target, all) => {
		for (var name$111 in all) __defProp$18(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$18 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$18(from)) if (!__hasOwnProp$18.call(to, key) && key !== except) __defProp$18(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$18(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$7 = (mod, isNodeMode, target) => (target = mod != null ? __create$7(__getProtoOf$7(mod)) : {}, __copyProps$18(isNodeMode || !mod || !mod.__esModule ? __defProp$18(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$18 = (mod) => __copyProps$18(__defProp$18({}, "__esModule", { value: true }), mod);
	var stdin_exports$18 = {};
	__export$18(stdin_exports$18, {
		TextEllipsis: () => TextEllipsis,
		default: () => stdin_default$14,
		textEllipsisProps: () => import_TextEllipsis2.textEllipsisProps
	});
	module.exports = __toCommonJS$18(stdin_exports$18);
	var import_utils$13 = require_utils$9();
	var import_TextEllipsis = __toESM$7(require_TextEllipsis());
	var import_TextEllipsis2 = require_TextEllipsis();
	var TextEllipsis = (0, import_utils$13.withInstall)(import_TextEllipsis.default);
	var stdin_default$14 = TextEllipsis;
}) });

//#endregion
//#region node_modules/vant/lib/time-picker/TimePicker.js
var require_TimePicker = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/time-picker/TimePicker.js": ((exports, module) => {
	var __defProp$17 = Object.defineProperty;
	var __getOwnPropDesc$17 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$17 = Object.getOwnPropertyNames;
	var __hasOwnProp$17 = Object.prototype.hasOwnProperty;
	var __export$17 = (target, all) => {
		for (var name2 in all) __defProp$17(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$17 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$17(from)) if (!__hasOwnProp$17.call(to, key) && key !== except) __defProp$17(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$17(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$17 = (mod) => __copyProps$17(__defProp$17({}, "__esModule", { value: true }), mod);
	var stdin_exports$17 = {};
	__export$17(stdin_exports$17, {
		default: () => stdin_default$13,
		timePickerProps: () => timePickerProps
	});
	module.exports = __toCommonJS$17(stdin_exports$17);
	var import_vue$7 = require_vue();
	var import_utils$12 = require_utils$3();
	var import_utils2$2 = require_utils$9();
	var import_use_expose$1 = require_use_expose();
	var import_picker$1 = require_picker();
	var [name$3] = (0, import_utils2$2.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 = (0, import_utils2$2.extend)({}, import_utils$12.sharedProps, {
		minHour: (0, import_utils2$2.makeNumericProp)(0),
		maxHour: (0, import_utils2$2.makeNumericProp)(23),
		minMinute: (0, import_utils2$2.makeNumericProp)(0),
		maxMinute: (0, import_utils2$2.makeNumericProp)(59),
		minSecond: (0, import_utils2$2.makeNumericProp)(0),
		maxSecond: (0, import_utils2$2.makeNumericProp)(59),
		minTime: {
			type: String,
			validator: validateTime
		},
		maxTime: {
			type: String,
			validator: validateTime
		},
		columnsType: {
			type: Array,
			default: () => ["hour", "minute"]
		}
	});
	var stdin_default$13 = (0, import_vue$7.defineComponent)({
		name: name$3,
		props: timePickerProps,
		emits: [
			"confirm",
			"cancel",
			"change",
			"update:modelValue"
		],
		setup(props$1, { emit, slots }) {
			const currentValues = (0, import_vue$7.ref)(props$1.modelValue);
			const pickerRef = (0, import_vue$7.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 = (0, import_vue$7.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 (0, import_utils$12.genOptions)(+minHour, +maxHour, type, formatter, filter, currentValues.value);
						case "minute": return (0, import_utils$12.genOptions)(+minMinute, +maxMinute, type, formatter, filter, currentValues.value);
						case "second": return (0, import_utils$12.genOptions)(+minSecond, +maxSecond, type, formatter, filter, currentValues.value);
						default: throw new Error(`[Vant] DatePicker: unsupported columns type: ${type}`);
					}
				});
			});
			(0, import_vue$7.watch)(currentValues, (newValues) => {
				if (!(0, import_utils2$2.isSameValue)(newValues, props$1.modelValue)) emit("update:modelValue", newValues);
			});
			(0, import_vue$7.watch)(() => props$1.modelValue, (newValues) => {
				newValues = (0, import_utils$12.formatValueRange)(newValues, columns.value);
				if (!(0, import_utils2$2.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);
			(0, import_use_expose$1.useExpose)({
				confirm,
				getSelectedTime
			});
			return () => (0, import_vue$7.createVNode)(import_picker$1.Picker, (0, import_vue$7.mergeProps)({
				"ref": pickerRef,
				"modelValue": currentValues.value,
				"onUpdate:modelValue": ($event) => currentValues.value = $event,
				"columns": columns.value,
				"onChange": onChange,
				"onCancel": onCancel,
				"onConfirm": onConfirm
			}, (0, import_utils2$2.pick)(props$1, import_utils$12.pickerInheritKeys)), slots);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/time-picker/index.js
var require_time_picker = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/time-picker/index.js": ((exports, module) => {
	var __create$6 = Object.create;
	var __defProp$16 = Object.defineProperty;
	var __getOwnPropDesc$16 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$16 = Object.getOwnPropertyNames;
	var __getProtoOf$6 = Object.getPrototypeOf;
	var __hasOwnProp$16 = Object.prototype.hasOwnProperty;
	var __export$16 = (target, all) => {
		for (var name$111 in all) __defProp$16(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$16 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$16(from)) if (!__hasOwnProp$16.call(to, key) && key !== except) __defProp$16(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$16(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$6 = (mod, isNodeMode, target) => (target = mod != null ? __create$6(__getProtoOf$6(mod)) : {}, __copyProps$16(isNodeMode || !mod || !mod.__esModule ? __defProp$16(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$16 = (mod) => __copyProps$16(__defProp$16({}, "__esModule", { value: true }), mod);
	var stdin_exports$16 = {};
	__export$16(stdin_exports$16, {
		TimePicker: () => TimePicker,
		default: () => stdin_default$12,
		timePickerProps: () => import_TimePicker2.timePickerProps
	});
	module.exports = __toCommonJS$16(stdin_exports$16);
	var import_utils$11 = require_utils$9();
	var import_TimePicker = __toESM$6(require_TimePicker());
	var import_TimePicker2 = require_TimePicker();
	var TimePicker = (0, import_utils$11.withInstall)(import_TimePicker.default);
	var stdin_default$12 = TimePicker;
}) });

//#endregion
//#region node_modules/vant/lib/tree-select/TreeSelect.js
var require_TreeSelect = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tree-select/TreeSelect.js": ((exports, module) => {
	var __defProp$15 = Object.defineProperty;
	var __getOwnPropDesc$15 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$15 = Object.getOwnPropertyNames;
	var __hasOwnProp$15 = Object.prototype.hasOwnProperty;
	var __export$15 = (target, all) => {
		for (var name2 in all) __defProp$15(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$15 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$15(from)) if (!__hasOwnProp$15.call(to, key) && key !== except) __defProp$15(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$15(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$15 = (mod) => __copyProps$15(__defProp$15({}, "__esModule", { value: true }), mod);
	var stdin_exports$15 = {};
	__export$15(stdin_exports$15, {
		default: () => stdin_default$11,
		treeSelectProps: () => treeSelectProps
	});
	module.exports = __toCommonJS$15(stdin_exports$15);
	var import_vue$6 = require_vue();
	var import_utils$10 = require_utils$9();
	var import_icon$3 = require_icon();
	var import_sidebar$1 = require_sidebar();
	var import_sidebar_item$1 = require_sidebar_item();
	var [name$2, bem$2] = (0, import_utils$10.createNamespace)("tree-select");
	var treeSelectProps = {
		max: (0, import_utils$10.makeNumericProp)(Infinity),
		items: (0, import_utils$10.makeArrayProp)(),
		height: (0, import_utils$10.makeNumericProp)(300),
		selectedIcon: (0, import_utils$10.makeStringProp)("success"),
		mainActiveIndex: (0, import_utils$10.makeNumericProp)(0),
		activeId: {
			type: [
				Number,
				String,
				Array
			],
			default: 0
		}
	};
	var stdin_default$11 = (0, import_vue$6.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 (0, import_vue$6.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) && (0, import_vue$6.createVNode)(import_icon$3.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) => (0, import_vue$6.createVNode)(import_sidebar_item$1.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 (0, import_vue$6.createVNode)(import_sidebar$1.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 () => (0, import_vue$6.createVNode)("div", {
				"class": bem$2(),
				"style": { height: (0, import_utils$10.addUnit)(props$1.height) }
			}, [renderSidebar(), (0, import_vue$6.createVNode)("div", { "class": bem$2("content") }, [renderContent()])]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/tree-select/index.js
var require_tree_select = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/tree-select/index.js": ((exports, module) => {
	var __create$5 = Object.create;
	var __defProp$14 = Object.defineProperty;
	var __getOwnPropDesc$14 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$14 = Object.getOwnPropertyNames;
	var __getProtoOf$5 = Object.getPrototypeOf;
	var __hasOwnProp$14 = Object.prototype.hasOwnProperty;
	var __export$14 = (target, all) => {
		for (var name$111 in all) __defProp$14(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$14 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$14(from)) if (!__hasOwnProp$14.call(to, key) && key !== except) __defProp$14(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$14(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$5 = (mod, isNodeMode, target) => (target = mod != null ? __create$5(__getProtoOf$5(mod)) : {}, __copyProps$14(isNodeMode || !mod || !mod.__esModule ? __defProp$14(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$14 = (mod) => __copyProps$14(__defProp$14({}, "__esModule", { value: true }), mod);
	var stdin_exports$14 = {};
	__export$14(stdin_exports$14, {
		TreeSelect: () => TreeSelect,
		default: () => stdin_default$10,
		treeSelectProps: () => import_TreeSelect2.treeSelectProps
	});
	module.exports = __toCommonJS$14(stdin_exports$14);
	var import_utils$9 = require_utils$9();
	var import_TreeSelect = __toESM$5(require_TreeSelect());
	var import_TreeSelect2 = require_TreeSelect();
	var TreeSelect = (0, import_utils$9.withInstall)(import_TreeSelect.default);
	var stdin_default$10 = TreeSelect;
}) });

//#endregion
//#region node_modules/vant/lib/uploader/utils.js
var require_utils = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/uploader/utils.js": ((exports, module) => {
	var __defProp$13 = Object.defineProperty;
	var __getOwnPropDesc$13 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$13 = Object.getOwnPropertyNames;
	var __hasOwnProp$13 = Object.prototype.hasOwnProperty;
	var __export$13 = (target, all) => {
		for (var name2 in all) __defProp$13(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$13 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$13(from)) if (!__hasOwnProp$13.call(to, key) && key !== except) __defProp$13(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$13(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$13 = (mod) => __copyProps$13(__defProp$13({}, "__esModule", { value: true }), mod);
	var stdin_exports$13 = {};
	__export$13(stdin_exports$13, {
		bem: () => bem$1,
		filterFiles: () => filterFiles,
		isImageFile: () => isImageFile,
		isImageUrl: () => isImageUrl,
		isOversize: () => isOversize,
		name: () => name$1,
		readFileContent: () => readFileContent,
		t: () => t
	});
	module.exports = __toCommonJS$13(stdin_exports$13);
	var import_utils$8 = require_utils$9();
	var [name$1, bem$1, t] = (0, import_utils$8.createNamespace)("uploader");
	function readFileContent(file, resultType) {
		return new Promise((resolve) => {
			if (resultType === "file") {
				resolve();
				return;
			}
			const reader = new FileReader();
			reader.onload = (event) => {
				resolve(event.target.result);
			};
			if (resultType === "dataUrl") reader.readAsDataURL(file);
			else if (resultType === "text") reader.readAsText(file);
		});
	}
	function isOversize(items, maxSize) {
		return (0, import_utils$8.toArray)(items).some((item) => {
			if (item.file) {
				if ((0, import_utils$8.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/lib/uploader/UploaderPreviewItem.js
var require_UploaderPreviewItem = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/uploader/UploaderPreviewItem.js": ((exports, module) => {
	var __defProp$12 = Object.defineProperty;
	var __getOwnPropDesc$12 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$12 = Object.getOwnPropertyNames;
	var __hasOwnProp$12 = Object.prototype.hasOwnProperty;
	var __export$12 = (target, all) => {
		for (var name$111 in all) __defProp$12(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$12 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$12(from)) if (!__hasOwnProp$12.call(to, key) && key !== except) __defProp$12(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$12(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$12 = (mod) => __copyProps$12(__defProp$12({}, "__esModule", { value: true }), mod);
	var stdin_exports$12 = {};
	__export$12(stdin_exports$12, { default: () => stdin_default$9 });
	module.exports = __toCommonJS$12(stdin_exports$12);
	var import_vue$5 = require_vue();
	var import_utils$7 = require_utils();
	var import_utils2$1 = require_utils$9();
	var import_icon$2 = require_icon();
	var import_image$1 = require_image();
	var import_loading$1 = require_loading();
	var stdin_default$9 = (0, import_vue$5.defineComponent)({
		props: {
			name: import_utils2$1.numericProp,
			item: (0, import_utils2$1.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" ? (0, import_vue$5.createVNode)(import_icon$2.Icon, {
						"name": "close",
						"class": (0, import_utils$7.bem)("mask-icon")
					}, null) : (0, import_vue$5.createVNode)(import_loading$1.Loading, { "class": (0, import_utils$7.bem)("loading") }, null);
					const showMessage = (0, import_utils2$1.isDef)(message) && message !== "";
					return (0, import_vue$5.createVNode)("div", { "class": (0, import_utils$7.bem)("mask") }, [MaskIcon, showMessage && (0, import_vue$5.createVNode)("div", { "class": (0, import_utils$7.bem)("mask-message") }, [message])]);
				}
			};
			const onDelete = (event) => {
				const { name: name$111, item, index, beforeDelete } = props$1;
				event.stopPropagation();
				(0, import_utils2$1.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 (0, import_vue$5.createVNode)("div", {
						"role": "button",
						"class": (0, import_utils$7.bem)("preview-delete", { shadow: !slot }),
						"tabindex": 0,
						"aria-label": (0, import_utils$7.t)("delete"),
						"onClick": onDelete
					}, [slot ? slot() : (0, import_vue$5.createVNode)(import_icon$2.Icon, {
						"name": "cross",
						"class": (0, import_utils$7.bem)("preview-delete-icon")
					}, null)]);
				}
			};
			const renderCover = () => {
				if (slots["preview-cover"]) {
					const { index, item } = props$1;
					return (0, import_vue$5.createVNode)("div", { "class": (0, import_utils$7.bem)("preview-cover") }, [slots["preview-cover"]((0, import_utils2$1.extend)({ index }, item))]);
				}
			};
			const renderPreview = () => {
				const { item, lazyLoad, imageFit, previewSize, reupload } = props$1;
				if ((0, import_utils$7.isImageFile)(item)) return (0, import_vue$5.createVNode)(import_image$1.Image, {
					"fit": imageFit,
					"src": item.objectUrl || item.content || item.url,
					"class": (0, import_utils$7.bem)("preview-image"),
					"width": Array.isArray(previewSize) ? previewSize[0] : previewSize,
					"height": Array.isArray(previewSize) ? previewSize[1] : previewSize,
					"lazyLoad": lazyLoad,
					"onClick": reupload ? onReupload : onPreview
				}, { default: renderCover });
				return (0, import_vue$5.createVNode)("div", {
					"class": (0, import_utils$7.bem)("file"),
					"style": (0, import_utils2$1.getSizeStyle)(props$1.previewSize)
				}, [
					(0, import_vue$5.createVNode)(import_icon$2.Icon, {
						"class": (0, import_utils$7.bem)("file-icon"),
						"name": "description"
					}, null),
					(0, import_vue$5.createVNode)("div", { "class": [(0, import_utils$7.bem)("file-name"), "van-ellipsis"] }, [item.file ? item.file.name : item.url]),
					renderCover()
				]);
			};
			return () => (0, import_vue$5.createVNode)("div", { "class": (0, import_utils$7.bem)("preview") }, [
				renderPreview(),
				renderMask(),
				renderDeleteIcon()
			]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/uploader/Uploader.js
var require_Uploader = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/uploader/Uploader.js": ((exports, module) => {
	var __create$4 = Object.create;
	var __defProp$11 = Object.defineProperty;
	var __getOwnPropDesc$11 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$11 = Object.getOwnPropertyNames;
	var __getProtoOf$4 = Object.getPrototypeOf;
	var __hasOwnProp$11 = Object.prototype.hasOwnProperty;
	var __export$11 = (target, all) => {
		for (var name2 in all) __defProp$11(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$11 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$11(from)) if (!__hasOwnProp$11.call(to, key) && key !== except) __defProp$11(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$11(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$4 = (mod, isNodeMode, target) => (target = mod != null ? __create$4(__getProtoOf$4(mod)) : {}, __copyProps$11(isNodeMode || !mod || !mod.__esModule ? __defProp$11(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$11 = (mod) => __copyProps$11(__defProp$11({}, "__esModule", { value: true }), mod);
	var stdin_exports$11 = {};
	__export$11(stdin_exports$11, {
		default: () => stdin_default$8,
		uploaderProps: () => uploaderProps
	});
	module.exports = __toCommonJS$11(stdin_exports$11);
	var import_vue$4 = require_vue();
	var import_utils$6 = require_utils$9();
	var import_utils2 = require_utils();
	var import_use$4 = require_index_cjs$1();
	var import_use_expose = require_use_expose();
	var import_icon$1 = require_icon();
	var import_image_preview$1 = require_image_preview();
	var import_UploaderPreviewItem = __toESM$4(require_UploaderPreviewItem());
	var uploaderProps = {
		name: (0, import_utils$6.makeNumericProp)(""),
		accept: (0, import_utils$6.makeStringProp)("image/*"),
		capture: String,
		multiple: Boolean,
		disabled: Boolean,
		readonly: Boolean,
		lazyLoad: Boolean,
		maxCount: (0, import_utils$6.makeNumericProp)(Infinity),
		imageFit: (0, import_utils$6.makeStringProp)("cover"),
		resultType: (0, import_utils$6.makeStringProp)("dataUrl"),
		uploadIcon: (0, import_utils$6.makeStringProp)("photograph"),
		uploadText: String,
		deletable: import_utils$6.truthProp,
		reupload: Boolean,
		afterRead: Function,
		showUpload: import_utils$6.truthProp,
		modelValue: (0, import_utils$6.makeArrayProp)(),
		beforeRead: Function,
		beforeDelete: Function,
		previewSize: [
			Number,
			String,
			Array
		],
		previewImage: import_utils$6.truthProp,
		previewOptions: Object,
		previewFullImage: import_utils$6.truthProp,
		maxSize: {
			type: [
				Number,
				String,
				Function
			],
			default: Infinity
		}
	};
	var stdin_default$8 = (0, import_vue$4.defineComponent)({
		name: import_utils2.name,
		props: uploaderProps,
		emits: [
			"delete",
			"oversize",
			"clickUpload",
			"closePreview",
			"clickPreview",
			"clickReupload",
			"update:modelValue"
		],
		setup(props$1, { emit, slots }) {
			const inputRef = (0, import_vue$4.ref)();
			const urls = [];
			const reuploadIndex = (0, import_vue$4.ref)(-1);
			const isReuploading = (0, import_vue$4.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 ((0, import_utils2.isOversize)(items, props$1.maxSize)) if (Array.isArray(items)) {
					const result = (0, import_utils2.filterFiles)(items, props$1.maxSize);
					items = result.valid;
					emit("oversize", result.invalid, getDetail());
					if (!items.length) return;
				} else {
					emit("oversize", items, getDetail());
					return;
				}
				items = (0, import_vue$4.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, ...(0, import_utils$6.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) => (0, import_utils2.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 (0, import_utils2.readFileContent)(files, resultType).then((content) => {
					const result = {
						file: files,
						status: "",
						message: "",
						objectUrl: URL.createObjectURL(files)
					};
					if (content) result.content = content;
					onAfterRead(result);
				});
			};
			const onChange = (event) => {
				const { files } = event.target;
				if (props$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 ((0, import_utils$6.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(import_utils2.isImageFile);
					const images = imageFiles.map((item2) => {
						if (item2.objectUrl && !item2.url && item2.status !== "failed") {
							item2.url = item2.objectUrl;
							urls.push(item2.url);
						}
						return item2.url;
					}).filter(Boolean);
					imagePreview = (0, import_image_preview$1.showImagePreview)((0, import_utils$6.extend)({
						images,
						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;
				(0, import_vue$4.nextTick)(() => chooseFile());
			};
			const onInputClick = () => {
				if (!isReuploading.value) reuploadIndex.value = -1;
				isReuploading.value = false;
			};
			const renderPreviewItem = (item, index) => {
				const needPickData = [
					"imageFit",
					"deletable",
					"reupload",
					"previewSize",
					"beforeDelete"
				];
				const previewData = (0, import_utils$6.extend)((0, import_utils$6.pick)(props$1, needPickData), (0, import_utils$6.pick)(item, needPickData, true));
				return (0, import_vue$4.createVNode)(import_UploaderPreviewItem.default, (0, import_vue$4.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)
				}, (0, import_utils$6.pick)(props$1, ["name", "lazyLoad"]), previewData), (0, import_utils$6.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 : (0, import_vue$4.createVNode)("input", {
					"ref": inputRef,
					"type": "file",
					"class": (0, import_utils2.bem)("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 (0, import_vue$4.withDirectives)((0, import_vue$4.createVNode)("div", {
					"class": (0, import_utils2.bem)("input-wrapper"),
					"onClick": onClickUpload
				}, [slots.default(), Input]), [[import_vue$4.vShow, lessThanMax]]);
				return (0, import_vue$4.withDirectives)((0, import_vue$4.createVNode)("div", {
					"class": (0, import_utils2.bem)("upload", { readonly: props$1.readonly }),
					"style": (0, import_utils$6.getSizeStyle)(props$1.previewSize),
					"onClick": onClickUpload
				}, [
					(0, import_vue$4.createVNode)(import_icon$1.Icon, {
						"name": props$1.uploadIcon,
						"class": (0, import_utils2.bem)("upload-icon")
					}, null),
					props$1.uploadText && (0, import_vue$4.createVNode)("span", { "class": (0, import_utils2.bem)("upload-text") }, [props$1.uploadText]),
					Input
				]), [[import_vue$4.vShow, props$1.showUpload && lessThanMax]]);
			};
			const chooseFile = () => {
				if (inputRef.value && !props$1.disabled) inputRef.value.click();
			};
			(0, import_vue$4.onBeforeUnmount)(() => {
				urls.forEach((url) => URL.revokeObjectURL(url));
			});
			(0, import_use_expose.useExpose)({
				chooseFile,
				reuploadFile,
				closeImagePreview
			});
			(0, import_use$4.useCustomFieldValue)(() => props$1.modelValue);
			return () => (0, import_vue$4.createVNode)("div", { "class": (0, import_utils2.bem)() }, [(0, import_vue$4.createVNode)("div", { "class": (0, import_utils2.bem)("wrapper", { disabled: props$1.disabled }) }, [renderPreviewList(), renderUpload()])]);
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/uploader/index.js
var require_uploader = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/uploader/index.js": ((exports, module) => {
	var __create$3 = Object.create;
	var __defProp$10 = Object.defineProperty;
	var __getOwnPropDesc$10 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$10 = Object.getOwnPropertyNames;
	var __getProtoOf$3 = Object.getPrototypeOf;
	var __hasOwnProp$10 = Object.prototype.hasOwnProperty;
	var __export$10 = (target, all) => {
		for (var name$111 in all) __defProp$10(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$10 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$10(from)) if (!__hasOwnProp$10.call(to, key) && key !== except) __defProp$10(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$10(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$3 = (mod, isNodeMode, target) => (target = mod != null ? __create$3(__getProtoOf$3(mod)) : {}, __copyProps$10(isNodeMode || !mod || !mod.__esModule ? __defProp$10(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$10 = (mod) => __copyProps$10(__defProp$10({}, "__esModule", { value: true }), mod);
	var stdin_exports$10 = {};
	__export$10(stdin_exports$10, {
		Uploader: () => Uploader,
		default: () => stdin_default$7,
		uploaderProps: () => import_Uploader2.uploaderProps
	});
	module.exports = __toCommonJS$10(stdin_exports$10);
	var import_utils$5 = require_utils$9();
	var import_Uploader = __toESM$3(require_Uploader());
	var import_Uploader2 = require_Uploader();
	var Uploader = (0, import_utils$5.withInstall)(import_Uploader.default);
	var stdin_default$7 = Uploader;
}) });

//#endregion
//#region node_modules/vant/lib/watermark/Watermark.js
var require_Watermark = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/watermark/Watermark.js": ((exports, module) => {
	var __defProp$9 = Object.defineProperty;
	var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$9 = Object.getOwnPropertyNames;
	var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
	var __export$9 = (target, all) => {
		for (var name2 in all) __defProp$9(target, name2, {
			get: all[name2],
			enumerable: true
		});
	};
	var __copyProps$9 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$9(from)) if (!__hasOwnProp$9.call(to, key) && key !== except) __defProp$9(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$9(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$9 = (mod) => __copyProps$9(__defProp$9({}, "__esModule", { value: true }), mod);
	var stdin_exports$9 = {};
	__export$9(stdin_exports$9, {
		default: () => stdin_default$6,
		watermarkProps: () => watermarkProps
	});
	module.exports = __toCommonJS$9(stdin_exports$9);
	var import_vue$3 = require_vue();
	var import_utils$4 = require_utils$9();
	var [name, bem] = (0, import_utils$4.createNamespace)("watermark");
	var watermarkProps = {
		gapX: (0, import_utils$4.makeNumberProp)(0),
		gapY: (0, import_utils$4.makeNumberProp)(0),
		image: String,
		width: (0, import_utils$4.makeNumberProp)(100),
		height: (0, import_utils$4.makeNumberProp)(100),
		rotate: (0, import_utils$4.makeNumericProp)(-22),
		zIndex: import_utils$4.numericProp,
		content: String,
		opacity: import_utils$4.numericProp,
		fullPage: import_utils$4.truthProp,
		textColor: (0, import_utils$4.makeStringProp)("#dcdee0")
	};
	var stdin_default$6 = (0, import_vue$3.defineComponent)({
		name,
		props: watermarkProps,
		setup(props$1, { slots }) {
			const svgElRef = (0, import_vue$3.ref)();
			const watermarkUrl = (0, import_vue$3.ref)("");
			const imageBase64 = (0, import_vue$3.ref)("");
			const renderWatermark = () => {
				const rotateStyle = {
					transformOrigin: "center",
					transform: `rotate(${props$1.rotate}deg)`
				};
				const svgInner = () => {
					if (props$1.image && !slots.content) return (0, import_vue$3.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 (0, import_vue$3.createVNode)("foreignObject", {
						"x": "0",
						"y": "0",
						"width": props$1.width,
						"height": props$1.height
					}, [(0, import_vue$3.createVNode)("div", {
						"xmlns": "http://www.w3.org/1999/xhtml",
						"style": rotateStyle
					}, [slots.content ? slots.content() : (0, import_vue$3.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 (0, import_vue$3.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);
				}
			};
			(0, import_vue$3.watchEffect)(() => {
				if (props$1.image) makeImageToBase64(props$1.image);
			});
			(0, import_vue$3.watch)(() => [
				props$1.content,
				props$1.textColor,
				props$1.height,
				props$1.width,
				props$1.rotate,
				props$1.gapX,
				props$1.gapY
			], generateWatermarkUrl);
			(0, import_vue$3.watch)(imageBase64, () => {
				(0, import_vue$3.nextTick)(generateWatermarkUrl);
			});
			(0, import_vue$3.onMounted)(generateWatermarkUrl);
			(0, import_vue$3.onUnmounted)(revokeWatermarkUrl);
			return () => {
				const style = (0, import_utils$4.extend)({ backgroundImage: `url(${watermarkUrl.value})` }, (0, import_utils$4.getZIndexStyle)(props$1.zIndex));
				return (0, import_vue$3.createVNode)("div", {
					"class": bem({ full: props$1.fullPage }),
					"style": style
				}, [(0, import_vue$3.createVNode)("div", {
					"class": bem("wrapper"),
					"ref": svgElRef
				}, [renderWatermark()])]);
			};
		}
	});
}) });

//#endregion
//#region node_modules/vant/lib/watermark/index.js
var require_watermark = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/watermark/index.js": ((exports, module) => {
	var __create$2 = Object.create;
	var __defProp$8 = Object.defineProperty;
	var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$8 = Object.getOwnPropertyNames;
	var __getProtoOf$2 = Object.getPrototypeOf;
	var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
	var __export$8 = (target, all) => {
		for (var name$111 in all) __defProp$8(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$8 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$8(from)) if (!__hasOwnProp$8.call(to, key) && key !== except) __defProp$8(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$8(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$2 = (mod, isNodeMode, target) => (target = mod != null ? __create$2(__getProtoOf$2(mod)) : {}, __copyProps$8(isNodeMode || !mod || !mod.__esModule ? __defProp$8(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$8 = (mod) => __copyProps$8(__defProp$8({}, "__esModule", { value: true }), mod);
	var stdin_exports$8 = {};
	__export$8(stdin_exports$8, {
		Watermark: () => Watermark,
		default: () => stdin_default$5,
		watermarkProps: () => import_Watermark2.watermarkProps
	});
	module.exports = __toCommonJS$8(stdin_exports$8);
	var import_utils$3 = require_utils$9();
	var import_Watermark = __toESM$2(require_Watermark());
	var import_Watermark2 = require_Watermark();
	var Watermark = (0, import_utils$3.withInstall)(import_Watermark.default);
	var stdin_default$5 = Watermark;
}) });

//#endregion
//#region node_modules/vant/lib/lazyload/vue-lazyload/listener.js
var require_listener = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/lazyload/vue-lazyload/listener.js": ((exports, module) => {
	var __defProp$7 = Object.defineProperty;
	var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$7 = Object.getOwnPropertyNames;
	var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
	var __export$7 = (target, all) => {
		for (var name$111 in all) __defProp$7(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$7 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$7(from)) if (!__hasOwnProp$7.call(to, key) && key !== except) __defProp$7(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$7(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$7 = (mod) => __copyProps$7(__defProp$7({}, "__esModule", { value: true }), mod);
	var stdin_exports$7 = {};
	__export$7(stdin_exports$7, { default: () => ReactiveListener });
	module.exports = __toCommonJS$7(stdin_exports$7);
	var import_use$3 = require_index_cjs$1();
	var import_util$3 = require_util();
	var import_utils$2 = require_utils$9();
	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 = (0, import_use$3.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;
			(0, import_util$3.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 = import_utils$2.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");
				(0, import_util$3.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/lib/lazyload/vue-lazyload/lazy.js
var require_lazy = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/lazyload/vue-lazyload/lazy.js": ((exports, module) => {
	var __create$1 = Object.create;
	var __defProp$6 = Object.defineProperty;
	var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$6 = Object.getOwnPropertyNames;
	var __getProtoOf$1 = Object.getPrototypeOf;
	var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
	var __export$6 = (target, all) => {
		for (var name$111 in all) __defProp$6(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$6 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$6(from)) if (!__hasOwnProp$6.call(to, key) && key !== except) __defProp$6(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$6(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(__getProtoOf$1(mod)) : {}, __copyProps$6(isNodeMode || !mod || !mod.__esModule ? __defProp$6(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$6 = (mod) => __copyProps$6(__defProp$6({}, "__esModule", { value: true }), mod);
	var stdin_exports$6 = {};
	__export$6(stdin_exports$6, { default: () => stdin_default$4 });
	module.exports = __toCommonJS$6(stdin_exports$6);
	var import_vue$2 = require_vue();
	var import_use$2 = require_index_cjs$1();
	var import_util$2 = require_util();
	var import_utils$1 = require_utils$9();
	var import_listener = __toESM$1(require_listener());
	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$4() {
		return class Lazy {
			constructor({ preLoad, error, throttleWait, preLoadTop, dispatchEvent, loading, attempt, silent = true, scale, listenEvents, filter, adapter, observer, observerOptions }) {
				this.mode = import_util$2.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 || (0, import_util$2.getDPR)(scale),
					ListenEvents: listenEvents || DEFAULT_EVENTS,
					supportWebp: (0, import_util$2.supportWebp)(),
					filter: filter || {},
					adapter: adapter || {},
					observer: !!observer,
					observerOptions: observerOptions || DEFAULT_OBSERVER_OPTIONS
				};
				this.initEvent();
				this.imageCache = new import_util$2.ImageCache({ max: 200 });
				this.lazyLoadHandler = (0, import_util$2.throttle)(this.lazyLoadHandler.bind(this), this.options.throttleWait);
				this.setMode(this.options.observer ? import_util$2.modeType.observer : import_util$2.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 (import_use$2.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 (0, import_vue$2.nextTick)(this.lazyLoadHandler);
				}
				const value = this.valueFormatter(binding.value);
				let { src } = value;
				(0, import_vue$2.nextTick)(() => {
					src = (0, import_util$2.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 = (0, import_use$2.getScrollParent)(el);
					const newListener = new import_listener.default({
						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 (import_use$2.inBrowser) {
						this.addListenerTarget(window);
						this.addListenerTarget($parent);
					}
					this.lazyLoadHandler();
					(0, import_vue$2.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 = (0, import_util$2.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();
				(0, import_vue$2.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);
					(0, import_util$2.remove)(this.listeners, existItem);
					existItem.$destroy();
				}
			}
			removeComponent(vm) {
				if (!vm) return;
				(0, import_util$2.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 (!import_util$2.hasIntersectionObserver && mode === import_util$2.modeType.observer) mode = import_util$2.modeType.event;
				this.mode = mode;
				if (mode === import_util$2.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 === import_util$2.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 ? import_util$2.on : import_util$2.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;
					}
					(0, import_util$2.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) => {
					(0, import_util$2.remove)(this.listeners, item);
					item.$destroy();
				});
			}
			/**
			* init IntersectionObserver
			* set mode to observer
			* @return
			*/
			initIntersectionObserver() {
				if (!import_util$2.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 ((0, import_utils$1.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/lib/lazyload/vue-lazyload/lazy-component.js
var require_lazy_component = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/lazyload/vue-lazyload/lazy-component.js": ((exports, module) => {
	var __defProp$5 = Object.defineProperty;
	var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$5 = Object.getOwnPropertyNames;
	var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
	var __export$5 = (target, all) => {
		for (var name$111 in all) __defProp$5(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$5 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$5(from)) if (!__hasOwnProp$5.call(to, key) && key !== except) __defProp$5(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$5(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$5 = (mod) => __copyProps$5(__defProp$5({}, "__esModule", { value: true }), mod);
	var stdin_exports$5 = {};
	__export$5(stdin_exports$5, { default: () => stdin_default$3 });
	module.exports = __toCommonJS$5(stdin_exports$5);
	var import_vue$1 = require_vue();
	var import_use$1 = require_index_cjs$1();
	var stdin_default$3 = (lazy) => ({
		props: { tag: {
			type: String,
			default: "div"
		} },
		emits: ["show"],
		render() {
			return (0, import_vue$1.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 = (0, import_use$1.useRect)(this.$el);
				return import_use$1.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/lib/lazyload/vue-lazyload/lazy-container.js
var require_lazy_container = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/lazyload/vue-lazyload/lazy-container.js": ((exports, module) => {
	var __defProp$4 = Object.defineProperty;
	var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$4 = Object.getOwnPropertyNames;
	var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
	var __export$4 = (target, all) => {
		for (var name$111 in all) __defProp$4(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$4 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$4(from)) if (!__hasOwnProp$4.call(to, key) && key !== except) __defProp$4(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$4(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$4 = (mod) => __copyProps$4(__defProp$4({}, "__esModule", { value: true }), mod);
	var stdin_exports$4 = {};
	__export$4(stdin_exports$4, { default: () => LazyContainerManager });
	module.exports = __toCommonJS$4(stdin_exports$4);
	var import_util$1 = require_util();
	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();
			(0, import_util$1.remove)(this.queue, container);
		}
	};
}) });

//#endregion
//#region node_modules/vant/lib/lazyload/vue-lazyload/lazy-image.js
var require_lazy_image = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/lazyload/vue-lazyload/lazy-image.js": ((exports, module) => {
	var __defProp$3 = Object.defineProperty;
	var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$3 = Object.getOwnPropertyNames;
	var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
	var __export$3 = (target, all) => {
		for (var name$111 in all) __defProp$3(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$3 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$3(from)) if (!__hasOwnProp$3.call(to, key) && key !== except) __defProp$3(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$3(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$3 = (mod) => __copyProps$3(__defProp$3({}, "__esModule", { value: true }), mod);
	var stdin_exports$3 = {};
	__export$3(stdin_exports$3, { default: () => stdin_default$2 });
	module.exports = __toCommonJS$3(stdin_exports$3);
	var import_use = require_index_cjs$1();
	var import_util = require_util();
	var import_utils = require_utils$9();
	var import_vue = require_vue();
	var stdin_default$2 = (lazyManager) => ({
		props: {
			src: [String, Object],
			tag: {
				type: String,
				default: "img"
			}
		},
		render() {
			var _a, _b;
			return (0, import_vue.h)(this.tag, { src: this.renderSrc }, (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a));
		},
		data() {
			return {
				el: null,
				options: {
					src: "",
					error: "",
					loading: "",
					attempt: lazyManager.options.attempt
				},
				state: {
					loaded: false,
					error: false,
					attempt: 0
				},
				renderSrc: ""
			};
		},
		watch: { src() {
			this.init();
			lazyManager.addLazyBox(this);
			lazyManager.lazyLoadHandler();
		} },
		created() {
			this.init();
		},
		mounted() {
			this.el = this.$el;
			lazyManager.addLazyBox(this);
			lazyManager.lazyLoadHandler();
		},
		beforeUnmount() {
			lazyManager.removeComponent(this);
		},
		methods: {
			init() {
				const { src, loading, error } = lazyManager.valueFormatter(this.src);
				this.state.loaded = false;
				this.options.src = src;
				this.options.error = error;
				this.options.loading = loading;
				this.renderSrc = this.options.loading;
			},
			checkInView() {
				const rect = (0, import_use.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 = import_utils.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;
				(0, import_util.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/lib/lazyload/vue-lazyload/index.js
var require_vue_lazyload = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/lazyload/vue-lazyload/index.js": ((exports, module) => {
	var __create = Object.create;
	var __defProp$2 = Object.defineProperty;
	var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$2 = Object.getOwnPropertyNames;
	var __getProtoOf = Object.getPrototypeOf;
	var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
	var __export$2 = (target, all) => {
		for (var name$111 in all) __defProp$2(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$2 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$2(from)) if (!__hasOwnProp$2.call(to, key) && key !== except) __defProp$2(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$2(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps$2(isNodeMode || !mod || !mod.__esModule ? __defProp$2(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));
	var __toCommonJS$2 = (mod) => __copyProps$2(__defProp$2({}, "__esModule", { value: true }), mod);
	var stdin_exports$2 = {};
	__export$2(stdin_exports$2, { Lazyload: () => Lazyload });
	module.exports = __toCommonJS$2(stdin_exports$2);
	var import_lazy = __toESM(require_lazy());
	var import_lazy_component = __toESM(require_lazy_component());
	var import_lazy_container = __toESM(require_lazy_container());
	var import_lazy_image = __toESM(require_lazy_image());
	var Lazyload = { install(app, options = {}) {
		const lazy = new ((0, import_lazy.default)())(options);
		const lazyContainer = new import_lazy_container.default({ lazy });
		app.config.globalProperties.$Lazyload = lazy;
		if (options.lazyComponent) app.component("LazyComponent", (0, import_lazy_component.default)(lazy));
		if (options.lazyImage) app.component("LazyImage", (0, import_lazy_image.default)(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/lib/lazyload/index.js
var require_lazyload = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/lazyload/index.js": ((exports, module) => {
	var __defProp$1 = Object.defineProperty;
	var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames$1 = Object.getOwnPropertyNames;
	var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
	var __export$1 = (target, all) => {
		for (var name$111 in all) __defProp$1(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps$1 = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames$1(from)) if (!__hasOwnProp$1.call(to, key) && key !== except) __defProp$1(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc$1(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __toCommonJS$1 = (mod) => __copyProps$1(__defProp$1({}, "__esModule", { value: true }), mod);
	var stdin_exports$1 = {};
	__export$1(stdin_exports$1, {
		Lazyload: () => import_vue_lazyload.Lazyload,
		default: () => stdin_default$1
	});
	module.exports = __toCommonJS$1(stdin_exports$1);
	var import_vue_lazyload = require_vue_lazyload();
	var stdin_default$1 = import_vue_lazyload.Lazyload;
}) });

//#endregion
//#region node_modules/vant/lib/index.js
var require_lib = /* @__PURE__ */ __commonJS({ "node_modules/vant/lib/index.js": ((exports, module) => {
	var __defProp = Object.defineProperty;
	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames = Object.getOwnPropertyNames;
	var __hasOwnProp = Object.prototype.hasOwnProperty;
	var __export = (target, all) => {
		for (var name$111 in all) __defProp(target, name$111, {
			get: all[name$111],
			enumerable: true
		});
	};
	var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
				get: () => from[key],
				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
			});
		}
		return to;
	};
	var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
	var stdin_exports = {};
	__export(stdin_exports, {
		default: () => stdin_default,
		install: () => install,
		version: () => version
	});
	module.exports = __toCommonJS(stdin_exports);
	var import_action_bar = require_action_bar();
	var import_action_bar_button = require_action_bar_button();
	var import_action_bar_icon = require_action_bar_icon();
	var import_action_sheet = require_action_sheet();
	var import_address_edit = require_address_edit();
	var import_address_list = require_address_list();
	var import_area = require_area();
	var import_back_top = require_back_top();
	var import_badge = require_badge();
	var import_barrage = require_barrage();
	var import_button = require_button();
	var import_calendar = require_calendar();
	var import_card = require_card();
	var import_cascader = require_cascader();
	var import_cell = require_cell();
	var import_cell_group = require_cell_group();
	var import_checkbox = require_checkbox();
	var import_checkbox_group = require_checkbox_group();
	var import_circle = require_circle();
	var import_col = require_col();
	var import_collapse = require_collapse();
	var import_collapse_item = require_collapse_item();
	var import_config_provider = require_config_provider();
	var import_contact_card = require_contact_card();
	var import_contact_edit = require_contact_edit();
	var import_contact_list = require_contact_list();
	var import_count_down = require_count_down();
	var import_coupon = require_coupon();
	var import_coupon_cell = require_coupon_cell();
	var import_coupon_list = require_coupon_list();
	var import_date_picker = require_date_picker();
	var import_dialog = require_dialog();
	var import_divider = require_divider();
	var import_dropdown_item = require_dropdown_item();
	var import_dropdown_menu = require_dropdown_menu();
	var import_empty = require_empty();
	var import_field = require_field();
	var import_floating_bubble = require_floating_bubble();
	var import_floating_panel = require_floating_panel();
	var import_form = require_form();
	var import_grid = require_grid();
	var import_grid_item = require_grid_item();
	var import_highlight = require_highlight();
	var import_icon = require_icon();
	var import_image = require_image();
	var import_image_preview = require_image_preview();
	var import_index_anchor = require_index_anchor();
	var import_index_bar = require_index_bar();
	var import_list = require_list();
	var import_loading = require_loading();
	var import_locale = require_locale();
	var import_nav_bar = require_nav_bar();
	var import_notice_bar = require_notice_bar();
	var import_notify = require_notify();
	var import_number_keyboard = require_number_keyboard();
	var import_overlay = require_overlay();
	var import_pagination = require_pagination();
	var import_password_input = require_password_input();
	var import_picker = require_picker();
	var import_picker_group = require_picker_group();
	var import_popover = require_popover();
	var import_popup = require_popup();
	var import_progress = require_progress();
	var import_pull_refresh = require_pull_refresh();
	var import_radio = require_radio();
	var import_radio_group = require_radio_group();
	var import_rate = require_rate();
	var import_rolling_text = require_rolling_text();
	var import_row = require_row();
	var import_search = require_search();
	var import_share_sheet = require_share_sheet();
	var import_sidebar = require_sidebar();
	var import_sidebar_item = require_sidebar_item();
	var import_signature = require_signature();
	var import_skeleton = require_skeleton();
	var import_skeleton_avatar = require_skeleton_avatar();
	var import_skeleton_image = require_skeleton_image();
	var import_skeleton_paragraph = require_skeleton_paragraph();
	var import_skeleton_title = require_skeleton_title();
	var import_slider = require_slider();
	var import_space = require_space();
	var import_step = require_step();
	var import_stepper = require_stepper();
	var import_steps = require_steps();
	var import_sticky = require_sticky();
	var import_submit_bar = require_submit_bar();
	var import_swipe = require_swipe();
	var import_swipe_cell = require_swipe_cell();
	var import_swipe_item = require_swipe_item();
	var import_switch = require_switch();
	var import_tab = require_tab();
	var import_tabbar = require_tabbar();
	var import_tabbar_item = require_tabbar_item();
	var import_tabs = require_tabs();
	var import_tag = require_tag();
	var import_text_ellipsis = require_text_ellipsis();
	var import_time_picker = require_time_picker();
	var import_toast = require_toast();
	var import_tree_select = require_tree_select();
	var import_uploader = require_uploader();
	var import_watermark = require_watermark();
	__reExport(stdin_exports, require_action_bar(), module.exports);
	__reExport(stdin_exports, require_action_bar_button(), module.exports);
	__reExport(stdin_exports, require_action_bar_icon(), module.exports);
	__reExport(stdin_exports, require_action_sheet(), module.exports);
	__reExport(stdin_exports, require_address_edit(), module.exports);
	__reExport(stdin_exports, require_address_list(), module.exports);
	__reExport(stdin_exports, require_area(), module.exports);
	__reExport(stdin_exports, require_back_top(), module.exports);
	__reExport(stdin_exports, require_badge(), module.exports);
	__reExport(stdin_exports, require_barrage(), module.exports);
	__reExport(stdin_exports, require_button(), module.exports);
	__reExport(stdin_exports, require_calendar(), module.exports);
	__reExport(stdin_exports, require_card(), module.exports);
	__reExport(stdin_exports, require_cascader(), module.exports);
	__reExport(stdin_exports, require_cell(), module.exports);
	__reExport(stdin_exports, require_cell_group(), module.exports);
	__reExport(stdin_exports, require_checkbox(), module.exports);
	__reExport(stdin_exports, require_checkbox_group(), module.exports);
	__reExport(stdin_exports, require_circle(), module.exports);
	__reExport(stdin_exports, require_col(), module.exports);
	__reExport(stdin_exports, require_collapse(), module.exports);
	__reExport(stdin_exports, require_collapse_item(), module.exports);
	__reExport(stdin_exports, require_config_provider(), module.exports);
	__reExport(stdin_exports, require_contact_card(), module.exports);
	__reExport(stdin_exports, require_contact_edit(), module.exports);
	__reExport(stdin_exports, require_contact_list(), module.exports);
	__reExport(stdin_exports, require_count_down(), module.exports);
	__reExport(stdin_exports, require_coupon(), module.exports);
	__reExport(stdin_exports, require_coupon_cell(), module.exports);
	__reExport(stdin_exports, require_coupon_list(), module.exports);
	__reExport(stdin_exports, require_date_picker(), module.exports);
	__reExport(stdin_exports, require_dialog(), module.exports);
	__reExport(stdin_exports, require_divider(), module.exports);
	__reExport(stdin_exports, require_dropdown_item(), module.exports);
	__reExport(stdin_exports, require_dropdown_menu(), module.exports);
	__reExport(stdin_exports, require_empty(), module.exports);
	__reExport(stdin_exports, require_field(), module.exports);
	__reExport(stdin_exports, require_floating_bubble(), module.exports);
	__reExport(stdin_exports, require_floating_panel(), module.exports);
	__reExport(stdin_exports, require_form(), module.exports);
	__reExport(stdin_exports, require_grid(), module.exports);
	__reExport(stdin_exports, require_grid_item(), module.exports);
	__reExport(stdin_exports, require_highlight(), module.exports);
	__reExport(stdin_exports, require_icon(), module.exports);
	__reExport(stdin_exports, require_image(), module.exports);
	__reExport(stdin_exports, require_image_preview(), module.exports);
	__reExport(stdin_exports, require_index_anchor(), module.exports);
	__reExport(stdin_exports, require_index_bar(), module.exports);
	__reExport(stdin_exports, require_lazyload(), module.exports);
	__reExport(stdin_exports, require_list(), module.exports);
	__reExport(stdin_exports, require_loading(), module.exports);
	__reExport(stdin_exports, require_locale(), module.exports);
	__reExport(stdin_exports, require_nav_bar(), module.exports);
	__reExport(stdin_exports, require_notice_bar(), module.exports);
	__reExport(stdin_exports, require_notify(), module.exports);
	__reExport(stdin_exports, require_number_keyboard(), module.exports);
	__reExport(stdin_exports, require_overlay(), module.exports);
	__reExport(stdin_exports, require_pagination(), module.exports);
	__reExport(stdin_exports, require_password_input(), module.exports);
	__reExport(stdin_exports, require_picker(), module.exports);
	__reExport(stdin_exports, require_picker_group(), module.exports);
	__reExport(stdin_exports, require_popover(), module.exports);
	__reExport(stdin_exports, require_popup(), module.exports);
	__reExport(stdin_exports, require_progress(), module.exports);
	__reExport(stdin_exports, require_pull_refresh(), module.exports);
	__reExport(stdin_exports, require_radio(), module.exports);
	__reExport(stdin_exports, require_radio_group(), module.exports);
	__reExport(stdin_exports, require_rate(), module.exports);
	__reExport(stdin_exports, require_rolling_text(), module.exports);
	__reExport(stdin_exports, require_row(), module.exports);
	__reExport(stdin_exports, require_search(), module.exports);
	__reExport(stdin_exports, require_share_sheet(), module.exports);
	__reExport(stdin_exports, require_sidebar(), module.exports);
	__reExport(stdin_exports, require_sidebar_item(), module.exports);
	__reExport(stdin_exports, require_signature(), module.exports);
	__reExport(stdin_exports, require_skeleton(), module.exports);
	__reExport(stdin_exports, require_skeleton_avatar(), module.exports);
	__reExport(stdin_exports, require_skeleton_image(), module.exports);
	__reExport(stdin_exports, require_skeleton_paragraph(), module.exports);
	__reExport(stdin_exports, require_skeleton_title(), module.exports);
	__reExport(stdin_exports, require_slider(), module.exports);
	__reExport(stdin_exports, require_space(), module.exports);
	__reExport(stdin_exports, require_step(), module.exports);
	__reExport(stdin_exports, require_stepper(), module.exports);
	__reExport(stdin_exports, require_steps(), module.exports);
	__reExport(stdin_exports, require_sticky(), module.exports);
	__reExport(stdin_exports, require_submit_bar(), module.exports);
	__reExport(stdin_exports, require_swipe(), module.exports);
	__reExport(stdin_exports, require_swipe_cell(), module.exports);
	__reExport(stdin_exports, require_swipe_item(), module.exports);
	__reExport(stdin_exports, require_switch(), module.exports);
	__reExport(stdin_exports, require_tab(), module.exports);
	__reExport(stdin_exports, require_tabbar(), module.exports);
	__reExport(stdin_exports, require_tabbar_item(), module.exports);
	__reExport(stdin_exports, require_tabs(), module.exports);
	__reExport(stdin_exports, require_tag(), module.exports);
	__reExport(stdin_exports, require_text_ellipsis(), module.exports);
	__reExport(stdin_exports, require_time_picker(), module.exports);
	__reExport(stdin_exports, require_toast(), module.exports);
	__reExport(stdin_exports, require_tree_select(), module.exports);
	__reExport(stdin_exports, require_uploader(), module.exports);
	__reExport(stdin_exports, require_watermark(), module.exports);
	var version = "4.9.21";
	function install(app) {
		[
			import_action_bar.ActionBar,
			import_action_bar_button.ActionBarButton,
			import_action_bar_icon.ActionBarIcon,
			import_action_sheet.ActionSheet,
			import_address_edit.AddressEdit,
			import_address_list.AddressList,
			import_area.Area,
			import_back_top.BackTop,
			import_badge.Badge,
			import_barrage.Barrage,
			import_button.Button,
			import_calendar.Calendar,
			import_card.Card,
			import_cascader.Cascader,
			import_cell.Cell,
			import_cell_group.CellGroup,
			import_checkbox.Checkbox,
			import_checkbox_group.CheckboxGroup,
			import_circle.Circle,
			import_col.Col,
			import_collapse.Collapse,
			import_collapse_item.CollapseItem,
			import_config_provider.ConfigProvider,
			import_contact_card.ContactCard,
			import_contact_edit.ContactEdit,
			import_contact_list.ContactList,
			import_count_down.CountDown,
			import_coupon.Coupon,
			import_coupon_cell.CouponCell,
			import_coupon_list.CouponList,
			import_date_picker.DatePicker,
			import_dialog.Dialog,
			import_divider.Divider,
			import_dropdown_item.DropdownItem,
			import_dropdown_menu.DropdownMenu,
			import_empty.Empty,
			import_field.Field,
			import_floating_bubble.FloatingBubble,
			import_floating_panel.FloatingPanel,
			import_form.Form,
			import_grid.Grid,
			import_grid_item.GridItem,
			import_highlight.Highlight,
			import_icon.Icon,
			import_image.Image,
			import_image_preview.ImagePreview,
			import_index_anchor.IndexAnchor,
			import_index_bar.IndexBar,
			import_list.List,
			import_loading.Loading,
			import_locale.Locale,
			import_nav_bar.NavBar,
			import_notice_bar.NoticeBar,
			import_notify.Notify,
			import_number_keyboard.NumberKeyboard,
			import_overlay.Overlay,
			import_pagination.Pagination,
			import_password_input.PasswordInput,
			import_picker.Picker,
			import_picker_group.PickerGroup,
			import_popover.Popover,
			import_popup.Popup,
			import_progress.Progress,
			import_pull_refresh.PullRefresh,
			import_radio.Radio,
			import_radio_group.RadioGroup,
			import_rate.Rate,
			import_rolling_text.RollingText,
			import_row.Row,
			import_search.Search,
			import_share_sheet.ShareSheet,
			import_sidebar.Sidebar,
			import_sidebar_item.SidebarItem,
			import_signature.Signature,
			import_skeleton.Skeleton,
			import_skeleton_avatar.SkeletonAvatar,
			import_skeleton_image.SkeletonImage,
			import_skeleton_paragraph.SkeletonParagraph,
			import_skeleton_title.SkeletonTitle,
			import_slider.Slider,
			import_space.Space,
			import_step.Step,
			import_stepper.Stepper,
			import_steps.Steps,
			import_sticky.Sticky,
			import_submit_bar.SubmitBar,
			import_swipe.Swipe,
			import_swipe_cell.SwipeCell,
			import_swipe_item.SwipeItem,
			import_switch.Switch,
			import_tab.Tab,
			import_tabbar.Tabbar,
			import_tabbar_item.TabbarItem,
			import_tabs.Tabs,
			import_tag.Tag,
			import_text_ellipsis.TextEllipsis,
			import_time_picker.TimePicker,
			import_toast.Toast,
			import_tree_select.TreeSelect,
			import_uploader.Uploader,
			import_watermark.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 { require_lib as t };
//# sourceMappingURL=lib-Bm24f1cs.js.map