https://sveltiacms.app/assets/chunks/framework.BcTgqkOM.js

1//#region node_modules/.pnpm/@[email protected]/node_modules/@vue/shared/dist/shared.esm-bundler.js
2/**
3* @vue/shared v3.5.43
4* (c) 2018-present Yuxi (Evan) You and Vue contributors
5* @license MIT
6**/
7// @__NO_SIDE_EFFECTS__
8function makeMap(str) {
9	const map = /* @__PURE__ */ Object.create(null);
10	for (const key of str.split(",")) map[key] = 1;
11	return (val) => val in map;
12}
13var EMPTY_OBJ = {};
14var EMPTY_ARR = [];
15var NOOP = () => {};
16var NO = () => false;
17var isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && (key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
18var isModelListener = (key) => key.startsWith("onUpdate:");
19var extend = Object.assign;
20var remove = (arr, el) => {
21	const i = arr.indexOf(el);
22	if (i > -1) arr.splice(i, 1);
23};
24var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
25var hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
26var isArray = Array.isArray;
27var isMap = (val) => toTypeString(val) === "[object Map]";
28var isSet = (val) => toTypeString(val) === "[object Set]";
29var isDate = (val) => toTypeString(val) === "[object Date]";
30var isFunction = (val) => typeof val === "function";
31var isString = (val) => typeof val === "string";
32var isSymbol = (val) => typeof val === "symbol";
33var isObject$2 = (val) => val !== null && typeof val === "object";
34var isPromise = (val) => {
35	return (isObject$2(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
36};
37var objectToString = Object.prototype.toString;
38var toTypeString = (value) => objectToString.call(value);
39var toRawType = (value) => {
40	return toTypeString(value).slice(8, -1);
41};
42var isPlainObject = (val) => toTypeString(val) === "[object Object]";
43var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
44var isReservedProp = /* @__PURE__ */ makeMap(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted");
45var cacheStringFunction$1 = (fn) => {
46	const cache = /* @__PURE__ */ Object.create(null);
47	return ((str) => {
48		return cache[str] || (cache[str] = fn(str));
49	});
50};
51var camelizeRE$1 = /-\w/g;
52var camelize$1 = cacheStringFunction$1((str) => {
53	return str.replace(camelizeRE$1, (c) => c.slice(1).toUpperCase());
54});
55var hyphenateRE$1 = /\B([A-Z])/g;
56var hyphenate$1 = cacheStringFunction$1((str) => str.replace(hyphenateRE$1, "-$1").toLowerCase());
57var capitalize = cacheStringFunction$1((str) => {
58	return str.charAt(0).toUpperCase() + str.slice(1);
59});
60var toHandlerKey = cacheStringFunction$1((str) => {
61	return str ? `on${capitalize(str)}` : ``;
62});
63var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
64var invokeArrayFns = (fns, ...arg) => {
65	for (let i = 0; i < fns.length; i++) fns[i](...arg);
66};
67var def = (obj, key, value, writable = false) => {
68	Object.defineProperty(obj, key, {
69		configurable: true,
70		enumerable: false,
71		writable,
72		value
73	});
74};
75var looseToNumber = (val) => {
76	const n = parseFloat(val);
77	return isNaN(n) ? val : n;
78};
79var toNumber = (val) => {
80	const n = isString(val) ? Number(val) : NaN;
81	return isNaN(n) ? val : n;
82};
83var _globalThis;
84var getGlobalThis = () => {
85	return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
86};
87function normalizeStyle(value) {
88	if (isArray(value)) {
89		const res = {};
90		for (let i = 0; i < value.length; i++) {
91			const item = value[i];
92			const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
93			if (normalized) for (const key in normalized) res[key] = normalized[key];
94		}
95		return res;
96	} else if (isString(value) || isObject$2(value)) return value;
97}
98var listDelimiterRE = /;(?![^(]*\))/g;
99var propertyDelimiterRE = /:([^]+)/;
100var styleCommentRE = /"(?:[^"\\]|\\[^])*"|'(?:[^'\\]|\\[^])*'|\\[^]|\/\*[^]*?\*\//g;
101function parseStringStyle(cssText) {
102	const ret = {};
103	cssText.replace(styleCommentRE, (match) => match.startsWith("/*") ? "" : match).split(listDelimiterRE).forEac

103h((item) => {
104		if (item) {
105			const tmp = item.split(propertyDelimiterRE);
106			tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
107		}
108	});
109	return ret;
110}
111function stringifyStyle(styles) {
112	if (!styles) return "";
113	if (isString(styles)) return styles;
114	let ret = "";
115	for (const key in styles) {
116		const value = styles[key];
117		if (isString(value) || typeof value === "number") {
118			const normalizedKey = key.startsWith(`--`) ? key : hyphenate$1(key);
119			ret += `${normalizedKey}:${value};`;
120		}
121	}
122	return ret;
123}
124function normalizeClass(value) {
125	let res = "";
126	if (isString(value)) res = value;
127	else if (isArray(value)) for (let i = 0; i < value.length; i++) {
128		const normalized = normalizeClass(value[i]);
129		if (normalized) res += normalized + " ";
130	}
131	else if (isObject$2(value)) {
132		for (const name in value) if (value[name]) res += name + " ";
133	}
134	return res.trim();
135}
136var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
137var isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
138var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
139function includeBooleanAttr(value) {
140	return !!value || value === "";
141}
142var isKnownHtmlAttr = /* @__PURE__ */ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`);
143var isKnownSvgAttr = /* @__PURE__ */ makeMap(`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,str

143ikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`);
144function isRenderableAttrValue(value) {
145	if (value == null) return false;
146	const type = typeof value;
147	return type === "string" || type === "number" || type === "boolean";
148}
149var cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
150function getEscapedCssVarName(key, doubleEscape) {
151	return key.replace(cssVarNameEscapeSymbolsRE, (s) => doubleEscape ? s === "\"" ? "\\\\\\\"" : `\\\\${s}` : `\\${s}`);
152}
153function looseCompareArrays(a, b, seen) {
154	if (a.length !== b.length) return false;
155	let equal = true;
156	for (let i = 0; equal && i < a.length; i++) equal = looseEqual(a[i], b[i], seen);
157	return equal;
158}
159function looseCompareCollections(a, b, seen) {
160	if (a.size !== b.size) return false;
161	const candidates = Array.from(b);
162	const matched = new Uint8Array(candidates.length);
163	for (const item of a) {
164		let index = -1;
165		for (let i = 0; i < candidates.length; i++) if (!matched[i] && looseEqual(item, candidates[i], seen)) {
166			index = i;
167			break;
168		}
169		if (index < 0) return false;
170		matched[index] = 1;
171	}
172	return true;
173}
174function looseCompareObjects(a, b, seen) {
175	let aValidType = isMap(a);
176	let bValidType = isMap(b);
177	if (aValidType || bValidType) return aValidType && bValidType ? looseCompareCollections(a, b, seen) : false;
178	aValidType = isSet(a);
179	bValidType = isSet(b);
180	if (aValidType || bValidType) return aValidType && bValidType ? looseCompareCollections(a, b, seen) : false;
181	if (Object.keys(a).length !== Object.keys(b).length) return false;
182	for (const key in a) {
183		const aHasKey = a.hasOwnProperty(key);
184		const bHasKey = b.hasOwnProperty(key);
185		if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key], seen)) return false;
186	}
187	return String(a) === String(b);
188}
189function looseCompareNested(a, b, seen, compare) {
190	if (!seen) seen = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()];
191	const [seenA, seenB] = seen;
192	if (seenA.has(a) || seenB.has(b)) return seenA.get(a) === b && seenB.get(b) === a;
193	seenA.set(a, b);
194	seenB.set(b, a);
195	const equal = compare(a, b, seen);
196	seenA.delete(a);
197	seenB.delete(b);
198	return equal;
199}
200function looseEqual(a, b, seen) {
201	if (a === b) return true;
202	let aValidType = isDate(a);
203	let bValidType = isDate(b);
204	if (aValidType || bValidType) return aValidType && bValidType ? a.getTime() === b.getTime() : false;
205	aValidType = isSymbol(a);
206	bValidType = isSymbol(b);
207	if (aValidType || bValidType) return a === b;
208	aValidType = isArray(a);
209	bValidType = isArray(b);
210	if (aValidType || bValidType) return aValidType && bValidType ? looseCompareNested(a, b, seen, looseCompareArrays) : false;
211	aValidType = isObject$2(a);
212	bValidType = isObject$2(b);
213	if (aValidType || bValidType) {
214		if (!aValidType || !bValidType) return false;
215		return looseCompareNested(a, b, seen, looseCompareObjects);
216	}
217	return String(a) === String(b);
218}
219function looseIndexOf(arr, val) {
220	return arr.findIndex((item) => looseEqual(item, val));
221}
222var isRef$1 = (val) => {
223	return !!(val && val["__v_isRef"] === true);
224};
225var toDisplayString = (val) => {
226	return isString(val) ? val : val == null ? "" : isArray(val) || isObject$2(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
227};
228var replacer = (_key, val) => {
229	if (isRef$1(val)) return replacer(_key, val.value);
230	else if (isMap(val)) return { [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2], i) => {
231		entries[stringifySymbol(key, i) + " =>"] = val2;
232		return entries;
233	}, {}) };
234	else if (isSet(val)) return { [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v)) };
235	else if (isSymbol(val)) return stringifySymbol(val);
236	else if (isObject$2(val) && !isArray(val) && !isPlainObject(val)) return String(val);
237	return val;
238};
239var stringifySymbol = (v, i = "") => {
240	var _a;
241	return isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v;
242};
243function normalizeCssVarValue(value) {
244	if (value == null) return "initial";
245	if (typeof value === "string") return value === "" ? " " : value;

246	if (typeof value !== "number" || !Number.isFinite(value)) {}
247	return String(value);
248}
249//#endregion
250//#region node_modules/.pnpm/@[email protected]/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
251/**
252* @vue/reactivity v3.5.43
253* (c) 2018-present Yuxi (Evan) You and Vue contributors
254* @license MIT
255**/
256var activeEffectScope;
257var EffectScope = class {
258	constructor(detached = false) {
259		this.detached = detached;
260		/**
261		* @internal
262		*/
263		this._active = true;
264		/**
265		* @internal track `on` calls, allow `on` call multiple times
266		*/
267		this._on = 0;
268		/**
269		* @internal
270		*/
271		this.effects = [];
272		/**
273		* @internal
274		*/
275		this.cleanups = [];
276		this._isPaused = false;
277		this._warnOnRun = true;
278		this.__v_skip = true;
279		if (!detached && activeEffectScope) {
280			if (activeEffectScope.active) {
281				this.parent = activeEffectScope;
282				this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
283			} else {
284				this._active = false;
285				this._warnOnRun = false;
286			}
287		}
288	}
289	get active() {
290		return this._active;
291	}
292	pause() {
293		if (this._active) {
294			this._isPaused = true;
295			let i, l;
296			if (this.scopes) {
297				const scopes = this.scopes.slice();
298				for (i = 0, l = scopes.length; i < l; i++) scopes[i].pause();
299			}
300			for (i = 0, l = this.effects.length; i < l; i++) this.effects[i].pause();
301		}
302	}
303	/**
304	* Resumes the effect scope, including all child scopes and effects.
305	*/
306	resume() {
307		if (this._active) {
308			if (this._isPaused) {
309				this._isPaused = false;
310				let i, l;
311				if (this.scopes) {
312					const scopes = this.scopes.slice();
313					for (i = 0, l = scopes.length; i < l; i++) scopes[i].resume();
314				}
315				const effects = this.effects.slice();
316				for (i = 0, l = effects.length; i < l; i++) effects[i].resume();
317			}
318		}
319	}
320	run(fn) {
321		if (this._active) {
322			const currentEffectScope = activeEffectScope;
323			try {
324				activeEffectScope = this;
325				return fn();
326			} finally {
327				activeEffectScope = currentEffectScope;
328			}
329		}
330	}
331	/**
332	* This should only be called on non-detached scopes
333	* @internal
334	*/
335	on() {
336		if (++this._on === 1) {
337			this.prevScope = activeEffectScope;
338			activeEffectScope = this;
339		}
340	}
341	/**
342	* This should only be called on non-detached scopes
343	* @internal
344	*/
345	off() {
346		if (this._on > 0 && --this._on === 0) {
347			if (activeEffectScope === this) activeEffectScope = this.prevScope;
348			else {
349				let current = activeEffectScope;
350				while (current) {
351					if (current.prevScope === this) {
352						current.prevScope = this.prevScope;
353						break;
354					}
355					current = current.prevScope;
356				}
357			}
358			this.prevScope = void 0;
359		}
360	}
361	stop(fromParent) {
362		if (this._active) {
363			this._active = false;
364			let i, l;
365			for (i = 0, l = this.effects.length; i < l; i++) this.effects[i].stop();
366			this.effects.length = 0;
367			for (i = 0, l = this.cleanups.length; i < l; i++) this.cleanups[i]();
368			this.cleanups.length = 0;
369			if (this.scopes) {
370				const scopes = this.scopes.slice();
371				for (i = 0, l = scopes.length; i < l; i++) scopes[i].stop(true);
372				this.scopes.length = 0;
373			}
374			if (!this.detached && this.parent && !fromParent) {
375				const last = this.parent.scopes.pop();
376				if (last && last !== this) {
377					this.parent.scopes[this.index] = last;
378					last.index = this.index;
379				}
380			}
381			this.parent = void 0;
382		}
383	}
384};
385function getCurrentScope() {
386	return activeEffectScope;
387}
388function onScopeDispose(fn, failSilently = false) {
389	if (activeEffectScope) activeEffectScope.cleanups.push(fn);
390}
391var activeSub;
392var pausedQueueEffects = /* @__PURE__ */ new WeakSet();
393var ReactiveEffect = class {
394	constructor(fn) {
395		this.fn = fn;
396		/**
397		* @internal
398		*/
399		this.deps = void 0;
400		/**
401		* @internal
402		*/
403		this.depsTail = void 0;
404		/**
405		* @internal
406		*/
407		this.flags = 5;
408		/**
409		* @internal
410		*/
411		this.next = void 0;
412		/**
413		* @internal
414		*/
415		this.cleanup = void 0;
416		this.scheduler = void 0;
417		if (activeEffectScope) {
418			if (activeEffectScope.active) activeEffectScope.effects.push(this);
419			else this.flags &= -2;
420		}
421	}
422	pause() {
423		this.flags |= 64;
424	}
425	resume() {
426		if (this.flags & 64) {
427			this.flags &= -65;

428			if (pausedQueueEffects.has(this)) {
429				pausedQueueEffects.delete(this);
430				this.trigger();
431			}
432		}
433	}
434	/**
435	* @internal
436	*/
437	notify() {
438		if (this.flags & 2 && !(this.flags & 32)) return;
439		if (!(this.flags & 8)) batch(this);
440	}
441	run() {
442		if (!(this.flags & 1)) return this.fn();
443		this.flags |= 2;
444		cleanupEffect(this);
445		prepareDeps(this);
446		const prevEffect = activeSub;
447		const prevShouldTrack = shouldTrack;
448		activeSub = this;
449		shouldTrack = true;
450		try {
451			return this.fn();
452		} finally {
453			cleanupDeps(this);
454			activeSub = prevEffect;
455			shouldTrack = prevShouldTrack;
456			this.flags &= -3;
457		}
458	}
459	stop() {
460		if (this.flags & 1) {
461			for (let link = this.deps; link; link = link.nextDep) removeSub(link);
462			this.deps = this.depsTail = void 0;
463			cleanupEffect(this);
464			this.onStop && this.onStop();
465			this.flags &= -2;
466		}
467	}
468	trigger() {
469		if (this.flags & 64) pausedQueueEffects.add(this);
470		else if (this.scheduler) this.scheduler();
471		else this.runIfDirty();
472	}
473	/**
474	* @internal
475	*/
476	runIfDirty() {
477		if (isDirty(this)) this.run();
478	}
479	get dirty() {
480		return isDirty(this);
481	}
482};
483var batchDepth = 0;
484var batchedSub;
485var batchedComputed;
486function batch(sub, isComputed = false) {
487	sub.flags |= 8;
488	if (isComputed) {
489		sub.next = batchedComputed;
490		batchedComputed = sub;
491		return;
492	}
493	sub.next = batchedSub;
494	batchedSub = sub;
495}
496function startBatch() {
497	batchDepth++;
498}
499function endBatch() {
500	if (--batchDepth > 0) return;
501	if (batchedComputed) {
502		let e = batchedComputed;
503		batchedComputed = void 0;
504		while (e) {
505			const next = e.next;
506			e.next = void 0;
507			e.flags &= -9;
508			e = next;
509		}
510	}
511	let error;
512	while (batchedSub) {
513		let e = batchedSub;
514		batchedSub = void 0;
515		while (e) {
516			const next = e.next;
517			e.next = void 0;
518			e.flags &= -9;
519			if (e.flags & 1) try {
520				e.trigger();
521			} catch (err) {
522				if (!error) error = err;
523			}
524			e = next;
525		}
526	}
527	if (error) throw error;
528}
529function prepareDeps(sub) {
530	for (let link = sub.deps; link; link = link.nextDep) {
531		link.version = -1;
532		link.prevActiveLink = link.dep.activeLink;
533		link.dep.activeLink = link;
534	}
535}
536function cleanupDeps(sub) {
537	let head;
538	let tail = sub.depsTail;
539	let link = tail;
540	while (link) {
541		const prev = link.prevDep;
542		if (link.version === -1) {
543			if (link === tail) tail = prev;
544			removeSub(link);
545			removeDep(link);
546		} else head = link;
547		link.dep.activeLink = link.prevActiveLink;
548		link.prevActiveLink = void 0;
549		link = prev;
550	}
551	sub.deps = head;
552	sub.depsTail = tail;
553}
554function isDirty(sub) {
555	for (let link = sub.deps; link; link = link.nextDep) if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) return true;
556	if (sub._dirty) return true;
557	return false;
558}
559function refreshComputed(computed) {
560	if (computed.flags & 4 && !(computed.flags & 16)) return;
561	computed.flags &= -17;
562	if (computed.globalVersion === globalVersion) return;
563	computed.globalVersion = globalVersion;
564	if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) return;
565	computed.flags |= 2;
566	const dep = computed.dep;
567	const prevSub = activeSub;
568	const prevShouldTrack = shouldTrack;
569	activeSub = computed;
570	shouldTrack = true;
571	try {
572		prepareDeps(computed);
573		const value = computed.fn(computed._value);
574		if (dep.version === 0 || hasChanged(value, computed._value)) {
575			computed.flags |= 128;
576			computed._value = value;
577			dep.version++;
578		}
579	} catch (err) {
580		dep.version++;
581		throw err;
582	} finally {
583		activeSub = prevSub;
584		shouldTrack = prevShouldTrack;
585		cleanupDeps(computed);
586		computed.flags &= -3;
587	}
588}
589function removeSub(link, soft = false) {
590	const { dep, prevSub, nextSub } = link;
591	if (prevSub) {
592		prevSub.nextSub = nextSub;
593		link.prevSub = void 0;
594	}
595	if (nextSub) {
596		nextSub.prevSub = prevSub;
597		link.nextSub = void 0;
598	}
599	if (dep.subs === link) {
600		dep.subs = prevSub;
601		if (!prevSub && dep.computed) {
602			dep.computed.flags &= -5;
603			for (let l = dep.computed.deps; l; l = l.nextDep) removeSub(l, true);
604		}
605	}

606	if (!soft && !--dep.sc && dep.map) dep.map.delete(dep.key);
607}
608function removeDep(link) {
609	const { prevDep, nextDep } = link;
610	if (prevDep) {
611		prevDep.nextDep = nextDep;
612		link.prevDep = void 0;
613	}
614	if (nextDep) {
615		nextDep.prevDep = prevDep;
616		link.nextDep = void 0;
617	}
618}
619var shouldTrack = true;
620var trackStack = [];
621function pauseTracking() {
622	trackStack.push(shouldTrack);
623	shouldTrack = false;
624}
625function resetTracking() {
626	const last = trackStack.pop();
627	shouldTrack = last === void 0 ? true : last;
628}
629function cleanupEffect(e) {
630	const { cleanup } = e;
631	e.cleanup = void 0;
632	if (cleanup) {
633		const prevSub = activeSub;
634		activeSub = void 0;
635		try {
636			cleanup();
637		} finally {
638			activeSub = prevSub;
639		}
640	}
641}
642var globalVersion = 0;
643var Link = class {
644	constructor(sub, dep) {
645		this.sub = sub;
646		this.dep = dep;
647		this.version = dep.version;
648		this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
649	}
650};
651var Dep = class {
652	constructor(computed) {
653		this.computed = computed;
654		this.version = 0;
655		/**
656		* Link between this dep and the current active effect
657		*/
658		this.activeLink = void 0;
659		/**
660		* Doubly linked list representing the subscribing effects (tail)
661		*/
662		this.subs = void 0;
663		/**
664		* For object property deps cleanup
665		*/
666		this.map = void 0;
667		this.key = void 0;
668		/**
669		* Subscriber counter
670		*/
671		this.sc = 0;
672		/**
673		* @internal
674		*/
675		this.__v_skip = true;
676	}
677	track(debugInfo) {
678		if (!activeSub || !shouldTrack || activeSub === this.computed) return;
679		let link = this.activeLink;
680		if (link === void 0 || link.sub !== activeSub) {
681			link = this.activeLink = new Link(activeSub, this);
682			if (!activeSub.deps) activeSub.deps = activeSub.depsTail = link;
683			else {
684				link.prevDep = activeSub.depsTail;
685				activeSub.depsTail.nextDep = link;
686				activeSub.depsTail = link;
687			}
688			addSub(link);
689		} else if (link.version === -1) {
690			link.version = this.version;
691			if (link.nextDep) {
692				const next = link.nextDep;
693				next.prevDep = link.prevDep;
694				if (link.prevDep) link.prevDep.nextDep = next;
695				link.prevDep = activeSub.depsTail;
696				link.nextDep = void 0;
697				activeSub.depsTail.nextDep = link;
698				activeSub.depsTail = link;
699				if (activeSub.deps === link) activeSub.deps = next;
700			}
701		}
702		return link;
703	}
704	trigger(debugInfo) {
705		this.version++;
706		globalVersion++;
707		this.notify(debugInfo);
708	}
709	notify(debugInfo) {
710		startBatch();
711		try {
712			for (let link = this.subs; link; link = link.prevSub) if (link.sub.notify()) link.sub.dep.notify();
713		} finally {
714			endBatch();
715		}
716	}
717};
718function addSub(link) {
719	link.dep.sc++;
720	if (link.sub.flags & 4) {
721		const computed = link.dep.computed;
722		if (computed && !link.dep.subs) {
723			computed.flags |= 20;
724			for (let l = computed.deps; l; l = l.nextDep) addSub(l);
725		}
726		const currentTail = link.dep.subs;
727		if (currentTail !== link) {
728			link.prevSub = currentTail;
729			if (currentTail) currentTail.nextSub = link;
730		}
731		link.dep.subs = link;
732	}
733}
734var targetMap = /* @__PURE__ */ new WeakMap();
735var ITERATE_KEY = /* @__PURE__ */ Symbol("");
736var MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol("");
737var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("");
738function track(target, type, key) {
739	if (shouldTrack && activeSub) {
740		let depsMap = targetMap.get(target);
741		if (!depsMap) targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
742		let dep = depsMap.get(key);
743		if (!dep) {
744			depsMap.set(key, dep = new Dep());
745			dep.map = depsMap;
746			dep.key = key;
747		}
748		dep.track();
749	}
750}
751function trigger(target, type, key, newValue, oldValue, oldTarget) {
752	const depsMap = targetMap.get(target);
753	if (!depsMap) {
754		globalVersion++;
755		return;
756	}
757	const run = (dep) => {
758		if (dep) dep.trigger();
759	};
760	startBatch();
761	if (type === "clear") depsMap.forEach(run);
762	else {
763		const targetIsArray = isArray(target);
764		const isArrayIndex = targetIsArray && isIntegerKey(key);
765		if (targetIsArray && key === "length") {
766			const newLength = Number(newValue);
767			depsMap.forEach((dep, key2) => {

768				if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) run(dep);
769			});
770		} else {
771			if (key !== void 0 || depsMap.has(void 0)) run(depsMap.get(key));
772			if (isArrayIndex) run(depsMap.get(ARRAY_ITERATE_KEY));
773			switch (type) {
774				case "add":
775					if (!targetIsArray) {
776						run(depsMap.get(ITERATE_KEY));
777						if (isMap(target)) run(depsMap.get(MAP_KEY_ITERATE_KEY));
778					} else if (isArrayIndex) run(depsMap.get("length"));
779					break;
780				case "delete":
781					if (!targetIsArray) {
782						run(depsMap.get(ITERATE_KEY));
783						if (isMap(target)) run(depsMap.get(MAP_KEY_ITERATE_KEY));
784					}
785					break;
786				case "set": if (isMap(target)) run(depsMap.get(ITERATE_KEY));
787			}
788		}
789	}
790	endBatch();
791}
792function getDepFromReactive(object, key) {
793	const depMap = targetMap.get(object);
794	return depMap && depMap.get(key);
795}
796function reactiveReadArray(array) {
797	const raw = /* @__PURE__ */ toRaw(array);
798	if (raw === array) return raw;
799	track(raw, "iterate", ARRAY_ITERATE_KEY);
800	if (/* @__PURE__ */ isShallow(array)) return raw;
801	if (!/* @__PURE__ */ isReadonly(array)) return raw.map(toReactive);
802	return /* @__PURE__ */ isReactive(array) ? raw.map((item) => toReadonly(toReactive(item))) : raw.map(toReadonly);
803}
804function shallowReadArray(arr) {
805	track(arr = /* @__PURE__ */ toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
806	return arr;
807}
808function toWrapped(target, item) {
809	if (/* @__PURE__ */ isReadonly(target)) return /* @__PURE__ */ isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
810	return toReactive(item);
811}
812var arrayInstrumentations = {
813	__proto__: null,
814	[Symbol.iterator]() {
815		return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
816	},
817	concat(...args) {
818		return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
819	},
820	entries() {
821		return iterator(this, "entries", (value) => {
822			value[1] = toWrapped(this, value[1]);
823			return value;
824		});
825	},
826	every(fn, thisArg) {
827		return apply(this, "every", fn, thisArg, void 0, arguments);
828	},
829	filter(fn, thisArg) {
830		return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments);
831	},
832	find(fn, thisArg) {
833		return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments);
834	},
835	findIndex(fn, thisArg) {
836		return apply(this, "findIndex", fn, thisArg, void 0, arguments);
837	},
838	findLast(fn, thisArg) {
839		return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments);
840	},
841	findLastIndex(fn, thisArg) {
842		return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
843	},
844	forEach(fn, thisArg) {
845		return apply(this, "forEach", fn, thisArg, void 0, arguments);
846	},
847	includes(...args) {
848		return searchProxy(this, "includes", args);
849	},
850	indexOf(...args) {
851		return searchProxy(this, "indexOf", args);
852	},
853	join(separator) {
854		return reactiveReadArray(this).join(separator);
855	},
856	lastIndexOf(...args) {
857		return searchProxy(this, "lastIndexOf", args);
858	},
859	map(fn, thisArg) {
860		return apply(this, "map", fn, thisArg, void 0, arguments);
861	},
862	pop() {
863		return noTracking(this, "pop");
864	},
865	push(...args) {
866		return noTracking(this, "push", args);
867	},
868	reduce(fn, ...args) {
869		return reduce(this, "reduce", fn, args);
870	},
871	reduceRight(fn, ...args) {
872		return reduce(this, "reduceRight", fn, args);
873	},
874	shift() {
875		return noTracking(this, "shift");
876	},
877	some(fn, thisArg) {
878		return apply(this, "some", fn, thisArg, void 0, arguments);
879	},
880	splice(...args) {
881		return noTracking(this, "splice", args);
882	},
883	toReversed() {
884		return reactiveReadArray(this).toReversed();
885	},
886	toSorted(comparer) {
887		return reactiveReadArray(this).toSorted(comparer);
888	},
889	toSpliced(...args) {
890		return reactiveReadArray(this).toSpliced(...args);
891	},
892	unshift(...args) {
893		return noTracking(this, "unshift", args);
894	},
895	values() {
896		return iterator(this, "values", (item) => toWrapped(this, item));
897	}
898};
899function iterator(self, method, wrapValue) {
900	const arr = shallowReadArray(self);
901	const iter = arr[method]();
902	if (arr !== self && !/* @__PURE__ */ isShallow(self)) {
903		iter._next = iter.next;
904		iter.next = () => {
905			const result = iter._next();
906			if (!result.done) result.value = wrapValue(result.value);
907			return result;
908		};
909	}
910	return iter;
911}
912var arrayProto = Array.prototype;
913function apply(self, method, fn, thisArg, wrappedRetFn, args) {
914	const arr = shallowReadArray(self);
915	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
916	const methodFn = arr[method];
917	if (methodFn !== arrayProto[method]) {
918		const result2 = methodFn.apply(self, args);
919		return needsWrap ? toReactive(result2) : result2;
920	}
921	let wrappedFn = fn;
922	if (arr !== self) {
923		if (needsWrap) wrappedFn = function(item, index) {

924			return fn.call(this, toWrapped(self, item), index, self);
925		};
926		else if (fn.length > 2) wrappedFn = function(item, index) {
927			return fn.call(this, item, index, self);
928		};
929	}
930	const result = methodFn.call(arr, wrappedFn, thisArg);
931	return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
932}
933function reduce(self, method, fn, args) {
934	const arr = shallowReadArray(self);
935	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
936	let wrappedFn = fn;
937	let wrapInitialAccumulator = false;
938	if (arr !== self) {
939		if (needsWrap) {
940			wrapInitialAccumulator = args.length === 0;
941			wrappedFn = function(acc, item, index) {
942				if (wrapInitialAccumulator) {
943					wrapInitialAccumulator = false;
944					acc = toWrapped(self, acc);
945				}
946				return fn.call(this, acc, toWrapped(self, item), index, self);
947			};
948		} else if (fn.length > 3) wrappedFn = function(acc, item, index) {
949			return fn.call(this, acc, item, index, self);
950		};
951	}
952	const result = arr[method](wrappedFn, ...args);
953	return wrapInitialAccumulator ? toWrapped(self, result) : result;
954}
955function searchProxy(self, method, args) {
956	const arr = /* @__PURE__ */ toRaw(self);
957	track(arr, "iterate", ARRAY_ITERATE_KEY);
958	const res = arr[method](...args);

959	if ((res === -1 || res === false) && /* @__PURE__ */ isProxy(args[0])) {
960		args[0] = /* @__PURE__ */ toRaw(args[0]);
961		return arr[method](...args);
962	}
963	return res;
964}
965function noTracking(self, method, args = []) {
966	pauseTracking();
967	startBatch();
968	const res = (/* @__PURE__ */ toRaw(self))[method].apply(self, args);
969	endBatch();
970	resetTracking();
971	return res;
972}
973var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
974var builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
975function hasOwnProperty(key) {
976	if (!isSymbol(key)) key = String(key);
977	const obj = /* @__PURE__ */ toRaw(this);
978	track(obj, "has", key);
979	return obj.hasOwnProperty(key);
980}
981var BaseReactiveHandler = class {
982	constructor(_isReadonly = false, _isShallow = false) {
983		this._isReadonly = _isReadonly;
984		this._isShallow = _isShallow;
985	}
986	get(target, key, receiver) {
987		if (key === "__v_skip") return target["__v_skip"];
988		const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
989		if (key === "__v_isReactive") return !isReadonly2;
990		else if (key === "__v_isReadonly") return isReadonly2;
991		else if (key === "__v_isShallow") return isShallow2;
992		else if (key === "__v_raw") {
993			if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) return target;
994			return;
995		}
996		const targetIsArray = isArray(target);
997		if (!isReadonly2) {
998			let fn;
999			if (targetIsArray && (fn = arrayInstrumentations[key])) return fn;
1000			if (key === "hasOwnProperty") return hasOwnProperty;
1001		}
1002		const res = Reflect.get(target, key, /* @__PURE__ */ isRef(target) ? target : receiver);
1003		if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) return res;
1004		if (!isReadonly2) track(target, "get", key);
1005		if (isShallow2) return res;
1006		if (/* @__PURE__ */ isRef(res)) {
1007			const value = targetIsArray && isIntegerKey(key) ? res : res.value;
1008			return isReadonly2 && isObject$2(value) ? /* @__PURE__ */ readonly(value) : value;
1009		}
1010		if (isObject$2(res)) return isReadonly2 ? /* @__PURE__ */ readonly(res) : /* @__PURE__ */ reactive(res);
1011		return res;
1012	}
1013};
1014var MutableReactiveHandler = class extends BaseReactiveHandler {
1015	constructor(isShallow2 = false) {
1016		super(false, isShallow2);
1017	}
1018	set(target, key, value, receiver) {
1019		let oldValue = target[key];
1020		const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
1021		if (!this._isShallow) {
1022			const isOldValueReadonly = /* @__PURE__ */ isReadonly(oldValue);
1023			if (!/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) {
1024				oldValue = /* @__PURE__ */ toRaw(oldValue);
1025				value = /* @__PURE__ */ toRaw(value);
1026			}
1027			if (!isArrayWithIntegerKey && /* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) {
1028				if (isOldValueReadonly) return true;
1029				else {
1030					oldValue.value = value;
1031					return true;
1032				}
1033			}
1034		}
1035		const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
1036		const result = Reflect.set(target, key, value, /* @__PURE__ */ isRef(target) ? target : receiver);
1037		if (target === /* @__PURE__ */ toRaw(receiver) && result) {
1038			if (!hadKey) trigger(target, "add", key, value);
1039			else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
1040		}
1041		return result;
1042	}
1043	deleteProperty(target, key) {
1044		const hadKey = hasOwn(target, key);
1045		const oldValue = target[key];
1046		const result = Reflect.deleteProperty(target, key);
1047		if (result && hadKey) trigger(target, "delete", key, void 0, oldValue);
1048		return result;
1049	}
1050	has(target, key) {
1051		const result = Reflect.has(target, key);
1052		if (!isSymbol(key) || !builtInSymbols.has(key)) track(target, "has", key);
1053		return result;
1054	}
1055	ownKeys(target) {
1056		track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
1057		return Reflect.ownKeys(target);
1058	}
1059};
1060var ReadonlyReactiveHandler = class extends BaseReactiveHandler {
1061	constructor(isShallow2 = false) {
1062		super(true, isShallow2);
1063	}
1064	set(target, key) {
1065		return true;
1066	}
1067	deleteProperty(target, key) {
1068		return true;
1069	}
1070};
1071var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
1072var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
1073var shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
1074var shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
1075var toShallow = (value) => value;
1076var getProto = (v) => Reflect.getPrototypeOf(v);
1077function createIterableMethod(method, isReadonly2, isShallow2) {
1078	return function(...args) {
1079		const target = this["__v_raw"];
1080		const rawTarget = /* @__PURE__ */ toRaw(target);

1081		const targetIsMap = isMap(rawTarget);
1082		const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
1083		const isKeyOnly = method === "keys" && targetIsMap;
1084		const innerIterator = target[method](...args);
1085		const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
1086		!isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
1087		return extend(Object.create(innerIterator), { next() {
1088			const { value, done } = innerIterator.next();
1089			return done ? {
1090				value,
1091				done
1092			} : {
1093				value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
1094				done
1095			};
1096		} });
1097	};
1098}
1099function createReadonlyMethod(type) {
1100	return function(...args) {
1101		return type === "delete" ? false : type === "clear" ? void 0 : this;
1102	};
1103}
1104function createInstrumentations(readonly, shallow) {
1105	const instrumentations = {
1106		get(key) {
1107			const target = this["__v_raw"];
1108			const rawTarget = /* @__PURE__ */ toRaw(target);
1109			const rawKey = /* @__PURE__ */ toRaw(key);
1110			if (!readonly) {
1111				if (hasChanged(key, rawKey)) track(rawTarget, "get", key);
1112				track(rawTarget, "get", rawKey);
1113			}
1114			const { has } = getProto(rawTarget);
1115			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
1116			if (has.call(rawTarget, key)) return wrap(target.get(key));
1117			else if (has.call(rawTarget, rawKey)) return wrap(target.get(rawKey));
1118			else if (target !== rawTarget) target.get(key);
1119		},
1120		get size() {
1121			const target = this["__v_raw"];
1122			!readonly && track(/* @__PURE__ */ toRaw(target), "iterate", ITERATE_KEY);
1123			return target.size;
1124		},
1125		has(key) {
1126			const target = this["__v_raw"];
1127			const rawTarget = /* @__PURE__ */ toRaw(target);
1128			const rawKey = /* @__PURE__ */ toRaw(key);
1129			if (!readonly) {
1130				if (hasChanged(key, rawKey)) track(rawTarget, "has", key);
1131				track(rawTarget, "has", rawKey);
1132			}
1133			return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
1134		},
1135		forEach(callback, thisArg) {
1136			const observed = this;
1137			const target = observed["__v_raw"];
1138			const rawTarget = /* @__PURE__ */ toRaw(target);
1139			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
1140			!readonly && track(rawTarget, "iterate", ITERATE_KEY);
1141			return target.forEach((value, key) => {
1142				return callback.call(thisArg, wrap(value), wrap(key), observed);
1143			});
1144		}
1145	};
1146	extend(instrumentations, readonly ? {
1147		add: createReadonlyMethod("add"),
1148		set: createReadonlyMethod("set"),
1149		delete: createReadonlyMethod("delete"),
1150		clear: createReadonlyMethod("clear")
1151	} : {
1152		add(value) {
1153			const target = /* @__PURE__ */ toRaw(this);
1154			const proto = getProto(target);
1155			const rawValue = /* @__PURE__ */ toRaw(value);
1156			const valueToAdd = !shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value) ? rawValue : value;
1157			if (!(proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue))) {
1158				target.add(valueToAdd);
1159				trigger(target, "add", valueToAdd, valueToAdd);
1160			}
1161			return this;
1162		},
1163		set(key, value) {
1164			if (!shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) value = /* @__PURE__ */ toRaw(value);
1165			const target = /* @__PURE__ */ toRaw(this);
1166			const { has, get } = getProto(target);
1167			let hadKey = has.call(target, key);
1168			if (!hadKey) {
1169				key = /* @__PURE__ */ toRaw(key);
1170				hadKey = has.call(target, key);
1171			}
1172			const oldValue = get.call(target, key);
1173			target.set(key, value);
1174			if (!hadKey) trigger(target, "add", key, value);
1175			else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
1176			return this;
1177		},
1178		delete(key) {
1179			const target = /* @__PURE__ */ toRaw(this);
1180			const { has, get } = getProto(target);
1181			let hadKey = has.call(target, key);
1182			if (!hadKey) {
1183				key = /* @__PURE__ */ toRaw(key);
1184				hadKey = has.call(target, key);
1185			}
1186			const oldValue = get ? get.call(target, key) : void 0;
1187			const result = target.delete(key);
1188			if (hadKey) trigger(target, "delete", key, void 0, oldValue);
1189			return result;
1190		},
1191		clear() {
1192			const target = /* @__PURE__ */ toRaw(this);
1193			const hadItems = target.size !== 0;
1194			const oldTarget = void 0;
1195			const result = target.clear();
1196			if (hadItems) trigger(target, "clear", void 0, void 0, oldTarget);
1197			return result;
1198		}
1199	});
1200	[
1201		"keys",
1202		"values",
1203		"entries",
1204		Symbol.iterator
1205	].forEach((method) => {
1206		instrumentations[method] = createIterableMethod(method, readonly, shallow);
1207	});
1208	return instrumentations;
1209}
1210function createInstrumentationGetter(isReadonly2, shallow) {
1211	const instrumentations = createInstrumentations(isReadonly2, shallow);
1212	return (target, key, receiver) => {
1213		if (key === "__v_isReactive") return !isReadonly2;
1214		else if (key === "__v_isReadonly") return isReadonly2;
1215		else if (key === "__v_raw") return target;
1216		return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
1217	};
1218}
1219var mutableCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, false) };
1220var shallowCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, true) };
1221var readonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, false) };
1222var shallowReadonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, true) };
1223var reactiveMap = /* @__PURE__ */ new WeakMap();
1224var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
1225var readonlyMap = /* @__PURE__ */ new WeakMap();
1226var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
1227function targetTypeMap(rawType) {
1228	switch (rawType) {
1229		case "Object":
1230		case "Array": return 1;
1231		case "Map":
1232		case "Set":
1233		case "WeakMap":
1234		case "WeakSet": return 2;
1235		default: return 0;
1236	}
1237}
1238// @__NO_SIDE_EFFECTS__
1239function reactive(target) {
1240	if (/* @__PURE__ */ isReadonly(target)) return target;
1241	return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
1242}
1243// @__NO_SIDE_EFFECTS__
1244function shallowReactive(target) {
1245	return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
1246}
1247// @__NO_SIDE_EFFECTS__
1248function readonly(target) {
1249	return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
1250}
1251// @__NO_SIDE_EFFECTS__
1252function shallowReadonly(target) {
1253	return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
1254}
1255function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
1256	if (!isObject$2(target)) return target;
1257	if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) return target;
1258	if (target["__v_skip"] || !Object.isExtensible(target)) return target;
1259	const existingProxy = proxyMap.get(target);
1260	if (existingProxy) return existingProxy;
1261	const targetType = targetTypeMap(toRawType(target));
1262	if (targetType === 0) return target;
1263	const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
1264	proxyMap.set(target, proxy);
1265	return proxy;
1266}
1267// @__NO_SIDE_EFFECTS__
1268function isReactive(value) {
1269	if (/* @__PURE__ */ isReadonly(value)) return /* @__PURE__ */ isReactive(value["__v_raw"]);
1270	return !!(value && value["__v_isReactive"]);
1271}
1272// @__NO_SIDE_EFFECTS__
1273function isReadonly(value) {
1274	return !!(value && value["__v_isReadonly"]);
1275}
1276// @__NO_SIDE_EFFECTS__
1277function isShallow(value) {
1278	return !!(value && value["__v_isShallow"]);
1279}
1280// @__NO_SIDE_EFFECTS__
1281function isProxy(value) {
1282	return value ? !!value["__v_raw"] : false;

1283}
1284// @__NO_SIDE_EFFECTS__
1285function toRaw(observed) {
1286	const raw = observed && observed["__v_raw"];
1287	return raw ? /* @__PURE__ */ toRaw(raw) : observed;
1288}
1289function markRaw(value) {
1290	if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) def(value, "__v_skip", true);
1291	return value;
1292}
1293var toReactive = (value) => isObject$2(value) ? /* @__PURE__ */ reactive(value) : value;
1294var toReadonly = (value) => isObject$2(value) ? /* @__PURE__ */ readonly(value) : value;
1295// @__NO_SIDE_EFFECTS__
1296function isRef(r) {
1297	return r ? r["__v_isRef"] === true : false;
1298}
1299// @__NO_SIDE_EFFECTS__
1300function ref(value) {
1301	return createRef(value, false);
1302}
1303// @__NO_SIDE_EFFECTS__
1304function shallowRef(value) {
1305	return createRef(value, true);
1306}
1307function createRef(rawValue, shallow) {
1308	if (/* @__PURE__ */ isRef(rawValue)) return rawValue;
1309	return new RefImpl(rawValue, shallow);
1310}
1311var RefImpl = class {
1312	constructor(value, isShallow2) {
1313		this.dep = new Dep();
1314		this["__v_isRef"] = true;
1315		this["__v_isShallow"] = false;
1316		this._rawValue = isShallow2 ? value : /* @__PURE__ */ toRaw(value);
1317		this._value = isShallow2 ? value : toReactive(value);
1318		this["__v_isShallow"] = isShallow2;
1319	}
1320	get value() {
1321		this.dep.track();
1322		return this._value;
1323	}
1324	set value(newValue) {
1325		const oldValue = this._rawValue;

1326		const useDirectValue = this["__v_isShallow"] || /* @__PURE__ */ isShallow(newValue) || /* @__PURE__ */ isReadonly(newValue);
1327		newValue = useDirectValue ? newValue : /* @__PURE__ */ toRaw(newValue);
1328		if (hasChanged(newValue, oldValue)) {
1329			this._rawValue = newValue;
1330			this._value = useDirectValue ? newValue : toReactive(newValue);
1331			this.dep.trigger();
1332		}
1333	}
1334};
1335function unref(ref2) {
1336	return /* @__PURE__ */ isRef(ref2) ? ref2.value : ref2;
1337}
1338function toValue(source) {
1339	return isFunction(source) ? source() : unref(source);
1340}
1341var shallowUnwrapHandlers = {
1342	get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
1343	set: (target, key, value, receiver) => {
1344		const oldValue = target[key];
1345		if (/* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) {
1346			oldValue.value = value;
1347			return true;
1348		} else return Reflect.set(target, key, value, receiver);
1349	}
1350};
1351function proxyRefs(objectWithRefs) {
1352	return /* @__PURE__ */ isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1353}
1354var CustomRefImpl = class {
1355	constructor(factory) {
1356		this["__v_isRef"] = true;
1357		this._value = void 0;
1358		const dep = this.dep = new Dep();
1359		const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
1360		this._get = get;
1361		this._set = set;
1362	}
1363	get value() {
1364		return this._value = this._get();
1365	}
1366	set value(newVal) {
1367		this._set(newVal);
1368	}
1369};
1370function customRef(factory) {
1371	return new CustomRefImpl(factory);
1372}
1373var ObjectRefImpl = class {
1374	constructor(_object, key, _defaultValue) {
1375		this._object = _object;
1376		this._defaultValue = _defaultValue;
1377		this["__v_isRef"] = true;
1378		this._value = void 0;
1379		this._key = isSymbol(key) ? key : String(key);
1380		this._raw = /* @__PURE__ */ toRaw(_object);
1381		let shallow = true;
1382		let obj = _object;
1383		if (!isArray(_object) || isSymbol(this._key) || !isIntegerKey(this._key)) do
1384			shallow = !/* @__PURE__ */ isProxy(obj) || /* @__PURE__ */ isShallow(obj);
1385		while (shallow && (obj = obj["__v_raw"]));
1386		this._shallow = shallow;
1387	}
1388	get value() {
1389		let val = this._object[this._key];
1390		if (this._shallow) val = unref(val);
1391		return this._value = val === void 0 ? this._defaultValue : val;
1392	}
1393	set value(newVal) {

1394		if (this._shallow && /* @__PURE__ */ isRef(this._raw[this._key])) {
1395			const nestedRef = this._object[this._key];
1396			if (/* @__PURE__ */ isRef(nestedRef)) {
1397				nestedRef.value = newVal;
1398				return;
1399			}
1400		}
1401		this._object[this._key] = newVal;
1402	}
1403	get dep() {
1404		return getDepFromReactive(this._raw, this._key);
1405	}
1406};
1407var GetterRefImpl = class {
1408	constructor(_getter) {
1409		this._getter = _getter;
1410		this["__v_isRef"] = true;
1411		this["__v_isReadonly"] = true;
1412		this._value = void 0;
1413	}
1414	get value() {
1415		return this._value = this._getter();
1416	}
1417};
1418// @__NO_SIDE_EFFECTS__
1419function toRef$1(source, key, defaultValue) {
1420	if (/* @__PURE__ */ isRef(source)) return source;
1421	else if (isFunction(source)) return new GetterRefImpl(source);
1422	else if (isObject$2(source) && arguments.length > 1) return propertyToRef(source, key, defaultValue);
1423	else return /* @__PURE__ */ ref(source);
1424}
1425function propertyToRef(source, key, defaultValue) {
1426	return new ObjectRefImpl(source, key, defaultValue);
1427}
1428var ComputedRefImpl = class {
1429	constructor(fn, setter, isSSR) {
1430		this.fn = fn;
1431		this.setter = setter;
1432		/**
1433		* @internal
1434		*/
1435		this._value = void 0;
1436		/**
1437		* @internal
1438		*/
1439		this.dep = new Dep(this);
1440		/**
1441		* @internal
1442		*/
1443		this.__v_isRef = true;
1444		/**
1445		* @internal
1446		*/
1447		this.deps = void 0;
1448		/**
1449		* @internal
1450		*/
1451		this.depsTail = void 0;
1452		/**
1453		* @internal
1454		*/
1455		this.flags = 16;
1456		/**
1457		* @internal
1458		*/
1459		this.globalVersion = globalVersion - 1;
1460		/**
1461		* @internal
1462		*/
1463		this.next = void 0;
1464		this.effect = this;
1465		this["__v_isReadonly"] = !setter;
1466		this.isSSR = isSSR;
1467	}
1468	/**
1469	* @internal
1470	*/
1471	notify() {
1472		this.flags |= 16;
1473		if (!(this.flags & 8) && activeSub !== this) {
1474			batch(this, true);
1475			return true;
1476		}
1477	}
1478	get value() {
1479		const link = this.dep.track();
1480		refreshComputed(this);
1481		if (link) link.version = this.dep.version;
1482		return this._value;
1483	}
1484	set value(newValue) {
1485		if (this.setter) this.setter(newValue);
1486	}
1487};
1488// @__NO_SIDE_EFFECTS__
1489function computed$1(getterOrOptions, debugOptions, isSSR = false) {
1490	let getter;
1491	let setter;
1492	if (isFunction(getterOrOptions)) getter = getterOrOptions;
1493	else {
1494		getter = getterOrOptions.get;
1495		setter = getterOrOptions.set;
1496	}
1497	return new ComputedRefImpl(getter, setter, isSSR);
1498}
1499var INITIAL_WATCHER_VALUE = {};
1500var cleanupMap = /* @__PURE__ */ new WeakMap();
1501var activeWatcher = void 0;
1502function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
1503	if (owner) {
1504		let cleanups = cleanupMap.get(owner);
1505		if (!cleanups) cleanupMap.set(owner, cleanups = []);
1506		cleanups.push(cleanupFn);
1507	}
1508}
1509function watch$1(source, cb, options = EMPTY_OBJ) {
1510	const { immediate, deep, once, scheduler, augmentJob, call } = options;
1511	const reactiveGetter = (source2) => {
1512		if (deep) return source2;
1513		if (/* @__PURE__ */ isShallow(source2) || deep === false || deep === 0) return traverse(source2, 1);
1514		return traverse(source2);
1515	};
1516	let effect;
1517	let getter;
1518	let cleanup;
1519	let boundCleanup;
1520	let forceTrigger = false;
1521	let isMultiSource = false;

1522	if (/* @__PURE__ */ isRef(source)) {
1523		getter = () => source.value;
1524		forceTrigger = /* @__PURE__ */ isShallow(source);
1525	} else if (/* @__PURE__ */ isReactive(source)) {
1526		getter = () => reactiveGetter(source);
1527		forceTrigger = true;
1528	} else if (isArray(source)) {
1529		isMultiSource = true;
1530		forceTrigger = source.some((s) => /* @__PURE__ */ isReactive(s) || /* @__PURE__ */ isShallow(s));
1531		getter = () => source.map((s) => {
1532			if (/* @__PURE__ */ isRef(s)) return s.value;
1533			else if (/* @__PURE__ */ isReactive(s)) return reactiveGetter(s);
1534			else if (isFunction(s)) return call ? call(s, 2) : s();
1535		});
1536	} else if (isFunction(source)) {
1537		if (cb) getter = call ? () => call(source, 2) : source;
1538		else getter = () => {
1539			if (cleanup) {
1540				pauseTracking();
1541				try {
1542					cleanup();
1543				} finally {
1544					resetTracking();
1545				}
1546			}
1547			const currentEffect = activeWatcher;
1548			activeWatcher = effect;
1549			try {
1550				return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
1551			} finally {
1552				activeWatcher = currentEffect;
1553			}
1554		};
1555	} else getter = NOOP;
1556	if (cb && deep) {
1557		const baseGetter = getter;
1558		const depth = deep === true ? Infinity : deep;
1559		getter = () => traverse(baseGetter(), depth);
1560	}
1561	const scope = getCurrentScope();
1562	const watchHandle = () => {
1563		effect.stop();
1564		if (scope && scope.active) remove(scope.effects, effect);
1565	};
1566	if (once && cb) {
1567		const _cb = cb;
1568		cb = (...args) => {
1569			const res = _cb(...args);
1570			watchHandle();
1571			return res;
1572		};
1573	}
1574	let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
1575	const job = (immediateFirstRun) => {
1576		if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) return;
1577		if (cb) {
1578			const newValue = effect.run();
1579			if (immediateFirstRun || deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
1580				if (cleanup) cleanup();
1581				const currentWatcher = activeWatcher;
1582				activeWatcher = effect;
1583				try {
1584					const args = [
1585						newValue,
1586						oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
1587						boundCleanup
1588					];
1589					oldValue = newValue;
1590					call ? call(cb, 3, args) : cb(...args);
1591				} finally {
1592					activeWatcher = currentWatcher;
1593				}
1594			}
1595		} else effect.run();
1596	};
1597	if (augmentJob) augmentJob(job);
1598	effect = new ReactiveEffect(getter);
1599	effect.scheduler = scheduler ? () => scheduler(job, false) : job;
1600	boundCleanup = (fn) => onWatcherCleanup(fn, false, effect);
1601	cleanup = effect.onStop = () => {
1602		const cleanups = cleanupMap.get(effect);
1603		if (cleanups) {
1604			if (call) call(cleanups, 4);
1605			else for (const cleanup2 of cleanups) cleanup2();
1606			cleanupMap.delete(effect);
1607		}
1608	};
1609	if (cb) {
1610		if (immediate) job(true);
1611		else oldValue = effect.run();
1612	} else if (scheduler) scheduler(job.bind(null, true), true);
1613	else effect.run();
1614	watchHandle.pause = effect.pause.bind(effect);
1615	watchHandle.resume = effect.resume.bind(effect);
1616	watchHandle.stop = watchHandle;
1617	return watchHandle;
1618}
1619function traverse(value, depth = Infinity, seen) {
1620	if (depth <= 0 || !isObject$2(value) || value["__v_skip"]) return value;
1621	seen = seen || /* @__PURE__ */ new Map();
1622	if ((seen.get(value) || 0) >= depth) return value;
1623	seen.set(value, depth);
1624	depth--;
1625	if (/* @__PURE__ */ isRef(value)) traverse(value.value, depth, seen);
1626	else if (isArray(value)) for (let i = 0; i < value.length; i++) traverse(value[i], depth, seen);
1627	else if (isSet(value) || isMap(value)) value.forEach((v) => {
1628		traverse(v, depth, seen);
1629	});
1630	else if (isPlainObject(value)) {
1631		for (const key in value) traverse(value[key], depth, seen);
1632		for (const key of Object.getOwnPropertySymbols(value)) if (Object.prototype.propertyIsEnumerable.call(value, key)) traverse(value[key], depth, seen);
1633	}
1634	return value;
1635}
1636//#endregion
1637//#region node_modules/.pnpm/@[email protected]/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
1638/**
1639* @vue/runtime-core v3.5.43
1640* (c) 2018-present Yuxi (Evan) You and Vue contributors
1641* @license MIT

1642**/
1643var stack = [];
1644var isWarning = false;
1645function warn$1(msg, ...args) {
1646	if (isWarning) return;
1647	isWarning = true;
1648	pauseTracking();
1649	const instance = stack.length ? stack[stack.length - 1].component : null;
1650	const appWarnHandler = instance && instance.appContext.config.warnHandler;
1651	const trace = getComponentTrace();
1652	if (appWarnHandler) callWithErrorHandling(appWarnHandler, instance, 11, [
1653		msg + args.map((a) => {
1654			var _a, _b;
1655			return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
1656		}).join(""),
1657		instance && instance.proxy,
1658		trace.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`).join("\n"),
1659		trace
1660	]);
1661	else {
1662		const warnArgs = [`[Vue warn]: ${msg}`, ...args];
1663		if (trace.length && true) warnArgs.push(`
1664`, ...formatTrace(trace));
1665		console.warn(...warnArgs);
1666	}
1667	resetTracking();
1668	isWarning = false;
1669}
1670function getComponentTrace() {
1671	let currentVNode = stack[stack.length - 1];
1672	if (!currentVNode) return [];
1673	const normalizedStack = [];
1674	while (currentVNode) {
1675		const last = normalizedStack[0];
1676		if (last && last.vnode === currentVNode) last.recurseCount++;
1677		else normalizedStack.push({
1678			vnode: currentVNode,
1679			recurseCount: 0
1680		});
1681		const parentInstance = currentVNode.component && currentVNode.component.parent;
1682		currentVNode = parentInstance && parentInstance.vnode;
1683	}
1684	return normalizedStack;
1685}
1686function formatTrace(trace) {
1687	const logs = [];
1688	trace.forEach((entry, i) => {
1689		logs.push(...i === 0 ? [] : [`
1690`], ...formatTraceEntry(entry));
1691	});
1692	return logs;
1693}
1694function formatTraceEntry({ vnode, recurseCount }) {
1695	const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
1696	const isRoot = vnode.component ? vnode.component.parent == null : false;
1697	const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
1698	const close = `>` + postfix;
1699	return vnode.props ? [
1700		open,
1701		...formatProps(vnode.props),
1702		close
1703	] : [open + close];
1704}
1705function formatProps(props) {
1706	const res = [];
1707	const keys = Object.keys(props);
1708	keys.slice(0, 3).forEach((key) => {
1709		res.push(...formatProp(key, props[key]));
1710	});
1711	if (keys.length > 3) res.push(` ...`);
1712	return res;
1713}
1714function formatProp(key, value, raw) {
1715	if (isString(value)) {
1716		value = JSON.stringify(value);
1717		return raw ? value : [`${key}=${value}`];
1718	} else if (typeof value === "number" || typeof value === "boolean" || value == null) return raw ? value : [`${key}=${value}`];
1719	else if (/* @__PURE__ */ isRef(value)) {
1720		value = formatProp(key, /* @__PURE__ */ toRaw(value.value), true);
1721		return raw ? value : [
1722			`${key}=Ref<`,
1723			value,
1724			`>`
1725		];
1726	} else if (isFunction(value)) return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
1727	else {
1728		value = /* @__PURE__ */ toRaw(value);
1729		return raw ? value : [`${key}=`, value];
1730	}
1731}
1732function callWithErrorHandling(fn, instance, type, args) {
1733	try {
1734		return args ? fn(...args) : fn();
1735	} catch (err) {
1736		handleError(err, instance, type);
1737	}
1738}
1739function callWithAsyncErrorHandling(fn, instance, type, args) {
1740	if (isFunction(fn)) {
1741		const res = callWithErrorHandling(fn, instance, type, args);
1742		if (res && isPromise(res)) res.catch((err) => {
1743			handleError(err, instance, type);
1744		});
1745		return res;
1746	}
1747	if (isArray(fn)) {
1748		const values = [];
1749		for (let i = 0; i < fn.length; i++) values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
1750		return values;
1751	}
1752}
1753function handleError(err, instance, type, throwInDev = true) {
1754	const contextVNode = instance ? instance.vnode : null;
1755	const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
1756	if (instance) {
1757		let cur = instance.parent;
1758		const exposedInstance = instance.proxy;
1759		const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
1760		while (cur) {

1761			const errorCapturedHooks = cur.ec;
1762			if (errorCapturedHooks) {
1763				for (let i = 0; i < errorCapturedHooks.length; i++) if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) return;
1764			}
1765			cur = cur.parent;
1766		}
1767		if (errorHandler) {
1768			pauseTracking();
1769			callWithErrorHandling(errorHandler, null, 10, [
1770				err,
1771				exposedInstance,
1772				errorInfo
1773			]);
1774			resetTracking();
1775			return;
1776		}
1777	}
1778	logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
1779}
1780function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
1781	if (throwInProd) throw err;
1782	else console.error(err);
1783}
1784var queue = [];
1785var flushIndex = -1;
1786var pendingPostFlushCbs = [];
1787var activePostFlushCbs = null;
1788var postFlushIndex = 0;
1789var resolvedPromise = /* @__PURE__ */ Promise.resolve();
1790var currentFlushPromise = null;
1791function nextTick(fn) {
1792	const p = currentFlushPromise || resolvedPromise;
1793	return fn ? p.then(this ? fn.bind(this) : fn) : p;
1794}
1795function findInsertionIndex(id) {
1796	let start = flushIndex + 1;
1797	let end = queue.length;
1798	while (start < end) {
1799		const middle = start + end >>> 1;
1800		const middleJob = queue[middle];
1801		const middleJobId = getId(middleJob);
1802		if (middleJobId < id || middleJobId === id && middleJob.flags & 2) start = middle + 1;
1803		else end = middle;
1804	}
1805	return start;
1806}
1807function queueJob(job) {
1808	if (!(job.flags & 1)) {
1809		const jobId = getId(job);
1810		const lastJob = queue[queue.length - 1];
1811		if (!lastJob || !(job.flags & 2) && jobId >= getId(lastJob)) queue.push(job);
1812		else queue.splice(findInsertionIndex(jobId), 0, job);
1813		job.flags |= 1;
1814		queueFlush();
1815	}
1816}
1817function queueFlush() {
1818	if (!currentFlushPromise) currentFlushPromise = resolvedPromise.then(flushJobs);
1819}
1820function queuePostFlushCb(cb) {
1821	if (!isArray(cb)) {
1822		if (activePostFlushCbs && cb.id === -1) activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
1823		else if (!(cb.flags & 1)) {
1824			pendingPostFlushCbs.push(cb);
1825			cb.flags |= 1;
1826		}
1827	} else for (let i = 0; i < cb.length; i++) pendingPostFlushCbs.push(cb[i]);
1828	queueFlush();
1829}
1830function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
1831	for (; i < queue.length; i++) {
1832		const cb = queue[i];
1833		if (cb && cb.flags & 2) {
1834			if (instance && cb.id !== instance.uid) continue;
1835			queue.splice(i, 1);
1836			i--;
1837			if (cb.flags & 4) cb.flags &= -2;
1838			cb();
1839			if (!(cb.flags & 4)) cb.flags &= -2;
1840		}
1841	}
1842}
1843function flushPostFlushCbs(seen) {
1844	if (pendingPostFlushCbs.length) {
1845		const deduped = [...new Set(pendingPostFlushCbs)].sort((a, b) => getId(a) - getId(b));
1846		pendingPostFlushCbs.length = 0;
1847		if (activePostFlushCbs) {
1848			for (let i = 0; i < deduped.length; i++) activePostFlushCbs.push(deduped[i]);
1849			return;
1850		}
1851		activePostFlushCbs = deduped;
1852		for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
1853			const cb = activePostFlushCbs[postFlushIndex];
1854			if (cb.flags & 4) cb.flags &= -2;
1855			if (!(cb.flags & 8)) cb();
1856			cb.flags &= -2;
1857		}
1858		activePostFlushCbs = null;
1859		postFlushIndex = 0;
1860	}
1861}
1862var getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
1863function flushJobs(seen) {
1864	try {
1865		for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
1866			const job = queue[flushIndex];
1867			if (job && !(job.flags & 8)) {
1868				if (job.flags & 4) job.flags &= -2;
1869				callWithErrorHandling(job, job.i, job.i ? 15 : 14);
1870				if (!(job.flags & 4)) job.flags &= -2;
1871			}
1872		}
1873	} finally {
1874		for (; flushIndex < queue.length; flushIndex++) {
1875			const job = queue[flushIndex];
1876			if (job) job.flags &= -2;
1877		}
1878		flushIndex = -1;
1879		queue.length = 0;
1880		flushPostFlushCbs(seen);
1881		currentFlushPromise = null;
1882		if (queue.length || pendingPostFlushCbs.length) flushJobs(seen);
1883	}
1884}
1885var currentRenderingInstance = null;
1886var currentScopeId = null;
1887function setCurrentRenderingInstance(instance) {
1888	const prev = currentRenderingInstance;
1889	currentRenderingInstance = instance;
1890	currentScopeId = instance && instance.type.__scopeId || null;
1891	return prev;
1892}
1893function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
1894	if (!ctx) return fn;
1895	if (fn._n) return fn;
1896	const renderFnWithContext = (...args) => {
1897		if (renderFnWithContext._d) setBlockTracking(-1);
1898		const prevInstance = setCurrentRenderingInstance(ctx);
1899		const prevStackSize = blockStack.length;
1900		let res;
1901		try {
1902			res = fn(...args);
1903		} finally {
1904			for (let i = blockStack.length; i > prevStackSize; i--) closeBlock();
1905			setCurrentRenderingInstance(prevInstance);
1906			if (renderFnWithContext._d) setBlockTracking(1);
1907		}
1908		return res;
1909	};
1910	renderFnWithContext._n = true;
1911	renderFnWithContext._c = true;
1912	renderFnWithContext._d = true;
1913	return renderFnWithContext;
1914}
1915function withDirectives(vnode, directives) {
1916	if (currentRenderingInstance === null) return vnode;
1917	const instance = getComponentPublicInstance(currentRenderingInstance);
1918	const bindings = vnode.dirs || (vnode.dirs = []);
1919	for (let i = 0; i < directives.length; i++) {
1920		let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
1921		if (dir) {
1922			if (isFunction(dir)) dir = {
1923				mounted: dir,
1924				updated: dir
1925			};
1926			if (dir.deep) traverse(value);
1927			bindings.push({
1928				dir,
1929				instance,
1930				value,
1931				oldValue: void 0,
1932				arg,
1933				modifiers
1934			});
1935		}
1936	}
1937	return vnode;
1938}
1939function invokeDirectiveHook(vnode, prevVNode, instance, name) {
1940	const bindings = vnode.dirs;
1941	const oldBindings = prevVNode && prevVNode.dirs;
1942	for (let i = 0; i < bindings.length; i++) {
1943		const binding = bindings[i];
1944		if (oldBindings) binding.oldValue = oldBindings[i].value;
1945		let hook = binding.dir[name];
1946		if (hook) {
1947			pauseTracking();

1948			callWithAsyncErrorHandling(hook, instance, 8, [
1949				vnode.el,
1950				binding,
1951				vnode,
1952				prevVNode
1953			]);
1954			resetTracking();
1955		}
1956	}
1957}
1958function provide(key, value) {
1959	if (currentInstance) {
1960		let provides = currentInstance.provides;
1961		const parentProvides = currentInstance.parent && currentInstance.parent.provides;
1962		if (parentProvides === provides) provides = currentInstance.provides = Object.create(parentProvides);
1963		provides[key] = value;
1964	}
1965}
1966function inject(key, defaultValue, treatDefaultAsFactory = false) {
1967	const instance = getCurrentInstance();
1968	if (instance || currentApp) {
1969		let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
1970		if (provides && key in provides) return provides[key];
1971		else if (arguments.length > 1) return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
1972	}
1973}
1974function hasInjectionContext() {
1975	return !!(getCurrentInstance() || currentApp);
1976}
1977var ssrContextKey = /* @__PURE__ */ Symbol.for("v-scx");
1978var useSSRContext = () => {
1979	{
1980		const ctx = inject(ssrContextKey);
1981		if (!ctx) {}
1982		return ctx;
1983	}
1984};
1985function watchEffect(effect, options) {
1986	return doWatch(effect, null, options);
1987}
1988function watchPostEffect(effect, options) {
1989	return doWatch(effect, null, { flush: "post" });
1990}
1991function watch(source, cb, options) {
1992	return doWatch(source, cb, options);
1993}
1994function doWatch(source, cb, options = EMPTY_OBJ) {
1995	const { immediate, deep, flush, once } = options;
1996	const baseWatchOptions = extend({}, options);
1997	const runsImmediately = cb && immediate || !cb && flush !== "post";
1998	let ssrCleanup;
1999	if (isInSSRComponentSetup) {
2000		if (flush === "sync") {
2001			const ctx = useSSRContext();
2002			ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
2003		} else if (!runsImmediately) {
2004			const watchStopHandle = () => {};
2005			watchStopHandle.stop = NOOP;
2006			watchStopHandle.resume = NOOP;
2007			watchStopHandle.pause = NOOP;
2008			return watchStopHandle;
2009		}
2010	}
2011	const instance = currentInstance;
2012	baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
2013	let isPre = false;
2014	if (flush === "post") baseWatchOptions.scheduler = (job) => {
2015		queuePostRenderEffect(job, instance && instance.suspense);
2016	};
2017	else if (flush !== "sync") {
2018		isPre = true;
2019		baseWatchOptions.scheduler = (job, isFirstRun) => {
2020			if (isFirstRun) job();
2021			else queueJob(job);
2022		};
2023	}
2024	baseWatchOptions.augmentJob = (job) => {
2025		if (cb) job.flags |= 4;
2026		if (isPre) {
2027			job.flags |= 2;
2028			if (instance) {
2029				job.id = instance.uid;
2030				job.i = instance;
2031			}
2032		}
2033	};
2034	const watchHandle = watch$1(source, cb, baseWatchOptions);
2035	if (isInSSRComponentSetup) {
2036		if (ssrCleanup) ssrCleanup.push(watchHandle);
2037		else if (runsImmediately) watchHandle();
2038	}
2039	return watchHandle;
2040}
2041function instanceWatch(source, value, options) {
2042	const publicThis = this.proxy;
2043	const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
2044	let cb;
2045	if (isFunction(value)) cb = value;
2046	else {
2047		cb = value.handler;
2048		options = value;
2049	}
2050	const reset = setCurrentInstance(this);
2051	const res = doWatch(getter, cb.bind(publicThis), options);
2052	reset();
2053	return res;
2054}
2055function createPathGetter(ctx, path) {
2056	const segments = path.split(".");
2057	return () => {
2058		let cur = ctx;
2059		for (let i = 0; i < segments.length && cur; i++) cur = cur[segments[i]];
2060		return cur;
2061	};
2062}
2063var pendingMounts = /* @__PURE__ */ new WeakMap();
2064var TeleportEndKey = /* @__PURE__ */ Symbol("_vte");
2065var isTeleport = (type) => type.__isTeleport;
2066var isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
2067var isTeleportDeferred = (props) => props && (props.defer || props.defer === "");
2068var isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
2069var isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement;
2070var resolveTarget = (props, select) => {
2071	const targetSelector = props && props.to;

2072	if (isString(targetSelector)) {
2073		if (!select) return null;
2074		else return select(targetSelector);
2075	} else return targetSelector;
2076};
2077var TeleportImpl = {
2078	name: "Teleport",
2079	__isTeleport: true,
2080	process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) {
2081		const { mc: mountChildren, pc: patchChildren, pbc: patchBlockChildren, o: { insert, querySelector, createText, createComment, parentNode } } = internals;
2082		const disabled = isTeleportDisabled(n2.props);
2083		let { dynamicChildren } = n2;
2084		const mount = (vnode, container2, anchor2) => {
2085			if (vnode.shapeFlag & 16) mountChildren(vnode.children, container2, anchor2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
2086		};
2087		const mountToTarget = (vnode = n2) => {
2088			const disabled2 = isTeleportDisabled(vnode.props);
2089			const target = vnode.target = resolveTarget(vnode.props, querySelector);
2090			const targetAnchor = prepareAnchor(target, vnode, createText, insert);
2091			if (target) {
2092				if (namespace !== "svg" && isTargetSVG(target)) namespace = "svg";
2093				else if (namespace !== "mathml" && isTargetMathML(target)) namespace = "mathml";
2094				if (parentComponent && parentComponent.isCE) (parentComponent.ce._teleportTargets || (parentComponent.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target);
2095				if (!disabled2) {
2096					mount(vnode, target, targetAnchor);
2097					updateCssVars(vnode, false);
2098				}
2099			}
2100		};
2101		const queuePendingMount = (vnode) => {
2102			const mountJob = () => {
2103				if (pendingMounts.get(vnode) !== mountJob) return;
2104				pendingMounts.delete(vnode);
2105				if (isTeleportDisabled(vnode.props)) {
2106					const mountContainer = parentNode(vnode.el) || container;
2107					mount(vnode, mountContainer, vnode.anchor);
2108					updateCssVars(vnode, true);
2109				}
2110				mountToTarget(vnode);
2111			};
2112			pendingMounts.set(vnode, mountJob);
2113			queuePostRenderEffect(mountJob, parentSuspense);
2114		};
2115		if (n1 == null) {
2116			const placeholder = n2.el = createText("");
2117			const mainAnchor = n2.anchor = createText("");
2118			insert(placeholder, container, anchor);
2119			insert(mainAnchor, container, anchor);
2120			if (isTeleportDeferred(n2.props) || parentSuspense && parentSuspense.pendingBranch) {
2121				queuePendingMount(n2);
2122				return;
2123			}
2124			if (disabled) {
2125				mount(n2, container, mainAnchor);
2126				updateCssVars(n2, true);
2127			}
2128			mountToTarget();
2129		} else {
2130			n2.el = n1.el;
2131			const mainAnchor = n2.anchor = n1.anchor;
2132			const pendingMount = pendingMounts.get(n1);
2133			if (pendingMount) {
2134				pendingMount.flags |= 8;
2135				pendingMounts.delete(n1);
2136				queuePendingMount(n2);
2137				return;
2138			}
2139			n2.targetStart = n1.targetStart;
2140			const target = n2.target = n1.target;
2141			const targetAnchor = n2.targetAnchor = n1.targetAnchor;
2142			const wasDisabled = isTeleportDisabled(n1.props);
2143			const currentContainer = wasDisabled ? container : target;
2144			const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
2145			if (namespace === "svg" || isTargetSVG(target)) namespace = "svg";
2146			else if (namespace === "mathml" || isTargetMathML(target)) namespace = "mathml";
2147			if (dynamicChildren) {
2148				patchBlockChildren(n1.dynamicChildren, dynamicChildren, currentContainer, parentComponent, parentSuspense, namespace, slotScopeIds);
2149				traverseStaticChildren(n1, n2, true);
2150			} else if (!optimized) patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, false);
2151			if (disabled) {
2152				if (!wasDisabled) moveTeleport(n2, container, mainAnchor, internals, 1);
2153				else if (n2.props && n1.props && n2.props.to !== n1.props.to) n2.props.to = n1.props.to;
2154			} else if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
2155				const nextTarget = resolveTarget(n2.props, querySelector);
2156				if (nextTarget) {
2157					n2.target = nextTarget;
2158					moveTeleport(n2, nextTarget, null, internals, 0);
2159				}
2160			} else if (wasDisabled) moveTeleport(n2, target, targetAnchor, internals, 1);
2161			updateCssVars(n2, disabled);
2162		}
2163	},
2164	remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) {
2165		const { shapeFlag, children, anchor, targetStart, targetAnchor, target, props } = vnode;
2166		const disabled = isTeleportDisabled(props);
2167		const shouldRemove = doRemove || !disabled;
2168		const pendingMount = pendingMounts.get(vnode);
2169		if (pendingMount) {
2170			pendingMount.flags |= 8;
2171			pendingMounts.delete(vnode);
2172		}
2173		if (target) {

2174			hostRemove(targetStart);
2175			hostRemove(targetAnchor);
2176		}
2177		doRemove && hostRemove(anchor);
2178		if (!pendingMount && (disabled || target) && shapeFlag & 16) for (let i = 0; i < children.length; i++) {
2179			const child = children[i];
2180			unmount(child, parentComponent, parentSuspense, shouldRemove, !!child.dynamicChildren);
2181		}
2182	},
2183	move: moveTeleport,
2184	hydrate: hydrateTeleport
2185};
2186function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
2187	if (moveType === 0) insert(vnode.targetAnchor, container, parentAnchor);
2188	const { el, anchor, shapeFlag, children, props } = vnode;
2189	const isReorder = moveType === 2;
2190	if (isReorder) insert(el, container, parentAnchor);
2191	if (!pendingMounts.has(vnode) && (!isReorder || isTeleportDisabled(props))) {
2192		if (shapeFlag & 16) for (let i = 0; i < children.length; i++) move(children[i], container, parentAnchor, 2);
2193	}
2194	if (isReorder) insert(anchor, container, parentAnchor);
2195}
2196function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, { o: { nextSibling, parentNode, querySelector, insert, createText } }, hydrateChildren) {
2197	function hydrateAnchor(target2, targetNode) {
2198		let targetAnchor = targetNode;
2199		while (targetAnchor) {
2200			if (targetAnchor && targetAnchor.nodeType === 8) {
2201				if (targetAnchor.data === "teleport start anchor") vnode.targetStart = targetAnchor;
2202				else if (targetAnchor.data === "teleport anchor") {
2203					vnode.targetAnchor = targetAnchor;
2204					target2._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
2205					break;
2206				}
2207			}
2208			targetAnchor = nextSibling(targetAnchor);
2209		}
2210	}
2211	function hydrateDisabledTeleport(node2, vnode2) {
2212		vnode2.anchor = hydrateChildren(nextSibling(node2), vnode2, parentNode(node2), parentComponent, parentSuspense, slotScopeIds, optimized);
2213	}
2214	const target = vnode.target = resolveTarget(vnode.props, querySelector);
2215	const disabled = isTeleportDisabled(vnode.props);
2216	if (target) {
2217		const targetNode = target._lpa || target.firstChild;
2218		if (vnode.shapeFlag & 16) {
2219			if (disabled) {
2220				hydrateDisabledTeleport(node, vnode);
2221				hydrateAnchor(target, targetNode);
2222				if (!vnode.targetAnchor) prepareAnchor(target, vnode, createText, insert, parentNode(node) === target ? node : null);
2223			} else {
2224				vnode.anchor = nextSibling(node);
2225				hydrateAnchor(target, targetNode);
2226				if (!vnode.targetAnchor) prepareAnchor(target, vnode, createText, insert);
2227				hydrateChildren(targetNode && nextSibling(targetNode), vnode, target, parentComponent, parentSuspense, slotScopeIds, optimized);
2228			}
2229		}
2230		updateCssVars(vnode, disabled);
2231	} else if (disabled) {
2232		if (vnode.shapeFlag & 16) {
2233			hydrateDisabledTeleport(node, vnode);
2234			vnode.targetStart = node;
2235			vnode.targetAnchor = nextSibling(node);
2236		}
2237	}
2238	return vnode.anchor && nextSibling(vnode.anchor);
2239}
2240var Teleport = TeleportImpl;
2241function updateCssVars(vnode, isDisabled) {
2242	const ctx = vnode.ctx;
2243	if (ctx && ctx.ut) {
2244		let node, anchor;
2245		if (isDisabled) {
2246			node = vnode.el;
2247			anchor = vnode.anchor;
2248		} else {
2249			node = vnode.targetStart;
2250			anchor = vnode.targetAnchor;
2251		}
2252		while (node && node !== anchor) {
2253			if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid);
2254			node = node.nextSibling;
2255		}
2256		ctx.ut();
2257	}
2258}
2259function prepareAnchor(target, vnode, createText, insert, anchor = null) {
2260	const targetStart = vnode.targetStart = createText("");
2261	const targetAnchor = vnode.targetAnchor = createText("");
2262	targetStart[TeleportEndKey] = targetAnchor;
2263	if (target) {
2264		insert(targetStart, target, anchor);
2265		insert(targetAnchor, target, anchor);
2266	}
2267	return targetAnchor;
2268}
2269var leaveCbKey = /* @__PURE__ */ Symbol("_leaveCb");
2270var enterCbKey = /* @__PURE__ */ Symbol("_enterCb");
2271function useTransitionState() {
2272	const state = {
2273		isMounted: false,
2274		isLeaving: false,
2275		isUnmounting: false,
2276		leavingVNodes: /* @__PURE__ */ new Map()
2277	};
2278	onMounted(() => {
2279		state.isMounted = true;
2280	});
2281	onBeforeUnmount(() => {
2282		state.isUnmounting = true;
2283	});
2284	return state;
2285}
2286var TransitionHookValidator = [Function, Array];
2287var BaseTransitionPropsValidators = {
2288	mode: String,
2289	appear: Boolean,
2290	persisted: Boolean,
2291	onBeforeEnter: TransitionHookValidator,
2292	onEnter: TransitionHookValidator,
2293	onAfterEnter: TransitionHookValidator,
2294	onEnterCancelled: TransitionHookValidator,
2295	onBeforeLeave: TransitionHookValidator,
2296	onLeave: TransitionHookValidator,
2297	onAfterLeave: TransitionHookValidator,
2298	onLeaveCancelled: TransitionHookValidator,
2299	onBeforeAppear: TransitionHookValidator,
2300	onAppear: TransitionHookValidator,
2301	onAfterAppear: TransitionHookValidator,
2302	onAppearCancelled: TransitionHookValidator
2303};
2304var recursiveGetSubtree = (instance) => {
2305	const subTree = instance.subTree;
2306	return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
2307};
2308var BaseTransitionImpl = {
2309	name: `BaseTransition`,
2310	props: BaseTransitionPropsValidators,
2311	setup(props, { slots }) {
2312		const instance = getCurrentInstance();
2313		const state = useTransitionState();
2314		return () => {
2315			const children = slots.default && getTransitionRawChildren(slots.default(), true);
2316			const child = children && children.length ? findNonCommentChild(children) : instance.subTree ? createCommentVNode() : void 0;
2317			if (!child) return;
2318			const rawProps = /* @__PURE__ */ toRaw(props);
2319			const { mode } = rawProps;
2320			if (state.isLeaving) return emptyPlaceholder(child);
2321			const innerChild = getInnerChild$1(child);
2322			if (!innerChild) return emptyPlaceholder(child);
2323			let enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance, (hooks) => enterHooks = hooks);
2324			if (innerChild.type !== Comment) setTransitionHooks(innerChild, enterHooks);
2325			let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree);
2326			if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(oldInnerChild, innerChild) && recursiveGetSubtree(instance).type !== Comment) {

2327				let leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance);
2328				setTransitionHooks(oldInnerChild, leavingHooks);
2329				if (mode === "out-in" && innerChild.type !== Comment) {
2330					state.isLeaving = true;
2331					leavingHooks.afterLeave = () => {
2332						state.isLeaving = false;
2333						if (!(instance.job.flags & 8)) instance.update();
2334						delete leavingHooks.afterLeave;
2335						oldInnerChild = void 0;
2336					};
2337					return emptyPlaceholder(child);
2338				} else if (mode === "in-out" && innerChild.type !== Comment) leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
2339					const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild);
2340					leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
2341					el[leaveCbKey] = () => {
2342						earlyRemove();
2343						el[leaveCbKey] = void 0;
2344						delete enterHooks.delayedLeave;
2345						oldInnerChild = void 0;
2346					};
2347					enterHooks.delayedLeave = () => {
2348						delayedLeave();
2349						delete enterHooks.delayedLeave;
2350						oldInnerChild = void 0;
2351					};
2352				};
2353				else oldInnerChild = void 0;
2354			} else if (oldInnerChild) oldInnerChild = void 0;
2355			return child;
2356		};
2357	}
2358};
2359function findNonCommentChild(children) {
2360	let child = children[0];
2361	if (children.length > 1) {
2362		for (const c of children) if (c.type !== Comment) {
2363			child = c;
2364			break;
2365		}
2366	}
2367	return child;
2368}
2369var BaseTransition = BaseTransitionImpl;
2370function getLeavingNodesForType(state, vnode) {
2371	const { leavingVNodes } = state;
2372	let leavingVNodesCache = leavingVNodes.get(vnode.type);
2373	if (!leavingVNodesCache) {
2374		leavingVNodesCache = /* @__PURE__ */ Object.create(null);
2375		leavingVNodes.set(vnode.type, leavingVNodesCache);
2376	}
2377	return leavingVNodesCache;
2378}
2379function resolveTransitionHooks(vnode, props, state, instance, postClone) {
2380	const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props;
2381	const key = String(vnode.key);
2382	const leavingVNodesCache = getLeavingNodesForType(state, vnode);
2383	const callHook = (hook, args) => {
2384		hook && callWithAsyncErrorHandling(hook, instance, 9, args);
2385	};
2386	const callAsyncHook = (hook, args) => {
2387		const done = args[1];
2388		callHook(hook, args);
2389		if (isArray(hook)) {
2390			if (hook.every((hook2) => hook2.length <= 1)) done();
2391		} else if (hook.length <= 1) done();
2392	};
2393	const hooks = {
2394		mode,
2395		persisted,
2396		beforeEnter(el) {
2397			let hook = onBeforeEnter;
2398			if (!state.isMounted) {
2399				if (appear) hook = onBeforeAppear || onBeforeEnter;
2400				else return;
2401			}
2402			if (el[leaveCbKey]) el[leaveCbKey](true);
2403			const leavingVNode = leavingVNodesCache[key];
2404			if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) leavingVNode.el[leaveCbKey]();
2405			callHook(hook, [el]);
2406		},
2407		enter(el) {
2408			if (leavingVNodesCache[key] === vnode) return;
2409			let hook = onEnter;
2410			let afterHook = onAfterEnter;
2411			let cancelHook = onEnterCancelled;
2412			if (!state.isMounted) {
2413				if (appear) {
2414					hook = onAppear || onEnter;
2415					afterHook = onAfterAppear || onAfterEnter;
2416					cancelHook = onAppearCancelled || onEnterCancelled;
2417				} else return;
2418			}
2419			let called = false;
2420			el[enterCbKey] = (cancelled) => {
2421				if (called) return;
2422				called = true;
2423				if (cancelled) callHook(cancelHook, [el]);
2424				else callHook(afterHook, [el]);
2425				if (hooks.delayedLeave) hooks.delayedLeave();
2426				el[enterCbKey] = void 0;
2427			};
2428			const done = el[enterCbKey].bind(null, false);
2429			if (hook) callAsyncHook(hook, [el, done]);
2430			else done();
2431		},
2432		leave(el, remove) {
2433			const key2 = String(vnode.key);
2434			if (el[enterCbKey]) el[enterCbKey](true);
2435			if (state.isUnmounting) return remove();
2436			callHook(onBeforeLeave, [el]);
2437			let called = false;
2438			el[leaveCbKey] = (cancelled) => {
2439				if (called) return;
2440				called = true;
2441				remove();
2442				if (cancelled) callHook(onLeaveCancelled, [el]);
2443				else callHook(onAfterLeave, [el]);
2444				el[leaveCbKey] = void 0;
2445				if (leavingVNodesCache[key2] === vnode) delete leavingVNodesCache[key2];
2446			};
2447			const done = el[leaveCbKey].bind(null, false);
2448			leavingVNodesCache[key2] = vnode;
2449			if (onLeave) callAsyncHook(onLeave, [el, done]);
2450			else done();
2451		},
2452		clone(vnode2) {
2453			const hooks2 = resolveTransitionHooks(vnode2, props, state, instance, postClone);
2454			if (postClone) postClone(hooks2);
2455			return hooks2;
2456		}
2457	};
2458	return hooks;
2459}
2460function emptyPlaceholder(vnode) {
2461	if (isKeepAlive(vnode)) {
2462		vnode = cloneVNode(vnode);
2463		vnode.children = null;
2464		return vnode;
2465	}
2466}
2467function getInnerChild$1(vnode) {
2468	if (!isKeepAlive(vnode)) {
2469		if (isTeleport(vnode.type) && vnode.children) return findNonCommentChild(vnode.children);
2470		return vnode;
2471	}

2472	if (vnode.component) return vnode.component.subTree;
2473	const { shapeFlag, children } = vnode;
2474	if (children) {
2475		if (shapeFlag & 16) return children[0];
2476		if (shapeFlag & 32 && isFunction(children.default)) return children.default();
2477	}
2478}
2479function setTransitionHooks(vnode, hooks) {
2480	if (vnode.shapeFlag & 6 && vnode.component) {
2481		vnode.transition = hooks;
2482		const subTree = vnode.component.subTree;
2483		setTransitionHooks(isTeleport(subTree.type) ? getInnerChild$1(subTree) || subTree : subTree, hooks);
2484	} else if (vnode.shapeFlag & 128) {
2485		vnode.ssContent.transition = hooks.clone(vnode.ssContent);
2486		vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
2487	} else vnode.transition = hooks;
2488}
2489function getTransitionRawChildren(children, keepComment = false, parentKey) {
2490	let ret = [];
2491	let keyedFragmentCount = 0;
2492	for (let i = 0; i < children.length; i++) {
2493		let child = children[i];
2494		const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
2495		if (child.type === Fragment) {
2496			if (child.patchFlag & 128) keyedFragmentCount++;
2497			ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key));
2498		} else if (keepComment || child.type !== Comment) ret.push(key != null ? cloneVNode(child, { key }) : child);
2499	}
2500	if (keyedFragmentCount > 1) for (let i = 0; i < ret.length; i++) ret[i].patchFlag = -2;
2501	return ret;
2502}
2503// @__NO_SIDE_EFFECTS__
2504function defineComponent(options, extraOptions) {
2505	return isFunction(options) ? /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))() : options;
2506}
2507function useId() {
2508	const i = getCurrentInstance();
2509	if (i) return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++;
2510	return "";
2511}
2512function markAsyncBoundary(instance) {
2513	instance.ids = [
2514		instance.ids[0] + instance.ids[2]++ + "-",
2515		0,
2516		0
2517	];
2518}
2519function useTemplateRef(key) {
2520	const i = getCurrentInstance();
2521	const r = /* @__PURE__ */ shallowRef(null);
2522	if (i) {
2523		const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs;
2524		Object.defineProperty(refs, key, {
2525			enumerable: true,
2526			get: () => r.value,
2527			set: (val) => r.value = val
2528		});
2529	}
2530	return r;
2531}
2532function isTemplateRefKey(refs, key) {
2533	let desc;
2534	return !!((desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable);
2535}
2536var pendingSetRefMap = /* @__PURE__ */ new WeakMap();
2537function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
2538	if (isArray(rawRef)) {
2539		rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount));
2540		return;
2541	}
2542	if (isAsyncWrapper(vnode) && !isUnmount) {
2543		if (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) setRef(rawRef, oldRawRef, parentSuspense, vnode.component.subTree);
2544		return;
2545	}
2546	const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
2547	const value = isUnmount ? null : refValue;
2548	const { i: owner, r: ref } = rawRef;
2549	const oldRef = oldRawRef && oldRawRef.r;
2550	const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
2551	const setupState = owner.setupState;
2552	const rawSetupState = /* @__PURE__ */ toRaw(setupState);
2553	const canSetSetupRef = setupState === EMPTY_OBJ ? NO : (key) => {
2554		if (isTemplateRefKey(refs, key)) return false;
2555		return hasOwn(rawSetupState, key);
2556	};
2557	const canSetRef = (ref2, key) => {
2558		if (key && isTemplateRefKey(refs, key)) return false;
2559		return true;
2560	};
2561	if (oldRef != null && oldRef !== ref) {
2562		invalidatePendingSetRef(oldRawRef);
2563		if (isString(oldRef)) {
2564			refs[oldRef] = null;
2565			if (canSetSetupRef(oldRef)) setupState[oldRef] = null;
2566		} else if (/* @__PURE__ */ isRef(oldRef)) {
2567			const oldRawRefAtom = oldRawRef;
2568			if (canSetRef(oldRef, oldRawRefAtom.k)) oldRef.value = null;
2569			if (oldRawRefAtom.k) refs[oldRawRefAtom.k] = null;
2570		}
2571	}
2572	if (isFunction(ref)) callWithErrorHandling(ref, owner, 12, [value, refs]);
2573	else {
2574		const _isString = isString(ref);
2575		const _isRef = /* @__PURE__ */ isRef(ref);
2576		if (_isString || _isRef) {
2577			const doSet = () => {
2578				if (rawRef.f) {
2579					const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : canSetRef(ref) || !rawRef.k ? ref.value : refs[rawRef.k];
2580					if (isUnmount) isArray(existing) && remove(existing, refValue);
2581					else if (!isArray(existing)) {
2582						if (_isString) {
2583							refs[ref] = [refValue];
2584							if (canSetSetupRef(ref)) setupState[ref] = refs[ref];
2585						} else {
2586							const newVal = [refValue];
2587							if (canSetRef(ref, rawRef.k)) ref.value = newVal;
2588							if (rawRef.k) refs[rawRef.k] = newVal;
2589						}
2590					} else if (!existing.includes(refValue)) existing.push(refValue);
2591				} else if (_isString) {
2592					refs[ref] = value;
2593					if (canSetSetupRef(ref)) setupState[ref] = value;
2594				} else if (_isRef) {
2595					if (canSetRef(ref, rawRef.k)) ref.value = value;
2596					if (rawRef.k) refs[rawRef.k] = value;
2597				}
2598			};
2599			if (value) {
2600				const job = () => {
2601					doSet();
2602					pendingSetRefMap.delete(rawRef);
2603				};
2604				job.id = -1;
2605				pendingSetRefMap.set(rawRef, job);
2606				queuePostRenderEffect(job, parentSuspense);
2607			} else {
2608				invalidatePendingSetRef(rawRef);
2609				doSet();
2610			}
2611		}
2612	}
2613}

2614function invalidatePendingSetRef(rawRef) {
2615	const pendingSetRef = pendingSetRefMap.get(rawRef);
2616	if (pendingSetRef) {
2617		pendingSetRef.flags |= 8;
2618		pendingSetRefMap.delete(rawRef);
2619	}
2620}
2621var hasLoggedMismatchError = false;
2622var logMismatchError = () => {
2623	if (hasLoggedMismatchError) return;
2624	console.error("Hydration completed but contains mismatches.");
2625	hasLoggedMismatchError = true;
2626};
2627var isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
2628var isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
2629var getContainerType = (container) => {
2630	if (container.nodeType !== 1) return void 0;
2631	if (isSVGContainer(container)) return "svg";
2632	if (isMathMLContainer(container)) return "mathml";
2633};
2634var isComment = (node) => node.nodeType === 8;
2635function createHydrationFunctions(rendererInternals) {
2636	const { mt: mountComponent, p: patch, o: { patchProp, createText, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals;
2637	const hydrate = (vnode, container) => {
2638		if (!container.hasChildNodes()) {
2639			warn$1(`Attempting to hydrate existing markup but container is empty. Performing full mount instead.`);
2640			patch(null, vnode, container);
2641			flushPostFlushCbs();
2642			container._vnode = vnode;
2643			return;
2644		}
2645		hydrateNode(container.firstChild, vnode, null, null, null);
2646		flushPostFlushCbs();
2647		container._vnode = vnode;
2648	};
2649	const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
2650		optimized = optimized || !!vnode.dynamicChildren;
2651		const isFragmentStart = isComment(node) && node.data === "[";
2652		const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart);
2653		const { type, ref, shapeFlag, patchFlag } = vnode;
2654		let domType = node.nodeType;
2655		vnode.el = node;
2656		if (patchFlag === -2) {
2657			optimized = false;
2658			vnode.dynamicChildren = null;
2659		}
2660		let nextNode = null;
2661		switch (type) {
2662			case Text:
2663				if (domType !== 3) {
2664					if (vnode.children === "") {
2665						insert(vnode.el = createText(""), parentNode(node), node);
2666						nextNode = node;
2667					} else nextNode = onMismatch();
2668				} else {
2669					if (node.data !== vnode.children) {
2670						warn$1(`Hydration text mismatch in`, node.parentNode, `
2671  - rendered on server: ${JSON.stringify(node.data)}
2672  - expected on client: ${JSON.stringify(vnode.children)}`);
2673						logMismatchError();
2674						node.data = vnode.children;
2675					}
2676					nextNode = nextSibling(node);
2677				}
2678				break;
2679			case Comment:
2680				if (isTemplateNode(node)) {
2681					nextNode = nextSibling(node);
2682					replaceNode(vnode.el = node.content.firstChild, node, parentComponent);
2683				} else if (domType !== 8 || isFragmentStart) nextNode = onMismatch();
2684				else nextNode = nextSibling(node);
2685				break;
2686			case Static:
2687				if (isFragmentStart) {
2688					node = nextSibling(node);
2689					domType = node.nodeType;
2690				}
2691				if (domType === 1 || domType === 3) {
2692					nextNode = node;
2693					const needToAdoptContent = !vnode.children.length;
2694					for (let i = 0; i < vnode.staticCount; i++) {
2695						if (needToAdoptContent) vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data;
2696						if (i === vnode.staticCount - 1) vnode.anchor = nextNode;
2697						nextNode = nextSibling(nextNode);
2698					}
2699					return isFragmentStart ? nextSibling(nextNode) : nextNode;
2700				} else onMismatch();
2701				break;
2702			case Fragment:
2703				if (!isFragmentStart) nextNode = onMismatch();
2704				else nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
2705				break;
2706			default: if (shapeFlag & 1) {
2707				if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) nextNode = onMismatch();
2708				else nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
2709			} else if (shapeFlag & 6) {
2710				vnode.slotScopeIds = slotScopeIds;
2711				const container = parentNode(node);
2712				if (isFragmentStart) nextNode = locateClosingAnchor(node);
2713				else if (isComment(node) && node.data === "teleport start") 

2713nextNode = locateClosingAnchor(node, node.data, "teleport end");
2714				else nextNode = nextSibling(node);
2715				mountComponent(vnode, container, null, parentComponent, parentSuspense, getContainerType(container), optimized);
2716				if ((isAsyncWrapper(vnode) || vnode.component.asyncDep) && !vnode.component.subTree) {
2717					let subTree;
2718					if (isFragmentStart) {
2719						subTree = createVNode(Static);
2720						subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
2721					} else subTree = node.nodeType === 3 ? createTextVNode("") : createVNode(node.nodeType === 8 ? Comment : "div");
2722					subTree.el = node;
2723					vnode.component.subTree = subTree;
2724				}
2725			} else if (shapeFlag & 64) {
2726				if (domType !== 8) nextNode = onMismatch();
2727				else nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren);
2728			} else if (shapeFlag & 128) nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, getContainerType(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode);
2729			else warn$1("Invalid HostVNode type:", type, `(${typeof type})`);
2730		}
2731		if (ref != null) setRef(ref, null, parentSuspense, vnode);
2732		return nextNode;
2733	};
2734	const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
2735		optimized = optimized || !!vnode.dynamicChildren;
2736		const { type, dynamicProps, props, patchFlag, shapeFlag, dirs, transition } = vnode;
2737		const forcePatch = type === "input" || type === "option";
2738		if (forcePatch || !!dynamicProps || patchFlag !== -1) {
2739			if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "created");
2740			let needCallTransitionHooks = false;
2741			if (isTemplateNode(el)) {
2742				needCallTransitionHooks = needTransition(null, transition) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
2743				const content = el.content.firstChild;
2744				if (needCallTransitionHooks) {
2745					const cls = content.getAttribute("class");
2746					if (cls) content.$cls = cls;
2747					transition.beforeEnter(content);
2748				}
2749				replaceNode(content, el, parentComponent);
2750				vnode.el = el = content;
2751			}
2752			if (shapeFlag & 16 && !(props && (props.innerHTML || props.textContent))) {
2753				let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized);
2754				if (next && !isMismatchAllowed(el, 1)) {
2755					warn$1(`Hydration children mismatch on`, el, `
2756Server rendered element contains more child nodes than client vdom.`);
2757					logMismatchError();
2758				}
2759				while (next) {
2760					const cur = next;
2761					next = next.nextSibling;
2762					remove(cur);
2763				}
2764			} else if (shapeFlag & 8) {
2765				let clientText = vnode.children;
2766				if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) clientText = clientText.slice(1);
2767				const { textContent } = el;
2768				if (textContent !== clientText && textContent !== clientText.replace(/\r\n|\r/g, "\n")) {
2769					if (!isMismatchAllowed(el, 0)) {
2770						warn$1(`Hydration text content mismatch on`, el, `
2771  - rendered on server: ${textContent}
2772  - expected on client: ${clientText}`);
2773						logMismatchError();
2774					}
2775					el.textContent = vnode.children;
2776				}
2777			}
2778			if (props) {
2779				const isCustomElement = el.tagName.includes("-");
2780				const namespace = el.namespaceURI.includes("svg") ? "svg" : el.namespaceURI.includes("MathML") ? "mathml" : void 0;
2781				for (const key in props) {
2782					if (!(dirs && dirs.some((d) => d.dir.created)) && propHasMismatch(el, key, props[key], vnode, parentComponent)) logMismatchError();
2783					if (forcePatch && (key.endsWith("value") || key === "indeterminate") || isOn(key) && !isReservedProp(key) || key[0] === "." || isCustomElement && !isReservedProp(key) || dynamicProps && dynamicProps.includes(key)) {
2784						if (isUnchangedResourceProp(el, key, props[key])) continue;
2785						patchProp(el, key, null, props[key], namespace, parentComponent);
2786					}
2787				}
2788			}
2789			let vnodeHooks;
2790			if (vnodeHooks = props && props.onVnodeBeforeMount) invokeVNodeHook(vnodeHooks, parentComponent, vnode);
2791			if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");

2792			if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) queueEffectWithSuspense(() => {
2793				vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
2794				needCallTransitionHooks && transition.enter(el);
2795				dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
2796			}, parentSuspense);
2797		}
2798		return el.nextSibling;
2799	};
2800	const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
2801		optimized = optimized || !!parentVNode.dynamicChildren;
2802		const children = parentVNode.children;
2803		const l = children.length;
2804		let hasCheckedMismatch = false;
2805		for (let i = 0; i < l; i++) {
2806			const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
2807			const isText = vnode.type === Text;
2808			if (node) {
2809				if (isText && !optimized) {
2810					if (i + 1 < l && normalizeVNode(children[i + 1]).type === Text) {
2811						insert(createText(node.data.slice(vnode.children.length)), container, nextSibling(node));
2812						node.data = vnode.children;
2813					}
2814				}
2815				node = hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
2816			} else if (isText && !vnode.children) insert(vnode.el = createText(""), container);
2817			else {
2818				if (!hasCheckedMismatch) {
2819					hasCheckedMismatch = true;
2820					if (!isMismatchAllowed(container, 1)) {
2821						warn$1(`Hydration children mismatch on`, container, `
2822Server rendered element contains fewer child nodes than client vdom.`);
2823						logMismatchError();
2824					}
2825				}
2826				patch(null, vnode, container, null, parentComponent, parentSuspense, getContainerType(container), slotScopeIds);
2827			}
2828		}
2829		return node;
2830	};
2831	const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
2832		const { slotScopeIds: fragmentSlotScopeIds } = vnode;
2833		if (fragmentSlotScopeIds) slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
2834		const container = parentNode(node);
2835		const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized);
2836		if (next && isComment(next) && next.data === "]") return nextSibling(vnode.anchor = next);
2837		else {
2838			logMismatchError();
2839			insert(vnode.anchor = createComment(`]`), container, next);
2840			return next;
2841		}
2842	};
2843	const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
2844		if (!isNodeMismatchAllowed(node, vnode)) {
2845			warn$1(`Hydration node mismatch:
2846- rendered on server:`, node, node.nodeType === 3 ? `(text)` : isComment(node) && node.data === "[" ? `(start of fragment)` : ``, `
2847- expected on client:`, vnode.type);
2848			logMismatchError();
2849		}
2850		vnode.el = null;
2851		if (isFragment) {
2852			const end = locateClosingAnchor(node);
2853			while (true) {
2854				const next2 = nextSibling(node);
2855				if (next2 && next2 !== end) remove(next2);
2856				else break;
2857			}
2858		}
2859		const next = nextSibling(node);
2860		const container = parentNode(node);
2861		remove(node);
2862		patch(null, vnode, container, next, parentComponent, parentSuspense, getContainerType(container), slotScopeIds);
2863		if (parentComponent) {
2864			parentComponent.vnode.el = vnode.el;
2865			updateHOCHostEl(parentComponent, vnode.el);
2866		}
2867		return next;
2868	};
2869	const locateClosingAnchor = (node, open = "[", close = "]") => {
2870		let match = 0;
2871		while (node) {
2872			node = nextSibling(node);
2873			if (node && isComment(node)) {
2874				if (node.data === open) match++;
2875				if (node.data === close) {
2876					if (match === 0) return nextSibling(node);
2877					else match--;
2878				}
2879			}
2880		}
2881		return node;
2882	};
2883	const replaceNode = (newNode, oldNode, parentComponent) => {
2884		const parentNode2 = oldNode.parentNode;
2885		if (parentNode2) parentNode2.replaceChild(newNode, oldNode);
2886		let parent = parentComponent;
2887		while (parent) {
2888			if (parent.vnode.el === oldNode) parent.vnode.el = parent.subTree.el = newNode;
2889			parent = parent.parent;
2890		}
2891	};
2892	const isTemplateNode = (node) => {
2893		return node.nodeType === 1 && node.tagName === "TEMPLATE";
2894	};
2895	return [hydrate, hydrateNode];
2896}
2897var resourceProps = /* @__PURE__ */ new Set([
2898	"src",
2899	"srcset",
2900	"href",
2901	"poster"
2902]);
2903function isUnchangedResourceProp(el, key, clientValue) {
2904	if (!resourceProps.has(key)) return false;

2905	return el.getAttribute(key) === (clientValue == null ? null : `${clientValue}`);
2906}
2907function propHasMismatch(el, key, clientValue, vnode, instance) {
2908	let mismatchType;
2909	let mismatchKey;
2910	let actual;
2911	let expected;
2912	if (key === "class") {
2913		if (el.$cls) {
2914			actual = el.$cls;
2915			delete el.$cls;
2916		} else actual = el.getAttribute("class");
2917		expected = normalizeClass(clientValue);
2918		if (!isSetEqual(toClassSet(actual || ""), toClassSet(expected))) {
2919			mismatchType = 2;
2920			mismatchKey = `class`;
2921		}
2922	} else if (key === "style") {
2923		actual = el.getAttribute("style") || "";
2924		expected = isString(clientValue) ? clientValue : stringifyStyle(normalizeStyle(clientValue));
2925		const actualMap = toStyleMap(actual);
2926		const expectedMap = toStyleMap(expected);
2927		if (vnode.dirs) {
2928			for (const { dir, value } of vnode.dirs) if (dir.name === "show" && !value) expectedMap.set("display", "none");
2929		}
2930		if (instance) resolveCssVars(instance, vnode, expectedMap);
2931		if (!isMapEqual(actualMap, expectedMap)) {
2932			mismatchType = 3;
2933			mismatchKey = "style";
2934		}
2935	} else if (el instanceof SVGElement && isKnownSvgAttr(key) || el instanceof HTMLElement && (isBooleanAttr(key) || isKnownHtmlAttr(key))) {
2936		if (key === "hidden") {
2937			actual = normalizeHiddenValue(el.getAttribute(key));
2938			expected = normalizeHiddenValue(clientValue);
2939		} else if (isBooleanAttr(key)) {
2940			actual = el.hasAttribute(key);
2941			expected = includeBooleanAttr(clientValue);
2942		} else if (clientValue == null) {
2943			actual = el.hasAttribute(key);
2944			expected = false;
2945		} else {
2946			if (el.hasAttribute(key)) actual = el.getAttribute(key);
2947			else if (key === "value" && el.tagName === "TEXTAREA") actual = el.value;
2948			else actual = false;
2949			expected = isRenderableAttrValue(clientValue) ? String(clientValue) : false;
2950		}
2951		if (actual !== expected) {
2952			mismatchType = 4;
2953			mismatchKey = key;
2954		}
2955	}
2956	if (mismatchType != null && !isMismatchAllowed(el, mismatchType)) {
2957		const format = (v) => v === false ? `(not rendered)` : `${mismatchKey}="${v}"`;
2958		warn$1(`Hydration ${MismatchTypeString[mismatchType]} mismatch on`, el, `
2959  - rendered on server: ${format(actual)}
2960  - expected on client: ${format(expected)}
2961  Note: this mismatch is check-only. The DOM will not be rectified in production due to performance overhead.
2962  You should fix the source of the mismatch.`);
2963		return true;
2964	}
2965	return false;
2966}
2967function normalizeHiddenValue(value) {
2968	if (!isRenderableAttrValue(value)) return false;
2969	if (isString(value)) return value.toLowerCase() === "until-found" ? "until-found" : "";
2970	return includeBooleanAttr(value) ? "" : false;
2971}
2972function toClassSet(str) {
2973	return new Set(str.trim().split(/\s+/));
2974}
2975function isSetEqual(a, b) {
2976	if (a.size !== b.size) return false;
2977	for (const s of a) if (!b.has(s)) return false;
2978	return true;
2979}
2980function toStyleMap(str) {
2981	const styleMap = /* @__PURE__ */ new Map();
2982	for (const item of str.split(";")) {
2983		let [key, value] = item.split(":");
2984		key = key.trim();
2985		value = value && value.trim();
2986		if (key && value) styleMap.set(key, value);
2987	}
2988	return styleMap;
2989}
2990function isMapEqual(a, b) {
2991	if (a.size !== b.size) return false;
2992	for (const [key, value] of a) if (value !== b.get(key)) return false;
2993	return true;
2994}
2995function resolveCssVars(instance, vnode, expectedMap) {
2996	const root = instance.subTree;
2997	if (instance.getCssVars && (vnode === root || root && root.type === Fragment && root.children.includes(vnode))) {
2998		const cssVars = instance.getCssVars();
2999		for (const key in cssVars) {
3000			const value = normalizeCssVarValue(cssVars[key]);
3001			expectedMap.set(`--${getEscapedCssVarName(key, false)}`, value);
3002		}
3003	}
3004	if (vnode === root && instance.parent) resolveCssVars(instance.parent, instance.vnode, expectedMap);
3005}
3006var allowMismatchAttr = "data-allow-mismatch";
3007var MismatchTypeString = {
3008	[0]: "text",
3009	[1]: "children",
3010	[2]: "class",
3011	[3]: "style",
3012	[4]: "attribute"
3013};
3014function isMismatchAllowed(el, allowedType) {
3015	if (allowedType === 0 || allowedType === 1) while (el && !el.hasAttribute(allowMismatchAttr)) el = el.parentElement;
3016	return isMismatchAllowedByAttr(el && el.getAttribute(allowMismatchAttr), allowedType);
3017}
3018function isMismatchAllowedByAttr(allowedAttr, allowedType) {
3019	if (allowedAttr == null) return false;

3020	else if (allowedAttr === "") return true;
3021	else {
3022		const list = allowedAttr.split(",");
3023		if (allowedType === 0 && list.includes("children")) return true;
3024		return list.includes(MismatchTypeString[allowedType]);
3025	}
3026}
3027function isNodeMismatchAllowed(node, vnode) {
3028	return isMismatchAllowed(node.parentElement, 1) || isMismatchAllowedByNode(node) || isMismatchAllowedByVNode(vnode);
3029}
3030function isMismatchAllowedByNode(node) {
3031	return node.nodeType === 1 && isMismatchAllowedByAttr(node.getAttribute(allowMismatchAttr), 1);
3032}
3033function isMismatchAllowedByVNode({ props }) {
3034	const allowedAttr = props && props[allowMismatchAttr];
3035	return typeof allowedAttr === "string" && isMismatchAllowedByAttr(allowedAttr, 1);
3036}
3037getGlobalThis().requestIdleCallback;
3038getGlobalThis().cancelIdleCallback;
3039function forEachElement(node, cb) {
3040	if (isComment(node) && node.data === "[") {
3041		let depth = 1;
3042		let next = node.nextSibling;
3043		while (next) {
3044			if (next.nodeType === 1) {
3045				if (cb(next) === false) break;
3046			} else if (isComment(next)) {
3047				if (next.data === "]") {
3048					if (--depth === 0) break;
3049				} else if (next.data === "[") depth++;
3050			}
3051			next = next.nextSibling;
3052		}
3053	} else cb(node);
3054}
3055var isAsyncWrapper = (i) => !!i.type.__asyncLoader;
3056// @__NO_SIDE_EFFECTS__
3057function defineAsyncComponent(source) {
3058	if (isFunction(source)) source = { loader: source };
3059	const { loader, loadingComponent, errorComponent, delay = 200, hydrate: hydrateStrategy, timeout, suspensible = true, onError: userOnError } = source;
3060	let pendingRequest = null;
3061	let resolvedComp;
3062	let retries = 0;
3063	const retry = () => {
3064		retries++;
3065		pendingRequest = null;
3066		return load();
3067	};
3068	const load = () => {
3069		let thisRequest;
3070		return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
3071			err = err instanceof Error ? err : new Error(String(err));
3072			if (userOnError) return new Promise((resolve, reject) => {
3073				const userRetry = () => resolve(retry());
3074				const userFail = () => reject(err);
3075				userOnError(err, userRetry, userFail, retries + 1);
3076			});
3077			else throw err;
3078		}).then((comp) => {
3079			if (thisRequest !== pendingRequest && pendingRequest) return pendingRequest;
3080			if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) comp = comp.default;
3081			resolvedComp = comp;
3082			return comp;
3083		}));
3084	};
3085	return /* @__PURE__ */ defineComponent({
3086		name: "AsyncComponentWrapper",
3087		__asyncLoader: load,
3088		__asyncHydrate(el, instance, hydrate) {
3089			const wasConnected = el.isConnected;
3090			let patched = false;
3091			(instance.bu || (instance.bu = [])).push(() => patched = true);
3092			const performHydrate = () => {
3093				if (patched) return;
3094				if (!el.parentNode || wasConnected && !el.isConnected) return;
3095				hydrate();
3096			};
3097			const doHydrate = hydrateStrategy ? () => {
3098				const teardown = hydrateStrategy(performHydrate, (cb) => forEachElement(el, cb));
3099				if (teardown) (instance.bum || (instance.bum = [])).push(teardown);
3100			} : performHydrate;
3101			if (resolvedComp) doHydrate();
3102			else load().then(() => !instance.isUnmounted && doHydrate());
3103		},
3104		get __asyncResolved() {
3105			return resolvedComp;
3106		},
3107		setup() {
3108			const instance = currentInstance;
3109			markAsyncBoundary(instance);
3110			if (resolvedComp) return () => createInnerComp(resolvedComp, instance);
3111			const onError = (err) => {
3112				pendingRequest = null;
3113				handleError(err, instance, 13, !errorComponent);
3114			};
3115			if (suspensible && instance.suspense || isInSSRComponentSetup) return load().then((comp) => {
3116				return () => createInnerComp(comp, instance);
3117			}).catch((err) => {
3118				onError(err);
3119				return () => errorComponent ? createVNode(errorComponent, { error: err }) : null;
3120			});
3121			const loaded = /* @__PURE__ */ ref(false);
3122			const error = /* @__PURE__ */ ref();
3123			const delayed = /* @__PURE__ */ ref(!!delay);
3124			let timeoutTimer;
3125			let delayTimer;
3126			onUnmounted(() => {
3127				if (timeoutTimer != null) clearTimeout(timeoutTimer);
3128				if (delayTimer != null) clearTimeout(delayTimer);
3129			});
3130			if (delay) delayTimer = setTimeout(() => {
3131				if (instance.isUnmounted) return;
3132				delayed.value = false;

3133			}, delay);
3134			if (timeout != null) timeoutTimer = setTimeout(() => {
3135				if (instance.isUnmounted) return;
3136				if (!loaded.value && !error.value) {
3137					const err = /* @__PURE__ */ new Error(`Async component timed out after ${timeout}ms.`);
3138					onError(err);
3139					error.value = err;
3140				}
3141			}, timeout);
3142			load().then(() => {
3143				if (instance.isUnmounted) return;
3144				loaded.value = true;
3145				if (instance.parent && isKeepAlive(instance.parent.vnode)) instance.parent.update();
3146			}).catch((err) => {
3147				if (instance.isUnmounted) {
3148					pendingRequest = null;
3149					return;
3150				}
3151				onError(err);
3152				error.value = err;
3153			});
3154			return () => {
3155				if (loaded.value && resolvedComp) return createInnerComp(resolvedComp, instance);
3156				else if (error.value && errorComponent) return createVNode(errorComponent, { error: error.value });
3157				else if (loadingComponent && !delayed.value) return createInnerComp(loadingComponent, instance);
3158			};
3159		}
3160	});
3161}
3162function createInnerComp(comp, parent) {
3163	const { ref: ref2, props, children, ce } = parent.vnode;
3164	const vnode = createVNode(comp, props, children);
3165	vnode.ref = ref2;
3166	vnode.ce = ce;
3167	delete parent.vnode.ce;
3168	return vnode;
3169}
3170var isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
3171function onActivated(hook, target) {
3172	registerKeepAliveHook(hook, "a", target);
3173}
3174function onDeactivated(hook, target) {
3175	registerKeepAliveHook(hook, "da", target);
3176}
3177function registerKeepAliveHook(hook, type, target = currentInstance) {
3178	const wrappedHook = hook.__wdc || (hook.__wdc = () => {
3179		let current = target;
3180		while (current) {
3181			if (current.isDeactivated) return;
3182			current = current.parent;
3183		}
3184		return hook();
3185	});
3186	injectHook(type, wrappedHook, target);
3187	if (target) {
3188		let current = target.parent;
3189		while (current && current.parent) {
3190			if (isKeepAlive(current.parent.vnode)) injectToKeepAliveRoot(wrappedHook, type, target, current);
3191			current = current.parent;
3192		}
3193	}
3194}
3195function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
3196	const injected = injectHook(type, hook, keepAliveRoot, true);
3197	onUnmounted(() => {
3198		remove(keepAliveRoot[type], injected);
3199	}, target);
3200}
3201function injectHook(type, hook, target = currentInstance, prepend = false) {
3202	if (target) {
3203		const hooks = target[type] || (target[type] = []);
3204		const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
3205			pauseTracking();
3206			const reset = setCurrentInstance(target);
3207			const res = callWithAsyncErrorHandling(hook, target, type, args);
3208			reset();
3209			resetTracking();
3210			return res;
3211		});
3212		if (prepend) hooks.unshift(wrappedHook);
3213		else hooks.push(wrappedHook);
3214		return wrappedHook;
3215	}
3216}
3217var createHook = (lifecycle) => (hook, target = currentInstance) => {
3218	if (!isInSSRComponentSetup || lifecycle === "sp") injectHook(lifecycle, (...args) => hook(...args), target);
3219};
3220var onBeforeMount = createHook("bm");
3221var onMounted = createHook("m");
3222var onBeforeUpdate = createHook("bu");
3223var onUpdated = createHook("u");
3224var onBeforeUnmount = createHook("bum");
3225var onUnmounted = createHook("um");
3226var onServerPrefetch = createHook("sp");
3227var onRenderTriggered = createHook("rtg");
3228var onRenderTracked = createHook("rtc");
3229function onErrorCaptured(hook, target = currentInstance) {
3230	injectHook("ec", hook, target);
3231}
3232var COMPONENTS = "components";
3233function resolveComponent(name, maybeSelfReference) {
3234	return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
3235}
3236var NULL_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol.for("v-ndc");
3237function resolveDynamicComponent(component) {
3238	if (isString(component)) return resolveAsset(COMPONENTS, component, false) || component;
3239	else return component || NULL_DYNAMIC_COMPONENT;
3240}
3241function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
3242	const instance = currentRenderingInstance || currentInstance;
3243	if (instance) {
3244		const Component = instance.type;
3245		if (type === COMPONENTS) {
3246			const selfName = getComponentName(Component, false);
3247			if (selfName && (selfName === name || selfName === camelize$1(name) || selfName === capitalize(camelize$1(name)))) return Component;
3248		}
3249		const res = resolve(instance[type] || Component[type], name) || resolve(instance.appContext[type], name);
3250		if (!res && maybeSelfReference) return Component;
3251		return res;
3252	}
3253}
3254function resolve(registry, name) {
3255	return registry && (registry[name] || registry[camelize$1(name)] || registry[capitalize(camelize$1(name))]);
3256}
3257function renderList(source, renderItem, cache, index) {
3258	let ret;

3259	const cached = cache && cache[index];
3260	const sourceIsArray = isArray(source);
3261	if (sourceIsArray || isString(source)) {
3262		const sourceIsReactiveArray = sourceIsArray && /* @__PURE__ */ isReactive(source);
3263		let needsWrap = false;
3264		let isReadonlySource = false;
3265		if (sourceIsReactiveArray) {
3266			needsWrap = !/* @__PURE__ */ isShallow(source);
3267			isReadonlySource = /* @__PURE__ */ isReadonly(source);
3268			source = shallowReadArray(source);
3269		}
3270		ret = new Array(source.length);
3271		for (let i = 0, l = source.length; i < l; i++) ret[i] = renderItem(needsWrap ? isReadonlySource ? toReadonly(toReactive(source[i])) : toReactive(source[i]) : source[i], i, void 0, cached && cached[i]);
3272	} else if (typeof source === "number") {
3273		ret = new Array(source);
3274		for (let i = 0; i < source; i++) ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
3275	} else if (isObject$2(source)) {
3276		if (source[Symbol.iterator]) ret = Array.from(source, (item, i) => renderItem(item, i, void 0, cached && cached[i]));
3277		else {
3278			const keys = Object.keys(source);
3279			ret = new Array(keys.length);
3280			for (let i = 0, l = keys.length; i < l; i++) {
3281				const key = keys[i];
3282				ret[i] = renderItem(source[key], key, i, cached && cached[i]);
3283			}
3284		}
3285	} else ret = [];
3286	if (cache) cache[index] = ret;
3287	return ret;
3288}

3289function renderSlot(slots, name, props, fallback, noSlotted, branchKey) {
3290	if (props == null) props = {};
3291	if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
3292		const slotProps = branchKey != null && props.key == null ? extend({}, props, { key: branchKey }) : props;
3293		const hasProps = Object.keys(slotProps).length > 0;
3294		if (name !== "default") slotProps.name = name;
3295		return openBlock(), createBlock(Fragment, null, [createVNode("slot", slotProps, fallback && fallback())], hasProps ? -2 : 64);
3296	}
3297	let slot = slots[name];
3298	if (slot && slot._c) slot._d = false;
3299	const prevStackSize = blockStack.length;
3300	openBlock();
3301	let rendered;
3302	try {
3303		const validSlotContent = slot && ensureValidVNode(slot(props));
3304		const slotKey = props.key || branchKey || validSlotContent && validSlotContent.key;
3305		rendered = createBlock(Fragment, { key: (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) + (!validSlotContent && fallback ? "_fb" : "") }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 ? 64 : -2);
3306	} catch (err) {
3307		for (let i = blockStack.length; i > prevStackSize; i--) closeBlock();
3308		throw err;
3309	} finally {
3310		if (slot && slot._c) slot._d = true;
3311	}
3312	if (!noSlotted && rendered.scopeId) rendered.slotScopeIds = [rendered.scopeId + "-s"];
3313	return rendered;
3314}
3315function ensureValidVNode(vnodes) {
3316	return vnodes.some((child) => {
3317		if (!isVNode(child)) return true;
3318		if (child.type === Comment) return false;
3319		if (child.type === Fragment && !ensureValidVNode(child.children)) return false;
3320		return true;
3321	}) ? vnodes : null;
3322}
3323var getPublicInstance = (i) => {
3324	if (!i) return null;
3325	if (isStatefulComponent(i)) return getComponentPublicInstance(i);
3326	return getPublicInstance(i.parent);
3327};
3328var publicPropertiesMap = /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
3329	$: (i) => i,
3330	$el: (i) => i.vnode.el,
3331	$data: (i) => i.data,
3332	$props: (i) => i.props,
3333	$attrs: (i) => i.attrs,
3334	$slots: (i) => i.slots,
3335	$refs: (i) => i.refs,
3336	$parent: (i) => getPublicInstance(i.parent),
3337	$root: (i) => getPublicInstance(i.root),
3338	$host: (i) => i.ce,
3339	$emit: (i) => i.emit,
3340	$options: (i) => resolveMergedOptions(i),
3341	$forceUpdate: (i) => i.f || (i.f = () => {
3342		queueJob(i.update);
3343	}),
3344	$nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
3345	$watch: (i) => instanceWatch.bind(i)
3346});
3347var hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
3348var PublicInstanceProxyHandlers = {
3349	get({ _: instance }, key) {
3350		if (key === "__v_skip") return true;
3351		const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
3352		if (key[0] !== "$") {
3353			const n = accessCache[key];
3354			if (n !== void 0) switch (n) {
3355				case 1: return setupState[key];
3356				case 2: return data[key];
3357				case 4: return ctx[key];
3358				case 3: return props[key];
3359			}
3360			else if (hasSetupBinding(setupState, key)) {
3361				accessCache[key] = 1;
3362				return setupState[key];
3363			} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
3364				accessCache[key] = 2;
3365				return data[key];
3366			} else if (hasOwn(props, key)) {
3367				accessCache[key] = 3;
3368				return props[key];
3369			} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
3370				accessCache[key] = 4;
3371				return ctx[key];
3372			} else if (shouldCacheAccess) accessCache[key] = 0;
3373		}
3374		const publicGetter = publicPropertiesMap[key];
3375		let cssModule, globalProperties;
3376		if (publicGetter) {
3377			if (key === "$attrs") track(instance.attrs, "get", "");
3378			return publicGetter(instance);
3379		} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) return cssModule;
3380		else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
3381			accessCache[key] = 4;
3382			return ctx[key];
3383		} else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) return globalProperties[key];
3384	},
3385	set({ _: instance }, key, value) {
3386		const { data, setupState, ctx } = instance;
3387		if (hasSetupBinding(setupState, key)) {
3388			setupState[key] = value;
3389			return true;
3390		} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
3391			data[key] = value;
3392			return true;
3393		} else if (hasOwn(instance.props, key)) return false;

3394		if (key[0] === "$" && key.slice(1) in instance) return false;
3395		else ctx[key] = value;
3396		return true;
3397	},
3398	has({ _: { data, setupState, accessCache, ctx, appContext, props, type } }, key) {
3399		let cssModules;
3400		return !!(accessCache[key] || data !== EMPTY_OBJ && key[0] !== "$" && hasOwn(data, key) || hasSetupBinding(setupState, key) || hasOwn(props, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key) || (cssModules = type.__cssModules) && cssModules[key]);
3401	},
3402	defineProperty(target, key, descriptor) {
3403		if (descriptor.get != null) target._.accessCache[key] = 0;
3404		else if (hasOwn(descriptor, "value")) this.set(target, key, descriptor.value, null);
3405		return Reflect.defineProperty(target, key, descriptor);
3406	}
3407};
3408function useSlots() {
3409	return getContext("useSlots").slots;
3410}
3411function getContext(calledFunctionName) {
3412	const i = getCurrentInstance();
3413	return i.setupContext || (i.setupContext = createSetupContext(i));
3414}
3415function normalizePropsOrEmits(props) {
3416	return isArray(props) ? props.reduce((normalized, p) => (normalized[p] = null, normalized), {}) : props;
3417}
3418var shouldCacheAccess = true;
3419function applyOptions(instance) {
3420	const options = resolveMergedOptions(instance);
3421	const publicThis = instance.proxy;
3422	const ctx = instance.ctx;
3423	shouldCacheAccess = false;
3424	if (options.beforeCreate) callHook$1(options.beforeCreate, instance, "bc");
3425	const { data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, created, beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured, serverPrefetch, expose, inheritAttrs, components, directives, filters } = options;
3426	const checkDuplicateProperties = null;
3427	if (injectOptions) resolveInjections(injectOptions, ctx, checkDuplicateProperties);
3428	if (methods) for (const key in methods) {
3429		const methodHandler = methods[key];
3430		if (isFunction(methodHandler)) ctx[key] = methodHandler.bind(publicThis);
3431	}
3432	if (dataOptions) {
3433		const data = dataOptions.call(publicThis, publicThis);
3434		if (!isObject$2(data)) {} else instance.data = /* @__PURE__ */ reactive(data);
3435	}
3436	shouldCacheAccess = true;
3437	if (computedOptions) for (const key in computedOptions) {
3438		const opt = computedOptions[key];
3439		const c = computed({
3440			get: isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP,
3441			set: !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : NOOP
3442		});
3443		Object.defineProperty(ctx, key, {
3444			enumerable: true,
3445			configurable: true,
3446			get: () => c.value,
3447			set: (v) => c.value = v
3448		});
3449	}
3450	if (watchOptions) for (const key in watchOptions) createWatcher(watchOptions[key], ctx, publicThis, key);
3451	if (provideOptions) {
3452		const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
3453		Reflect.ownKeys(provides).forEach((key) => {
3454			provide(key, provides[key]);
3455		});
3456	}
3457	if (created) callHook$1(created, instance, "c");
3458	function registerLifecycleHook(register, hook) {
3459		if (isArray(hook)) hook.forEach((_hook) => register(_hook.bind(publicThis)));
3460		else if (hook) register(hook.bind(publicThis));
3461	}
3462	registerLifecycleHook(onBeforeMount, beforeMount);
3463	registerLifecycleHook(onMounted, mounted);
3464	registerLifecycleHook(onBeforeUpdate, beforeUpdate);
3465	registerLifecycleHook(onUpdated, updated);
3466	registerLifecycleHook(onActivated, activated);
3467	registerLifecycleHook(onDeactivated, deactivated);
3468	registerLifecycleHook(onErrorCaptured, errorCaptured);
3469	registerLifecycleHook(onRenderTracked, renderTracked);
3470	registerLifecycleHook(onRenderTriggered, renderTriggered);
3471	registerLifecycleHook(onBeforeUnmount, beforeUnmount);
3472	registerLifecycleHook(onUnmounted, unmounted);
3473	registerLifecycleHook(onServerPrefetch, serverPrefetch);
3474	if (isArray(expose)) {
3475		if (expose.length) {
3476			const exposed = instance.exposed || (instance.exposed = {});
3477			expose.forEach((key) => {
3478				Object.defineProperty(exposed, key, {
3479					get: () => publicThis[key],
3480					set: (val) => publicThis[key] = val,
3481					enumerable: true
3482				});
3483			});
3484		} else if (!instance.exposed) instance.exposed = {};
3485	}
3486	if (render && instance.render === NOOP) instance.render = render;
3487	if (inheritAttrs != null) instance.inheritAttrs = inheritAttrs;
3488	if (components) instance.components = components;
3489	if (directives) instance.directives = directives;
3490	if (serverPrefetch) markAsyncBoundary(instance);
3491}
3492function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
3493	if (isArray(injectOptions)) injectOptions = normalizeInject(injectOptions);
3494	for (const key in injectOptions) {
3495		const opt = injectOptions[key];
3496		let injected;
3497		if (isObject$2(opt)) {
3498			if ("default" in opt) injected = inject(opt.from || key, opt.default, true);
3499			else injected = inject(opt.from || key);
3500		} else injected = inject(opt);
3501		if (/* @__PURE__ */ isRef(injected)) Object.defineProperty(ctx, key, {
3502			enumerable: true,
3503			configurable: true,
3504			get: () => injected.value,
3505			set: (v) => injected.value = v
3506		});
3507		else ctx[key] = injected;
3508	}
3509}
3510function callHook$1(hook, instance, type) {
3511	callWithAsyncErrorHandling(isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy), instance, type);
3512}
3513function createWatcher(raw, ctx, publicThis, key) {
3514	let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
3515	if (isString(raw)) {
3516		const handler = ctx[raw];
3517		if (isFunction(handler)) watch(getter, handler);
3518	} else if (isFunction(raw)) watch(getter, raw.bind(publicThis));
3519	else if (isObject$2(raw)) {
3520		if (isArray(raw)) raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
3521		else {

3522			const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
3523			if (isFunction(handler)) watch(getter, handler, raw);
3524		}
3525	}
3526}
3527function resolveMergedOptions(instance) {
3528	const base = instance.type;
3529	const { mixins, extends: extendsOptions } = base;
3530	const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext;
3531	const cached = cache.get(base);
3532	let resolved;
3533	if (cached) resolved = cached;
3534	else if (!globalMixins.length && !mixins && !extendsOptions) resolved = base;
3535	else {
3536		resolved = {};
3537		if (globalMixins.length) globalMixins.forEach((m) => mergeOptions(resolved, m, optionMergeStrategies, true));
3538		mergeOptions(resolved, base, optionMergeStrategies);
3539	}
3540	if (isObject$2(base)) cache.set(base, resolved);
3541	return resolved;
3542}
3543function mergeOptions(to, from, strats, asMixin = false) {
3544	const { mixins, extends: extendsOptions } = from;
3545	if (extendsOptions) mergeOptions(to, extendsOptions, strats, true);
3546	if (mixins) mixins.forEach((m) => mergeOptions(to, m, strats, true));
3547	for (const key in from) if (asMixin && key === "expose") {} else {
3548		const strat = internalOptionMergeStrats[key] || strats && strats[key];
3549		to[key] = strat ? strat(to[key], from[key]) : from[key];
3550	}
3551	return to;
3552}
3553var internalOptionMergeStrats = {
3554	data: mergeDataFn,
3555	props: mergeEmitsOrPropsOptions,
3556	emits: mergeEmitsOrPropsOptions,
3557	methods: mergeObjectOptions,
3558	computed: mergeObjectOptions,
3559	beforeCreate: mergeAsArray,
3560	created: mergeAsArray,
3561	beforeMount: mergeAsArray,
3562	mounted: mergeAsArray,
3563	beforeUpdate: mergeAsArray,
3564	updated: mergeAsArray,
3565	beforeDestroy: mergeAsArray,
3566	beforeUnmount: mergeAsArray,
3567	destroyed: mergeAsArray,
3568	unmounted: mergeAsArray,
3569	activated: mergeAsArray,
3570	deactivated: mergeAsArray,
3571	errorCaptured: mergeAsArray,
3572	serverPrefetch: mergeAsArray,
3573	components: mergeObjectOptions,
3574	directives: mergeObjectOptions,
3575	watch: mergeWatchOptions,
3576	provide: mergeDataFn,
3577	inject: mergeInject
3578};
3579function mergeDataFn(to, from) {
3580	if (!from) return to;
3581	if (!to) return from;
3582	return function mergedDataFn() {
3583		return extend(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from);
3584	};
3585}
3586function mergeInject(to, from) {
3587	return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
3588}
3589function normalizeInject(raw) {
3590	if (isArray(raw)) {
3591		const res = {};
3592		for (let i = 0; i < raw.length; i++) res[raw[i]] = raw[i];
3593		return res;
3594	}
3595	return raw;
3596}
3597function mergeAsArray(to, from) {
3598	return to ? [...new Set([].concat(to, from))] : from;
3599}
3600function mergeObjectOptions(to, from) {
3601	return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
3602}
3603function mergeEmitsOrPropsOptions(to, from) {
3604	if (to) {
3605		if (isArray(to) && isArray(from)) return [.../* @__PURE__ */ new Set([...to, ...from])];
3606		return extend(/* @__PURE__ */ Object.create(null), normalizePropsOrEmits(to), normalizePropsOrEmits(from != null ? from : {}));
3607	} else return from;
3608}
3609function mergeWatchOptions(to, from) {
3610	if (!to) return from;
3611	if (!from) return to;
3612	const merged = extend(/* @__PURE__ */ Object.create(null), to);
3613	for (const key in from) merged[key] = mergeAsArray(to[key], from[key]);
3614	return merged;
3615}
3616function createAppContext() {
3617	return {
3618		app: null,
3619		config: {
3620			isNativeTag: NO,
3621			performance: false,
3622			globalProperties: {},
3623			optionMergeStrategies: {},
3624			errorHandler: void 0,
3625			warnHandler: void 0,
3626			compilerOptions: {}
3627		},
3628		mixins: [],
3629		components: {},
3630		directives: {},
3631		provides: /* @__PURE__ */ Object.create(null),
3632		optionsCache: /* @__PURE__ */ new WeakMap(),
3633		propsCache: /* @__PURE__ */ new WeakMap(),
3634		emitsCache: /* @__PURE__ */ new WeakMap()
3635	};
3636}
3637var uid$1 = 0;
3638function createAppAPI(render, hydrate) {
3639	return function createApp(rootComponent, rootProps = null) {
3640		if (!isFunction(rootComponent)) rootComponent = extend({}, rootComponent);
3641		if (rootProps != null && !isObject$2(rootProps)) rootProps = null;
3642		const context = createAppContext();
3643		const installedPlugins = /* @__PURE__ */ new WeakSet();
3644		const pluginCleanupFns = [];
3645		let isMounted = false;

3646		const app = context.app = {
3647			_uid: uid$1++,
3648			_component: rootComponent,
3649			_props: rootProps,
3650			_container: null,
3651			_context: context,
3652			_instance: null,
3653			version,
3654			get config() {
3655				return context.config;
3656			},
3657			set config(v) {},
3658			use(plugin, ...options) {
3659				if (installedPlugins.has(plugin)) {} else if (plugin && isFunction(plugin.install)) {
3660					installedPlugins.add(plugin);
3661					plugin.install(app, ...options);
3662				} else if (isFunction(plugin)) {
3663					installedPlugins.add(plugin);
3664					plugin(app, ...options);
3665				}
3666				return app;
3667			},
3668			mixin(mixin) {
3669				if (!context.mixins.includes(mixin)) context.mixins.push(mixin);
3670				return app;
3671			},
3672			component(name, component) {
3673				if (!component) return context.components[name];
3674				context.components[name] = component;
3675				return app;
3676			},
3677			directive(name, directive) {
3678				if (!directive) return context.directives[name];
3679				context.directives[name] = directive;
3680				return app;
3681			},
3682			mount(rootContainer, isHydrate, namespace) {
3683				if (!isMounted) {
3684					const vnode = app._ceVNode || createVNode(rootComponent, rootProps);
3685					vnode.appContext = context;
3686					if (namespace === true) namespace = "svg";
3687					else if (namespace === false) namespace = void 0;
3688					if (isHydrate && hydrate) hydrate(vnode, rootContainer);
3689					else render(vnode, rootContainer, namespace);
3690					isMounted = true;
3691					app._container = rootContainer;
3692					rootContainer.__vue_app__ = app;
3693					return getComponentPublicInstance(vnode.component);
3694				}
3695			},
3696			onUnmount(cleanupFn) {
3697				pluginCleanupFns.push(cleanupFn);
3698			},
3699			unmount() {
3700				if (isMounted) {
3701					callWithAsyncErrorHandling(pluginCleanupFns, app._instance, 16);
3702					render(null, app._container);
3703					delete app._container.__vue_app__;
3704				}
3705			},
3706			provide(key, value) {
3707				context.provides[key] = value;
3708				return app;
3709			},
3710			runWithContext(fn) {
3711				const lastApp = currentApp;
3712				currentApp = app;
3713				try {
3714					return fn();
3715				} finally {
3716					currentApp = lastApp;
3717				}
3718			}
3719		};
3720		return app;
3721	};
3722}
3723var currentApp = null;
3724var getModelModifiers = (props, modelName) => {
3725	return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize$1(modelName)}Modifiers`] || props[`${hyphenate$1(modelName)}Modifiers`];
3726};
3727function emit(instance, event, ...rawArgs) {
3728	if (instance.isUnmounted) return;
3729	const props = instance.vnode.props || EMPTY_OBJ;
3730	let args = rawArgs;
3731	const isModelListener = event.startsWith("update:");
3732	const modifiers = isModelListener && getModelModifiers(props, event.slice(7));
3733	if (modifiers) {
3734		if (modifiers.trim) args = rawArgs.map((a) => isString(a) ? a.trim() : a);
3735		if (modifiers.number) args = args.map(looseToNumber);
3736	}
3737	let handlerName;
3738	let handler = props[handlerName = toHandlerKey(event)] || props[handlerName = toHandlerKey(camelize$1(event))];
3739	if (!handler && isModelListener) handler = props[handlerName = toHandlerKey(hyphenate$1(event))];
3740	if (handler) callWithAsyncErrorHandling(handler, instance, 6, args);
3741	const onceHandler = props[handlerName + `Once`];
3742	if (onceHandler) {
3743		if (!instance.emitted) instance.emitted = {};
3744		else if (instance.emitted[handlerName]) return;
3745		instance.emitted[handlerName] = true;
3746		callWithAsyncErrorHandling(onceHandler, instance, 6, args);
3747	}
3748}
3749var mixinEmitsCache = /* @__PURE__ */ new WeakMap();
3750function normalizeEmitsOptions(comp, appContext, asMixin = false) {
3751	const cache = asMixin ? mixinEmitsCache : appContext.emitsCache;
3752	const cached = cache.get(comp);
3753	if (cached !== void 0) return cached;
3754	const raw = comp.emits;
3755	let normalized = {};
3756	let hasExtends = false;
3757	if (!isFunction(comp)) {
3758		const extendEmits = (raw2) => {
3759			const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
3760			if (normalizedFromExtend) {
3761				hasExtends = true;
3762				extend(normalized, normalizedFromExtend);
3763			}
3764		};
3765		if (!asMixin && appContext.mixins.length) appContext.mixins.forEach(extendEmits);
3766		if (comp.extends) extendEmits(comp.extends);
3767		if (comp.mixins) comp.mixins.forEach(extendEmits);
3768	}
3769	if (!raw && !hasExtends) {
3770		if (isObject$2(comp)) cache.set(comp, null);
3771		return null;
3772	}
3773	if (isArray(raw)) raw.forEach((key) => normalized[key] = null);
3774	else extend(normalized, raw);
3775	if (isObject$2(comp)) cache.set(comp, normalized);
3776	return normalized;
3777}
3778function isEmitListener(options, key) {
3779	if (!options || !isOn(key)) return false;

3780	key = key.slice(2);
3781	key = key === "Once" ? key : key.replace(/Once$/, "");
3782	return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate$1(key)) || hasOwn(options, key);
3783}
3784function renderComponentRoot(instance) {
3785	const { type: Component, vnode, proxy, withProxy, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, props, data, setupState, ctx, inheritAttrs } = instance;
3786	const prev = setCurrentRenderingInstance(instance);
3787	let result;
3788	let fallthroughAttrs;
3789	try {
3790		if (vnode.shapeFlag & 4) {
3791			const proxyToUse = withProxy || proxy;
3792			const thisProxy = proxyToUse;
3793			result = normalizeVNode(render.call(thisProxy, proxyToUse, renderCache, props, setupState, data, ctx));
3794			fallthroughAttrs = attrs;
3795		} else {
3796			const render2 = Component;
3797			result = normalizeVNode(render2.length > 1 ? render2(props, {
3798				attrs,
3799				slots,
3800				emit
3801			}) : render2(props, null));
3802			fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
3803		}
3804	} catch (err) {
3805		blockStack.length = 0;
3806		handleError(err, instance, 1);
3807		result = createVNode(Comment);
3808	}
3809	let root = result;
3810	if (fallthroughAttrs && inheritAttrs !== false) {
3811		const keys = Object.keys(fallthroughAttrs);
3812		const { shapeFlag } = root;
3813		if (keys.length) {
3814			if (shapeFlag & 7) {
3815				if (propsOptions && keys.some(isModelListener)) fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
3816				root = cloneVNode(root, fallthroughAttrs, false, true);
3817			}
3818		}
3819	}
3820	if (vnode.dirs) {
3821		root = cloneVNode(root, null, false, true);
3822		root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
3823	}
3824	if (vnode.transition) setTransitionHooks(isTeleport(root.type) ? getInnerChild$1(root) || root : root, vnode.transition);
3825	result = root;
3826	setCurrentRenderingInstance(prev);
3827	return result;
3828}
3829var getFunctionalFallthrough = (attrs) => {
3830	let res;
3831	for (const key in attrs) if (key === "class" || key === "style" || isOn(key)) (res || (res = {}))[key] = attrs[key];
3832	return res;
3833};
3834var filterModelListeners = (attrs, props) => {
3835	const res = {};
3836	for (const key in attrs) if (!isModelListener(key) || !(key.slice(9) in props)) res[key] = attrs[key];
3837	return res;
3838};
3839function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
3840	const { props: prevProps, children: prevChildren, component } = prevVNode;
3841	const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
3842	const emits = component.emitsOptions;
3843	if (nextVNode.dirs || nextVNode.transition) return true;
3844	if (optimized && patchFlag >= 0) {
3845		if (patchFlag & 1024) return true;
3846		if (patchFlag & 16) {
3847			if (!prevProps) return !!nextProps;
3848			return hasPropsChanged(prevProps, nextProps, emits);
3849		} else if (patchFlag & 8) {
3850			const dynamicProps = nextVNode.dynamicProps;
3851			for (let i = 0; i < dynamicProps.length; i++) {
3852				const key = dynamicProps[i];
3853				if (hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emits, key)) return true;
3854			}
3855		}
3856	} else {
3857		if (prevChildren || nextChildren) {
3858			if (!nextChildren || !nextChildren.$stable) return true;
3859		}
3860		if (prevProps === nextProps) return false;
3861		if (!prevProps) return !!nextProps;
3862		if (!nextProps) return true;
3863		return hasPropsChanged(prevProps, nextProps, emits);
3864	}
3865	return false;
3866}
3867function hasPropsChanged(prevProps, nextProps, emitsOptions) {
3868	const nextKeys = Object.keys(nextProps);
3869	if (nextKeys.length !== Object.keys(prevProps).length) return true;
3870	for (let i = 0; i < nextKeys.length; i++) {
3871		const key = nextKeys[i];
3872		if (hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emitsOptions, key)) return true;
3873	}
3874	return false;
3875}
3876function hasPropValueChanged(nextProps, prevProps, key) {
3877	const nextProp = nextProps[key];
3878	const prevProp = prevProps[key];
3879	if (key === "style" && isObject$2(nextProp) && isObject$2(prevProp)) return !looseEqual(nextProp, prevProp);
3880	return nextProp !== prevProp;
3881}
3882function updateHOCHostEl({ vnode, parent, suspense }, el) {
3883	while (parent) {
3884		const root = parent.subTree;
3885		if (root.suspense && root.suspense.activeBranch === vnode) {
3886			root.suspense.vnode.el = root.el = el;
3887			vnode = root;
3888		}
3889		if (root === vnode) {
3890			(vnode = parent.vnode).el = el;
3891			parent = parent.parent;
3892		} else break;
3893	}
3894	if (suspense && suspense.activeBranch === vnode) suspense.vnode.el = el;
3895}
3896var internalObjectProto = {};
3897var createInternalObject = () => Object.create(internalObjectProto);
3898var isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
3899function initProps(instance, rawProps, isStateful, isSSR = false) {
3900	const props = {};
3901	const attrs = createInternalObject();
3902	instance.propsDefaults = /* @__PURE__ */ Object.create(null);
3903	setFullProps(instance, rawProps, props, attrs);
3904	for (const key in instance.propsOptions[0]) if (!(key in props)) props[key] = void 0;
3905	if (isStateful) instance.props = isSSR ? props : /* @__PURE__ */ shallowReactive(props);
3906	else if (!instance.type.props) instance.props = attrs;
3907	else instance.props = props;
3908	instance.attrs = attrs;
3909}
3910function updateProps(instance, rawProps, rawPrevProps, optimized) {
3911	const { props, attrs, vnode: { patchFlag } } = instance;
3912	const rawCurrentProps = /* @__PURE__ */ toRaw(props);
3913	const [options] = instance.propsOptions;
3914	let hasAttrsChanged = false;

3915	if ((optimized || patchFlag > 0) && !(patchFlag & 16)) {
3916		if (patchFlag & 8) {
3917			const propsToUpdate = instance.vnode.dynamicProps;
3918			for (let i = 0; i < propsToUpdate.length; i++) {
3919				let key = propsToUpdate[i];
3920				if (isEmitListener(instance.emitsOptions, key)) continue;
3921				const value = rawProps[key];
3922				if (options) {
3923					if (hasOwn(attrs, key)) {
3924						if (value !== attrs[key]) {
3925							attrs[key] = value;
3926							hasAttrsChanged = true;
3927						}
3928					} else {
3929						const camelizedKey = camelize$1(key);
3930						props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false);
3931					}
3932				} else if (value !== attrs[key]) {
3933					attrs[key] = value;
3934					hasAttrsChanged = true;
3935				}
3936			}
3937		}
3938	} else {
3939		if (setFullProps(instance, rawProps, props, attrs)) hasAttrsChanged = true;
3940		let kebabKey;
3941		for (const key in rawCurrentProps) if (!rawProps || !hasOwn(rawProps, key) && ((kebabKey = hyphenate$1(key)) === key || !hasOwn(rawProps, kebabKey))) {
3942			if (options) {
3943				if (rawPrevProps && (rawPrevProps[key] !== void 0 || rawPrevProps[kebabKey] !== void 0)) props[key] = resolvePropValue(options, rawCurrentProps, key, void 0, instance, true);
3944			} else delete props[key];
3945		}
3946		if (attrs !== rawCurrentProps) {
3947			for (const key in attrs) if (!rawProps || !hasOwn(rawProps, key) && true) {
3948				delete attrs[key];
3949				hasAttrsChanged = true;
3950			}
3951		}
3952	}
3953	if (hasAttrsChanged) trigger(instance.attrs, "set", "");
3954}
3955function setFullProps(instance, rawProps, props, attrs) {
3956	const [options, needCastKeys] = instance.propsOptions;
3957	let hasAttrsChanged = false;
3958	let rawCastValues;
3959	if (rawProps) for (let key in rawProps) {
3960		if (isReservedProp(key)) continue;
3961		const value = rawProps[key];
3962		let camelKey;
3963		if (options && hasOwn(options, camelKey = camelize$1(key))) {
3964			if (!needCastKeys || !needCastKeys.includes(camelKey)) props[camelKey] = value;
3965			else (rawCastValues || (rawCastValues = {}))[camelKey] = value;
3966		} else if (!isEmitListener(instance.emitsOptions, key)) {
3967			if (!(key in attrs) || value !== attrs[key]) {
3968				attrs[key] = value;
3969				hasAttrsChanged = true;
3970			}
3971		}
3972	}
3973	if (needCastKeys) {
3974		const rawCurrentProps = /* @__PURE__ */ toRaw(props);
3975		const castValues = rawCastValues || EMPTY_OBJ;
3976		for (let i = 0; i < needCastKeys.length; i++) {
3977			const key = needCastKeys[i];
3978			props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn(castValues, key));
3979		}
3980	}
3981	return hasAttrsChanged;
3982}
3983function resolvePropValue(options, props, key, value, instance, isAbsent) {
3984	const opt = options[key];
3985	if (opt != null) {
3986		const hasDefault = hasOwn(opt, "default");
3987		if (hasDefault && value === void 0) {
3988			const defaultValue = opt.default;
3989			if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
3990				const { propsDefaults } = instance;
3991				if (key in propsDefaults) value = propsDefaults[key];
3992				else {
3993					const reset = setCurrentInstance(instance);
3994					value = propsDefaults[key] = defaultValue.call(null, props);
3995					reset();
3996				}
3997			} else value = defaultValue;
3998			if (instance.ce) instance.ce._setProp(key, value);
3999		}
4000		if (opt[0]) {
4001			if (isAbsent && !hasDefault) value = false;
4002			else if (opt[1] && (value === "" || value === hyphenate$1(key))) value = true;
4003		}
4004	}
4005	return value;
4006}
4007var mixinPropsCache = /* @__PURE__ */ new WeakMap();
4008function normalizePropsOptions(comp, appContext, asMixin = false) {
4009	const cache = asMixin ? mixinPropsCache : appContext.propsCache;
4010	const cached = cache.get(comp);
4011	if (cached) return cached;
4012	const raw = comp.props;
4013	const normalized = {};
4014	const needCastKeys = [];
4015	let hasExtends = false;
4016	if (!isFunction(comp)) {
4017		const extendProps = (raw2) => {
4018			hasExtends = true;
4019			const [props, keys] = normalizePropsOptions(raw2, appContext, true);
4020			extend(normalized, props);
4021			if (keys) needCastKeys.push(...keys);
4022		};
4023		if (!asMixin && appContext.mixins.length) appContext.mixins.forEach(extendProps);
4024		if (comp.extends) extendProps(comp.extends);
4025		if (comp.mixins) comp.mixins.forEach(extendProps);
4026	}
4027	if (!raw && !hasExtends) {
4028		if (isObject$2(comp)) cache.set(comp, EMPTY_ARR);
4029		return EMPTY_ARR;
4030	}
4031	if (isArray(raw)) for (let i = 0; i < raw.length; i++) {
4032		const normalizedKey = camelize$1(raw[i]);
4033		if (validatePropName(normalizedKey)) normalized[normalizedKey] = EMPTY_OBJ;
4034	}
4035	else if (raw) for (const key in raw) {
4036		const normalizedKey = camelize$1(key);
4037		if (validatePropName(normalizedKey)) {
4038			const opt = raw[key];
4039			const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
4040			const propType = prop.type;
4041			let shouldCast = false;

4042			let shouldCastTrue = true;
4043			if (isArray(propType)) for (let index = 0; index < propType.length; ++index) {
4044				const type = propType[index];
4045				const typeName = isFunction(type) && type.name;
4046				if (typeName === "Boolean") {
4047					shouldCast = true;
4048					break;
4049				} else if (typeName === "String") shouldCastTrue = false;
4050			}
4051			else shouldCast = isFunction(propType) && propType.name === "Boolean";
4052			prop[0] = shouldCast;
4053			prop[1] = shouldCastTrue;
4054			if (shouldCast || hasOwn(prop, "default")) needCastKeys.push(normalizedKey);
4055		}
4056	}
4057	const res = [normalized, needCastKeys];
4058	if (isObject$2(comp)) cache.set(comp, res);
4059	return res;
4060}
4061function validatePropName(key) {
4062	if (key[0] !== "$" && !isReservedProp(key)) return true;
4063	return false;
4064}
4065var isInternalKey = (key) => key === "_" || key === "_ctx" || key === "$stable";
4066var normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
4067var normalizeSlot = (key, rawSlot, ctx) => {
4068	if (rawSlot._n) return rawSlot;
4069	const normalized = withCtx((...args) => {
4070		return normalizeSlotValue(rawSlot(...args));
4071	}, ctx);
4072	normalized._c = false;
4073	return normalized;
4074};
4075var normalizeObjectSlots = (rawSlots, slots, instance) => {
4076	const ctx = rawSlots._ctx;
4077	for (const key in rawSlots) {
4078		if (isInternalKey(key)) continue;
4079		const value = rawSlots[key];
4080		if (isFunction(value)) slots[key] = normalizeSlot(key, value, ctx);
4081		else if (value != null) {
4082			const normalized = normalizeSlotValue(value);
4083			slots[key] = () => normalized;
4084		}
4085	}
4086};
4087var normalizeVNodeSlots = (instance, children) => {
4088	const normalized = normalizeSlotValue(children);
4089	instance.slots.default = () => normalized;
4090};
4091var assignSlots = (slots, children, optimized) => {
4092	for (const key in children) if (optimized || !isInternalKey(key)) slots[key] = children[key];
4093};
4094var initSlots = (instance, children, optimized) => {
4095	const slots = instance.slots = createInternalObject();
4096	if (instance.vnode.shapeFlag & 32) {
4097		const type = children._;
4098		if (type) {
4099			assignSlots(slots, children, optimized);
4100			if (optimized) def(slots, "_", type, true);
4101		} else normalizeObjectSlots(children, slots);
4102	} else if (children) normalizeVNodeSlots(instance, children);
4103};
4104var updateSlots = (instance, children, optimized) => {
4105	const { vnode, slots } = instance;
4106	let needDeletionCheck = true;
4107	let deletionComparisonTarget = EMPTY_OBJ;
4108	if (vnode.shapeFlag & 32) {
4109		const type = children._;
4110		if (type) {
4111			if (optimized && type === 1) needDeletionCheck = false;
4112			else assignSlots(slots, children, optimized);
4113		} else {
4114			needDeletionCheck = !children.$stable;
4115			normalizeObjectSlots(children, slots);
4116		}
4117		deletionComparisonTarget = children;
4118	} else if (children) {
4119		normalizeVNodeSlots(instance, children);
4120		deletionComparisonTarget = { default: 1 };
4121	}
4122	if (needDeletionCheck) {
4123		for (const key in slots) if (!isInternalKey(key) && deletionComparisonTarget[key] == null) delete slots[key];
4124	}
4125};
4126var queuePostRenderEffect = queueEffectWithSuspense;
4127function createRenderer(options) {
4128	return baseCreateRenderer(options);
4129}
4130function createHydrationRenderer(options) {
4131	return baseCreateRenderer(options, createHydrationFunctions);
4132}
4133function baseCreateRenderer(options, createHydrationFns) {
4134	const target = getGlobalThis();
4135	target.__VUE__ = true;
4136	const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, insertStaticContent: hostInsertStaticContent } = options;
4137	const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, namespace = void 0, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {
4138		if (n1 === n2) return;
4139		if (n1 && !isSameVNodeType(n1, n2)) {
4140			anchor = getNextHostNode(n1);
4141			unmount(n1, parentComponent, parentSuspense, true);
4142			n1 = null;
4143		}
4144		if (n2.patchFlag === -2) {
4145			optimized = false;

4146			n2.dynamicChildren = null;
4147		}
4148		if (n2.dynamicChildren && n1 && n1.dynamicChildren && n1.dynamicChildren.hasOnce) {
4149			if (n2.dynamicChildren === EMPTY_ARR) n2.dynamicChildren = [];
4150			n2.dynamicChildren.hasOnce = true;
4151		}
4152		const { type, ref, shapeFlag } = n2;
4153		switch (type) {
4154			case Text:
4155				processText(n1, n2, container, anchor);
4156				break;
4157			case Comment:
4158				processCommentNode(n1, n2, container, anchor);
4159				break;
4160			case Static:
4161				if (n1 == null) mountStaticNode(n2, container, anchor, namespace);
4162				break;
4163			case Fragment:
4164				processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4165				break;
4166			default: if (shapeFlag & 1) processElement(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4167			else if (shapeFlag & 6) processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4168			else if (shapeFlag & 64) type.process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals);
4169			else if (shapeFlag & 128) type.process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals);
4170		}
4171		if (ref != null && parentComponent) setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
4172		else if (ref == null && n1 && n1.ref != null) setRef(n1.ref, null, parentSuspense, n1, true);
4173	};
4174	const processText = (n1, n2, container, anchor) => {
4175		if (n1 == null) hostInsert(n2.el = hostCreateText(n2.children), container, anchor);
4176		else {
4177			const el = n2.el = n1.el;
4178			if (n2.children !== n1.children) hostSetText(el, n2.children);
4179		}
4180	};
4181	const processCommentNode = (n1, n2, container, anchor) => {
4182		if (n1 == null) hostInsert(n2.el = hostCreateComment(n2.children || ""), container, anchor);
4183		else n2.el = n1.el;
4184	};
4185	const mountStaticNode = (n2, container, anchor, namespace) => {
4186		[n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, namespace, n2.el, n2.anchor);
4187	};
4188	const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
4189		let next;
4190		while (el && el !== anchor) {
4191			next = hostNextSibling(el);
4192			hostInsert(el, container, nextSibling);
4193			el = next;
4194		}
4195		hostInsert(anchor, container, nextSibling);
4196	};
4197	const removeStaticNode = ({ el, anchor }) => {
4198		let next;
4199		while (el && el !== anchor) {
4200			next = hostNextSibling(el);
4201			hostRemove(el);
4202			el = next;
4203		}
4204		hostRemove(anchor);
4205	};
4206	const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
4207		if (n2.type === "svg") namespace = "svg";
4208		else if (n2.type === "math") namespace = "mathml";
4209		if (n1 == null) mountElement(n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4210		else {
4211			const customElement = n1.el && n1.el._isVueCE ? n1.el : null;
4212			try {
4213				if (customElement) customElement._beginPatch();
4214				patchElement(n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4215			} finally {
4216				if (customElement) customElement._endPatch();
4217			}
4218		}
4219	};
4220	const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
4221		let el;
4222		let vnodeHook;
4223		const { props, shapeFlag, transition, dirs } = vnode;
4224		el = vnode.el = hostCreateElement(vnode.type, namespace, props && props.is, props);
4225		if (shapeFlag & 8) hostSetElementText(el, vnode.children);
4226		else if (shapeFlag & 16) mountChildren(vnode.children, el, null, parentComponent, parentSuspense, resolveChildrenNamespace(vnode, namespace), slotScopeIds, optimized);
4227		if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "created");
4228		setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
4229		if (props) {
4230			for (const key in props) if (key !== "value" && !isReservedProp(key)) hostPatchProp(el, key, null, props[key], namespace, parentComponent);
4231			if ("value" in props) hostPatchProp(el, "value", null, props.value, namespace);
4232			if (vnodeHook = props.onVnodeBeforeMount) invokeVNodeHook(vnodeHook, parentComponent, vnode);
4233		}
4234		if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
4235		const needCallTransitionHooks = needTransition(parentSuspense, transition);
4236		if (needCallTransitionHooks) transition.beforeEnter(el);
4237		hostInsert(el, container, anchor);
4238		if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) queuePostRenderEffect(() => {
4239			try {
4240				vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
4241				needCallTransitionHooks && transition.enter(el);
4242				dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
4243			} finally {}
4244		}, parentSuspense);
4245	};
4246	const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
4247		if (scopeId) hostSetScopeId(el, scopeId);
4248		if (slotScopeIds) for (let i = 0; i < slotScopeIds.length; i++) hostSetScopeId(el, slotScopeIds[i]);
4249		if (parentComponent) {
4250			let subTree = parentComponent.subTree;
4251			if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ss

4251Fallback === vnode)) {
4252				const parentVNode = parentComponent.vnode;
4253				setScopeId(el, parentVNode, parentVNode.scopeId, parentVNode.slotScopeIds, parentComponent.parent);
4254			}
4255		}
4256	};
4257	const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
4258		for (let i = start; i < children.length; i++) {
4259			const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
4260			patch(null, child, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4261		}
4262	};
4263	const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
4264		const el = n2.el = n1.el;
4265		let { patchFlag, dynamicChildren, dirs } = n2;
4266		patchFlag |= n1.patchFlag & 16;
4267		const oldProps = n1.props || EMPTY_OBJ;
4268		const newProps = n2.props || EMPTY_OBJ;
4269		let vnodeHook;
4270		parentComponent && toggleRecurse(parentComponent, false);
4271		if (vnodeHook = newProps.onVnodeBeforeUpdate) invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
4272		if (dirs) invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
4273		parentComponent && toggleRecurse(parentComponent, true);
4274		if (dynamicChildren && (!n1.dynamicChildren || n1.dynamicChildren.length !== dynamicChildren.length)) {
4275			patchFlag = 0;
4276			optimized = false;
4277			dynamicChildren = null;
4278		}
4279		if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) hostSetElementText(el, "");
4280		if (dynamicChildren) patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, resolveChildrenNamespace(n2, namespace), slotScopeIds);
4281		else if (!optimized) patchChildren(n1, n2, el, null, parentComponent, parentSuspense, resolveChildrenNamespace(n2, namespace), slotScopeIds, false);
4282		if (patchFlag > 0) {
4283			if (patchFlag & 16) patchProps(el, oldProps, newProps, parentComponent, namespace);
4284			else {
4285				if (patchFlag & 2) {
4286					if (oldProps.class !== newProps.class) hostPatchProp(el, "class", null, newProps.class, namespace);
4287				}
4288				if (patchFlag & 4) hostPatchProp(el, "style", oldProps.style, newProps.style, namespace);
4289				if (patchFlag & 8) {
4290					const propsToUpdate = n2.dynamicProps;
4291					for (let i = 0; i < propsToUpdate.length; i++) {
4292						const key = propsToUpdate[i];
4293						const prev = oldProps[key];
4294						const next = newProps[key];
4295						if (next !== prev || key === "value") hostPatchProp(el, key, prev, next, namespace, parentComponent);
4296					}
4297				}
4298			}
4299			if (patchFlag & 1) {
4300				if (n1.children !== n2.children) hostSetElementText(el, n2.children);
4301			}
4302		} else if (!optimized && dynamicChildren == null) patchProps(el, oldProps, newProps, parentComponent, namespace);
4303		if ((vnodeHook = newProps.onVnodeUpdated) || dirs) queuePostRenderEffect(() => {
4304			vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
4305			dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
4306		}, parentSuspense);
4307	};
4308	const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
4309		for (let i = 0; i < newChildren.length; i++) {
4310			const oldVNode = oldChildren[i];
4311			const newVNode = newChildren[i];
4312			const container = oldVNode.el && (oldVNode.type === Fragment || !isSameVNodeType(oldVNode, newVNode) || oldVNode.shapeFlag & 198) ? hostParentNode(oldVNode.el) : fallbackContainer;
4313			patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, namespace, slotScopeIds, true);
4314		}
4315	};
4316	const patchProps = (el, oldProps, newProps, parentComponent, namespace) => {
4317		if (oldProps !== newProps) {
4318			if (oldProps !== EMPTY_OBJ) {
4319				for (const key in oldProps) if (!isReservedProp(key) && !(key in newProps)) hostPatchProp(el, key, oldProps[key], null, namespace, parentComponent);
4320			}
4321			for (const key in newProps) {
4322				if (isReservedProp(key)) continue;
4323				const next = newProps[key];
4324				const prev = oldProps[key];
4325				if (next !== prev && key !== "value") hostPatchProp(el, key, prev, next, namespace, parentComponent);
4326			}
4327			if ("value" in newProps) hostPatchProp(el, "value", oldProps.value, newProps.value, namespace);
4328		}
4329	};
4330	const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
4331		const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
4332		const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
4333		let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
4334		if (fragmentSlotScopeIds) slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
4335		if (n1 == null) {
4336			hostInsert(fragmentStartAnchor, container, anchor);
4337			hostInsert(fragmentEndAnchor, container, anchor);

4338			mountChildren(n2.children || [], container, fragmentEndAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4339		} else if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && n1.dynamicChildren && n1.dynamicChildren.length === dynamicChildren.length) {
4340			patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, namespace, slotScopeIds);
4341			if (n2.key != null || parentComponent && n2 === parentComponent.subTree) traverseStaticChildren(n1, n2, true);
4342		} else patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4343	};
4344	const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
4345		n2.slotScopeIds = slotScopeIds;
4346		if (n1 == null) {
4347			if (n2.shapeFlag & 512) parentComponent.ctx.activate(n2, container, anchor, namespace, optimized);
4348			else mountComponent(n2, container, anchor, parentComponent, parentSuspense, namespace, optimized);
4349		} else updateComponent(n1, n2, optimized);
4350	};
4351	const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace, optimized) => {
4352		const instance = initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense);
4353		if (isKeepAlive(initialVNode)) instance.ctx.renderer = internals;
4354		setupComponent(instance, false, optimized);
4355		if (instance.asyncDep) {
4356			parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized);
4357			if (!initialVNode.el) {
4358				const placeholder = instance.subTree = createVNode(Comment);
4359				processCommentNode(null, placeholder, container, anchor);
4360				initialVNode.placeholder = placeholder.el;
4361			}
4362		} else setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, namespace, optimized);
4363	};
4364	const updateComponent = (n1, n2, optimized) => {
4365		const instance = n2.component = n1.component;
4366		if (shouldUpdateComponent(n1, n2, optimized)) {
4367			if (instance.asyncDep && !instance.asyncResolved) {
4368				n2.el = n1.el;
4369				updateComponentPreRender(instance, n2, optimized);
4370				return;
4371			} else {
4372				instance.next = n2;
4373				instance.update();
4374			}
4375		} else {
4376			n2.el = n1.el;
4377			instance.vnode = n2;
4378		}
4379	};
4380	const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
4381		const componentUpdateFn = () => {
4382			if (!instance.isMounted) {
4383				let vnodeHook;
4384				const { el, props } = initialVNode;
4385				const { bm, m, parent, root, type } = instance;
4386				const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
4387				toggleRecurse(instance, false);
4388				if (bm) invokeArrayFns(bm);
4389				if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) invokeVNodeHook(vnodeHook, parent, initialVNode);
4390				toggleRecurse(instance, true);
4391				if (el && hydrateNode) {
4392					const hydrateSubTree = () => {
4393						instance.subTree = renderComponentRoot(instance);
4394						hydrateNode(el, instance.subTree, instance, parentSuspense, null);
4395					};
4396					if (isAsyncWrapperVNode && type.__asyncHydrate) type.__asyncHydrate(el, instance, hydrateSubTree);
4397					else hydrateSubTree();
4398				} else {
4399					if (root.ce && root.ce._hasShadowRoot()) root.ce._injectChildStyle(type, instance.parent ? instance.parent.type : void 0);
4400					const subTree = instance.subTree = renderComponentRoot(instance);
4401					patch(null, subTree, container, anchor, instance, parentSuspense, namespace);
4402					initialVNode.el = subTree.el;
4403				}
4404				if (m) queuePostRenderEffect(m, parentSuspense);
4405				if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
4406					const scopedInitialVNode = initialVNode;
4407					queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode), parentSuspense);
4408				}
4409				if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) instance.a && queuePostRenderEffect(instance.a, parentSuspense);
4410				instance.isMounted = true;
4411				initialVNode = container = anchor = null;
4412			} else {
4413				let { next, bu, u, parent, vnode } = instance;
4414				{
4415					const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
4416					if (nonHydratedAsyncRoot) {
4417						if (next) {
4418							next.el = vnode.el;
4419							updateComponentPreRender(instance, next, optimized);
4420						}
4421						nonHydratedAsyncRoot.asyncDep.then(() => {
4422							queuePostRenderEffect(() => {

4423								if (!instance.isUnmounted) update();
4424							}, parentSuspense);
4425						});
4426						return;
4427					}
4428				}
4429				let originNext = next;
4430				let vnodeHook;
4431				toggleRecurse(instance, false);
4432				if (next) {
4433					next.el = vnode.el;
4434					updateComponentPreRender(instance, next, optimized);
4435				} else next = vnode;
4436				if (bu) invokeArrayFns(bu);
4437				if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) invokeVNodeHook(vnodeHook, parent, next, vnode);
4438				toggleRecurse(instance, true);
4439				const nextTree = renderComponentRoot(instance);
4440				const prevTree = instance.subTree;
4441				instance.subTree = nextTree;
4442				patch(prevTree, nextTree, hostParentNode(prevTree.el), getNextHostNode(prevTree), instance, parentSuspense, namespace);
4443				next.el = nextTree.el;
4444				if (originNext === null) updateHOCHostEl(instance, nextTree.el);
4445				if (u) queuePostRenderEffect(u, parentSuspense);
4446				if (vnodeHook = next.props && next.props.onVnodeUpdated) queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, next, vnode), parentSuspense);
4447			}
4448		};
4449		instance.scope.on();
4450		const effect = instance.effect = new ReactiveEffect(componentUpdateFn);
4451		instance.scope.off();
4452		const update = instance.update = effect.run.bind(effect);
4453		const job = instance.job = effect.runIfDirty.bind(effect);
4454		job.i = instance;
4455		job.id = instance.uid;
4456		effect.scheduler = () => queueJob(job);
4457		toggleRecurse(instance, true);
4458		update();
4459	};
4460	const updateComponentPreRender = (instance, nextVNode, optimized) => {
4461		nextVNode.component = instance;
4462		const prevProps = instance.vnode.props;
4463		instance.vnode = nextVNode;
4464		instance.next = null;
4465		updateProps(instance, nextVNode.props, prevProps, optimized);
4466		updateSlots(instance, nextVNode.children, optimized);
4467		pauseTracking();
4468		flushPreFlushCbs(instance);
4469		resetTracking();
4470	};
4471	const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
4472		const c1 = n1 && n1.children;
4473		const prevShapeFlag = n1 ? n1.shapeFlag : 0;
4474		const c2 = n2.children;
4475		const { patchFlag, shapeFlag } = n2;
4476		if (patchFlag > 0) {
4477			if (patchFlag & 128) {
4478				patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4479				return;
4480			} else if (patchFlag & 256) {
4481				patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4482				return;
4483			}
4484		}
4485		if (shapeFlag & 8) {
4486			if (prevShapeFlag & 16) unmountChildren(c1, parentComponent, parentSuspense);
4487			if (c2 !== c1) hostSetElementText(container, c2);
4488		} else if (prevShapeFlag & 16) {
4489			if (shapeFlag & 16) patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4490			else unmountChildren(c1, parentComponent, parentSuspense, true);
4491		} else {
4492			if (prevShapeFlag & 8) hostSetElementText(container, "");
4493			if (shapeFlag & 16) mountChildren(c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4494		}
4495	};
4496	const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
4497		c1 = c1 || EMPTY_ARR;
4498		c2 = c2 || EMPTY_ARR;
4499		const oldLength = c1.length;
4500		const newLength = c2.length;
4501		const commonLength = Math.min(oldLength, newLength);
4502		let i = 0;
4503		for (; i < commonLength; i++) {
4504			const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
4505			patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4506		}
4507		if (oldLength > newLength) unmountChildren(c1, parentComponent, parentSuspense, true, false, commonLength);
4508		else mountChildren(c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, commonLength);
4509	};
4510	const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
4511		let i = 0;
4512		const l2 = c2.length;
4513		let e1 = c1.length - 1;
4514		let e2 = l2 - 1;
4515		while (i <= e1 && i <= e2) {
4516			const n1 = c1[i];
4517			const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
4518			if (isSameVNodeType(n1, n2)) patch(n1, n2, container, null, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4519			else break;
4520			i++;
4521		}
4522		while (i <= e1 && i <= e2) {
4523			const n1 = c1[e1];
4524			const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
4525			if (isSameVNodeType(n1, n2)) patch(n1, n2, container, null, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4526			else break;
4527			e1--;
4528			e2--;
4529		}
4530		if (i > e1) {
4531			if (i <= e2) {
4532				const nextPos = e2 + 1;
4533				const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
4534				while (i <= e2) {
4535					patch(null, c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]), container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4536					i++;
4537				}
4538			}
4539		} else if (i > e2) while (i <= e1) {
4540			unmount(c1[i], parentComponent, parentSuspense, true);
4541			i++;
4542		}
4543		else {

4544			const s1 = i;
4545			const s2 = i;
4546			const keyToNewIndexMap = /* @__PURE__ */ new Map();
4547			for (i = s2; i <= e2; i++) {
4548				const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
4549				if (nextChild.key != null) keyToNewIndexMap.set(nextChild.key, i);
4550			}
4551			let j;
4552			let patched = 0;
4553			const toBePatched = e2 - s2 + 1;
4554			let moved = false;
4555			let maxNewIndexSoFar = 0;
4556			const newIndexToOldIndexMap = new Array(toBePatched);
4557			for (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0;
4558			for (i = s1; i <= e1; i++) {
4559				const prevChild = c1[i];
4560				if (patched >= toBePatched) {
4561					unmount(prevChild, parentComponent, parentSuspense, true);
4562					continue;
4563				}
4564				let newIndex;
4565				if (prevChild.key != null) newIndex = keyToNewIndexMap.get(prevChild.key);
4566				else for (j = s2; j <= e2; j++) if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
4567					newIndex = j;
4568					break;
4569				}
4570				if (newIndex === void 0) unmount(prevChild, parentComponent, parentSuspense, true);
4571				else {
4572					newIndexToOldIndexMap[newIndex - s2] = i + 1;
4573					if (newIndex >= maxNewIndexSoFar) maxNewIndexSoFar = newIndex;
4574					else moved = true;
4575					patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4576					patched++;
4577				}
4578			}
4579			const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;
4580			j = increasingNewIndexSequence.length - 1;
4581			for (i = toBePatched - 1; i >= 0; i--) {
4582				const nextIndex = s2 + i;
4583				const nextChild = c2[nextIndex];
4584				const anchorVNode = c2[nextIndex + 1];
4585				const anchor = nextIndex + 1 < l2 ? anchorVNode.el || resolveAsyncComponentPlaceholder(anchorVNode) : parentAnchor;
4586				if (newIndexToOldIndexMap[i] === 0) patch(null, nextChild, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
4587				else if (moved) {
4588					if (j < 0 || i !== increasingNewIndexSequence[j]) move(nextChild, container, anchor, 2);
4589					else j--;
4590				}
4591			}
4592		}
4593	};
4594	const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
4595		const { el, type, transition, children, shapeFlag } = vnode;
4596		if (shapeFlag & 6) {
4597			move(vnode.component.subTree, container, anchor, moveType);
4598			return;
4599		}
4600		if (shapeFlag & 128) {
4601			vnode.suspense.move(container, anchor, moveType);
4602			return;
4603		}
4604		if (shapeFlag & 64) {
4605			type.move(vnode, container, anchor, internals);
4606			return;
4607		}
4608		if (type === Fragment) {
4609			hostInsert(el, container, anchor);
4610			for (let i = 0; i < children.length; i++) move(children[i], container, anchor, moveType);
4611			hostInsert(vnode.anchor, container, anchor);
4612			return;
4613		}
4614		if (type === Static) {
4615			moveStaticNode(vnode, container, anchor);
4616			return;
4617		}
4618		if (moveType !== 2 && shapeFlag & 1 && transition) {
4619			if (moveType === 0) {
4620				if (transition.persisted && !el[leaveCbKey]) hostInsert(el, container, anchor);
4621				else {
4622					transition.beforeEnter(el);
4623					hostInsert(el, container, anchor);
4624					queuePostRenderEffect(() => transition.enter(el), parentSuspense);
4625				}
4626			} else {
4627				const { leave, delayLeave, afterLeave } = transition;
4628				const remove2 = () => {
4629					if (vnode.ctx.isUnmounted) hostRemove(el);
4630					else hostInsert(el, container, anchor);
4631				};
4632				const performLeave = () => {
4633					const wasLeaving = el._isLeaving || !!el[leaveCbKey];
4634					if (el._isLeaving) el[leaveCbKey](true);
4635					if (transition.persisted && !wasLeaving) remove2();
4636					else leave(el, () => {
4637						remove2();
4638						afterLeave && afterLeave();
4639					});
4640				};
4641				if (delayLeave) delayLeave(el, remove2, performLeave);
4642				else performLeave();
4643			}
4644		} else hostInsert(el, container, anchor);
4645	};
4646	const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
4647		const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs, cacheIndex, memo } = vnode;
4648		if (patchFlag === -2 || dynamicChildren && dynamicChildren.hasOnce) optimized = false;
4649		if (ref != null) {
4650			pauseTracking();
4651			setRef(ref, null, parentSuspense, vnode, true);
4652			resetTracking();
4653		}
4654		if (cacheIndex != null && (!vnode.ctx || vnode.ctx === parentComponent)) parentComponent.renderCache[cacheIndex] = void 0;
4655		if (shapeFlag & 256) {
4656			parentComponent.ctx.deactivate(vnode);
4657			return;
4658		}
4659		const shouldInvokeDirs = shapeFlag & 1 && dirs;
4660		const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
4661		let vnodeHook;
4662		if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) invokeVNodeHook(vnodeHook, parentComponent, vnode);
4663		if (shapeFlag & 6) unmountComponent(vnode.component, parentSuspense, doRemove);
4664		else {
4665			if (shapeFlag & 128) {
4666				vnode.suspense.unmount(parentSuspense, doRemove);
4667				return;
4668			}
4669			if (shouldInvokeDirs) invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
4670			if (shapeFlag & 64) vnode.type.remove(vnode, parentComponent, parentSuspense, internals, doRemove);
4671			else if (dynamicChildren && !dynamicChildren.hasOnce && (type !== Fragment || patchFlag > 0 && patchFlag & 64)) unmountChildren(dynamicChildren, parentComponent, parentSuspense, false, true);

4672			else if (type === Fragment && patchFlag & 384 || !optimized && shapeFlag & 16) unmountChildren(children, parentComponent, parentSuspense);
4673			if (doRemove) remove(vnode);
4674		}
4675		const shouldInvalidateMemo = memo != null && cacheIndex == null;
4676		if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs || shouldInvalidateMemo) queuePostRenderEffect(() => {
4677			vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
4678			shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
4679			if (shouldInvalidateMemo) vnode.el = null;
4680		}, parentSuspense);
4681	};
4682	const remove = (vnode) => {
4683		const { type, el, anchor, transition } = vnode;
4684		if (type === Fragment) {
4685			removeFragment(el, anchor);
4686			return;
4687		}
4688		if (type === Static) {
4689			removeStaticNode(vnode);
4690			if (transition && !transition.persisted && transition.afterLeave) transition.afterLeave();
4691			return;
4692		}
4693		const performRemove = () => {
4694			hostRemove(el);
4695			if (transition && !transition.persisted && transition.afterLeave) transition.afterLeave();
4696		};
4697		if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
4698			const { leave, delayLeave } = transition;
4699			const performLeave = () => leave(el, performRemove);
4700			if (delayLeave) delayLeave(vnode.el, performRemove, performLeave);
4701			else performLeave();
4702		} else performRemove();
4703	};
4704	const removeFragment = (cur, end) => {
4705		let next;
4706		while (cur !== end) {
4707			next = hostNextSibling(cur);
4708			hostRemove(cur);
4709			cur = next;
4710		}
4711		hostRemove(end);
4712	};
4713	const unmountComponent = (instance, parentSuspense, doRemove) => {
4714		const { bum, scope, job, subTree, um, m, a } = instance;
4715		invalidateMount(m);
4716		invalidateMount(a);
4717		if (bum) invokeArrayFns(bum);
4718		scope.stop();
4719		if (job) {
4720			job.flags |= 8;
4721			unmount(subTree, instance, parentSuspense, doRemove);
4722		} else if (instance.vnode.el && subTree) {
4723			subTree.transition = instance.vnode.transition;
4724			unmount(subTree, instance, parentSuspense, doRemove);
4725		}
4726		if (um) queuePostRenderEffect(um, parentSuspense);
4727		queuePostRenderEffect(() => {
4728			instance.isUnmounted = true;
4729		}, parentSuspense);
4730	};
4731	const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
4732		for (let i = start; i < children.length; i++) unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
4733	};
4734	const getNextHostNode = (vnode) => {
4735		if (vnode.shapeFlag & 6) return getNextHostNode(vnode.component.subTree);
4736		if (vnode.shapeFlag & 128) return vnode.suspense.next();
4737		const el = hostNextSibling(vnode.anchor || vnode.el);
4738		const teleportEnd = el && el[TeleportEndKey];
4739		return teleportEnd ? hostNextSibling(teleportEnd) : el;
4740	};
4741	let isFlushing = false;
4742	const render = (vnode, container, namespace) => {
4743		let instance;
4744		if (vnode == null) {
4745			if (container._vnode) {
4746				unmount(container._vnode, null, null, true);
4747				instance = container._vnode.component;
4748			}
4749		} else patch(container._vnode || null, vnode, container, null, null, null, namespace);
4750		container._vnode = vnode;
4751		if (!isFlushing) {
4752			isFlushing = true;
4753			flushPreFlushCbs(instance);
4754			flushPostFlushCbs();
4755			isFlushing = false;
4756		}
4757	};
4758	const internals = {
4759		p: patch,
4760		um: unmount,
4761		m: move,
4762		r: remove,
4763		mt: mountComponent,
4764		mc: mountChildren,
4765		pc: patchChildren,
4766		pbc: patchBlockChildren,
4767		n: getNextHostNode,
4768		o: options
4769	};
4770	let hydrate;
4771	let hydrateNode;
4772	if (createHydrationFns) [hydrate, hydrateNode] = createHydrationFns(internals);
4773	return {
4774		render,
4775		hydrate,
4776		createApp: createAppAPI(render, hydrate)
4777	};
4778}
4779function resolveChildrenNamespace({ type, props }, currentNamespace) {
4780	return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
4781}
4782function toggleRecurse({ effect, job }, allowed) {
4783	if (allowed) {
4784		effect.flags |= 32;
4785		job.flags |= 4;
4786	} else {
4787		effect.flags &= -33;
4788		job.flags &= -5;
4789	}
4790}
4791function needTransition(parentSuspense, transition) {
4792	return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
4793}
4794function traverseStaticChildren(n1, n2, shallow = false) {
4795	const ch1 = n1.children;
4796	const ch2 = n2.children;
4797	if (isArray(ch1) && isArray(ch2)) for (let i = 0; i < ch1.length; i++) {
4798		const c1 = ch1[i];
4799		let c2 = ch2[i];
4800		if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
4801			if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
4802				c2 = ch2[i] = cloneIfMounted(ch2[i]);
4803				c2.el = c1.el;
4804			}
4805			if (!shallow && c2.patchFlag !== -2) traverseStaticChildren(c1, c2);
4806		}
4807		if (c2.type === Text) {
4808			if (c2.patchFlag === -1) c2 = ch2[i] = cloneIfMounted(c2);
4809			c2.el = c1.el;
4810		}
4811		if (c2.type === Comment && !c2.el) c2.el = c1.el;
4812	}
4813}
4814function getSequence(arr) {
4815	const p = arr.slice();
4816	const result = [0];
4817	let i, j, u, v, c;
4818	const len = arr.length;
4819	for (i = 0; i < len; i++) {
4820		const arrI = arr[i];
4821		if (arrI !== 0) {
4822			j = result[result.length - 1];
4823			if (arr[j] < arrI) {
4824				p[i] = j;
4825				result.push(i);
4826				continue;
4827			}
4828			u = 0;
4829			v = result.length - 1;
4830			while (u < v) {
4831				c = u + v >> 1;
4832				if (arr[result[c]] < arrI) u = c + 1;
4833				else v = c;
4834			}

4835			if (arrI < arr[result[u]]) {
4836				if (u > 0) p[i] = result[u - 1];
4837				result[u] = i;
4838			}
4839		}
4840	}
4841	u = result.length;
4842	v = result[u - 1];
4843	while (u-- > 0) {
4844		result[u] = v;
4845		v = p[v];
4846	}
4847	return result;
4848}
4849function locateNonHydratedAsyncRoot(instance) {
4850	const subComponent = instance.subTree.component;
4851	if (subComponent) {
4852		if (subComponent.asyncDep && !subComponent.asyncResolved) return subComponent;
4853		else return locateNonHydratedAsyncRoot(subComponent);
4854	}
4855}
4856function invalidateMount(hooks) {
4857	if (hooks) for (let i = 0; i < hooks.length; i++) hooks[i].flags |= 8;
4858}
4859function resolveAsyncComponentPlaceholder(anchorVnode) {
4860	if (anchorVnode.placeholder) return anchorVnode.placeholder;
4861	const instance = anchorVnode.component;
4862	if (instance) return resolveAsyncComponentPlaceholder(instance.subTree);
4863	return null;
4864}
4865var isSuspense = (type) => type.__isSuspense;
4866function queueEffectWithSuspense(fn, suspense) {
4867	if (suspense && suspense.pendingBranch) {
4868		if (isArray(fn)) suspense.effects.push(...fn);
4869		else suspense.effects.push(fn);
4870	} else queuePostFlushCb(fn);
4871}
4872var Fragment = /* @__PURE__ */ Symbol.for("v-fgt");
4873var Text = /* @__PURE__ */ Symbol.for("v-txt");
4874var Comment = /* @__PURE__ */ Symbol.for("v-cmt");
4875var Static = /* @__PURE__ */ Symbol.for("v-stc");
4876var blockStack = [];
4877var currentBlock = null;
4878function openBlock(disableTracking = false) {
4879	blockStack.push(currentBlock = disableTracking ? null : []);
4880}
4881function closeBlock() {
4882	blockStack.pop();
4883	currentBlock = blockStack[blockStack.length - 1] || null;
4884}
4885var isBlockTreeEnabled = 1;
4886function setBlockTracking(value, inVOnce = false) {
4887	isBlockTreeEnabled += value;
4888	if (value < 0 && currentBlock && inVOnce) currentBlock.hasOnce = true;
4889}
4890function setupBlock(vnode) {
4891	vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
4892	closeBlock();
4893	if (isBlockTreeEnabled > 0 && currentBlock) currentBlock.push(vnode);
4894	return vnode;
4895}
4896function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
4897	return setupBlock(createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, true));
4898}
4899function createBlock(type, props, children, patchFlag, dynamicProps) {
4900	return setupBlock(createVNode(type, props, children, patchFlag, dynamicProps, true));
4901}
4902function isVNode(value) {
4903	return value ? value.__v_isVNode === true : false;
4904}
4905function isSameVNodeType(n1, n2) {
4906	return n1.type === n2.type && n1.key === n2.key;
4907}
4908var normalizeKey = ({ key }) => key != null ? key : null;
4909var normalizeRef = ({ ref, ref_key, ref_for }) => {
4910	if (typeof ref === "number") ref = "" + ref;

4911	return ref != null ? isString(ref) || /* @__PURE__ */ isRef(ref) || isFunction(ref) ? {
4912		i: currentRenderingInstance,
4913		r: ref,
4914		k: ref_key,
4915		f: !!ref_for
4916	} : ref : null;
4917};
4918function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
4919	const vnode = {
4920		__v_isVNode: true,
4921		__v_skip: true,
4922		type,
4923		props,
4924		key: props && normalizeKey(props),
4925		ref: props && normalizeRef(props),
4926		scopeId: currentScopeId,
4927		slotScopeIds: null,
4928		children,
4929		component: null,
4930		suspense: null,
4931		ssContent: null,
4932		ssFallback: null,
4933		dirs: null,
4934		transition: null,
4935		el: null,
4936		anchor: null,
4937		target: null,
4938		targetStart: null,
4939		targetAnchor: null,
4940		staticCount: 0,
4941		shapeFlag,
4942		patchFlag,
4943		dynamicProps,
4944		dynamicChildren: null,
4945		appContext: null,
4946		ctx: currentRenderingInstance
4947	};
4948	if (needFullChildrenNormalization) {
4949		normalizeChildren(vnode, children);
4950		if (shapeFlag & 128) type.normalize(vnode);
4951	} else if (children) vnode.shapeFlag |= isString(children) ? 8 : 16;
4952	if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock && (vnode.patchFlag > 0 || shapeFlag & 6) && vnode.patchFlag !== 32) currentBlock.push(vnode);
4953	return vnode;
4954}
4955var createVNode = _createVNode;
4956function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
4957	if (!type || type === NULL_DYNAMIC_COMPONENT) type = Comment;
4958	if (isVNode(type)) {
4959		const cloned = cloneVNode(type, props, true);
4960		if (children) normalizeChildren(cloned, children);
4961		if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
4962			if (cloned.shapeFlag & 6) currentBlock[currentBlock.indexOf(type)] = cloned;
4963			else currentBlock.push(cloned);
4964		}
4965		cloned.patchFlag = -2;
4966		return cloned;
4967	}
4968	if (isClassComponent(type)) type = type.__vccOpts;
4969	if (props) {
4970		props = guardReactiveProps(props);
4971		let { class: klass, style } = props;
4972		if (klass && !isString(klass)) props.class = normalizeClass(klass);
4973		if (isObject$2(style)) {
4974			if (/* @__PURE__ */ isProxy(style) && !isArray(style)) style = extend({}, style);
4975			props.style = normalizeStyle(style);
4976		}
4977	}
4978	const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject$2(type) ? 4 : isFunction(type) ? 2 : 0;
4979	return createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, isBlockNode, true);
4980}
4981function guardReactiveProps(props) {
4982	if (!props) return null;
4983	return /* @__PURE__ */ isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
4984}
4985function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
4986	const { props, ref, patchFlag, children, transition } = vnode;
4987	const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
4988	const cloned = {
4989		__v_isVNode: true,
4990		__v_skip: true,
4991		type: vnode.type,
4992		props: mergedProps,
4993		key: mergedProps && normalizeKey(mergedProps),
4994		ref: extraProps && extraProps.ref ? mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref,
4995		scopeId: vnode.scopeId,
4996		slotScopeIds: vnode.slotScopeIds,
4997		children,
4998		target: vnode.target,
4999		targetStart: vnode.targetStart,
5000		targetAnchor: vnode.targetAnchor,
5001		staticCount: vnode.staticCount,
5002		shapeFlag: vnode.shapeFlag,
5003		patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
5004		dynamicProps: vnode.dynamicProps,
5005		dynamicChildren: vnode.dynamicChildren,
5006		appContext: vnode.appContext,
5007		dirs: vnode.dirs,
5008		transition,
5009		component: vnode.component,
5010		suspense: vnode.suspense,
5011		ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
5012		ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
5013		placeholder: vnode.placeholder,
5014		el: vnode.el,
5015		anchor: vnode.anchor,
5016		ctx: vnode.ctx,
5017		ce: vnode.ce,
5018		cacheIndex: vnode.cacheIndex
5019	};
5020	if (transition && cloneTransition) setTransitionHooks(cloned, transition.clone(cloned));
5021	return cloned;
5022}
5023function createTextVNode(text = " ", flag = 0) {
5024	return createVNode(Text, null, text, flag);
5025}
5026function createStaticVNode(content, numberOfNodes) {
5027	const vnode = createVNode(Static, null, content);
5028	vnode.staticCount = numberOfNodes;
5029	return vnode;
5030}
5031function createCommentVNode(text = "", asBlock = false) {
5032	return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
5033}
5034function normalizeVNode(child) {
5035	if (child == null || typeof child === "boolean") return createVNode(Comment);
5036	else if (isArray(child)) return createVNode(Fragment, null, child.slice());
5037	else if (isVNode(child)) return cloneIfMounted(child);
5038	else return createVNode(Text, null, String(child));
5039}
5040function cloneIfMounted(child) {
5041	return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
5042}
5043function normalizeChildren(vnode, children) {
5044	let type = 0;
5045	const { shapeFlag } = vnode;
5046	if (children == null) children = null;
5047	else if (isArray(children)) type = 16;
5048	else if (typeof children === "object") {
5049		if (shapeFlag & 65) {
5050			const slot = children.default;
5051			if (slot) {
5052				slot._c && (slot._d = false);
5053				normalizeChildren(vnode, slot());
5054				slot._c && (slot._d = true);
5055			}
5056			return;
5057		} else {
5058			type = 32;
5059			const slotFlag = children._;
5060			if (!slotFlag && !isInternalObject(children)) children._ctx = currentRenderingInstance;
5061			else if (slotFlag === 3 && currentRenderingInstance) {
5062				if (currentRenderingInstance.slots._ === 1) children._ = 1;
5063				else {
5064					children._ = 2;
5065					vnode.patchFlag |= 1024;
5066				}
5067			}
5068		}
5069	} else if (isFunction(children)) {
5070		if (shapeFlag & 65) {
5071			normalizeChildren(vnode, { default: children });
5072			return;
5073		}
5074		children = {
5075			default: children,
5076			_ctx: currentRenderingInstance
5077		};
5078		type = 32;
5079	} else {
5080		children = String(children);
5081		if (shapeFlag & 64) {
5082			type = 16;
5083			children = [createTextVNode(children)];
5084		} else type = 8;
5085	}
5086	vnode.children = children;
5087	vnode.shapeFlag |= type;
5088}
5089function mergeProps(...args) {
5090	const ret = {};
5091	for (let i = 0; i < args.length; i++) {
5092		const toMerge = args[i];
5093		for (const key in toMerge) if (key === "class") {
5094			if (ret.class !== toMerge.class) ret.class = normalizeClass([ret.class, toMerge.class]);
5095		} else if (key === "style") ret.style = normalizeStyle([ret.style, toMerge.

5095style]);
5096		else if (isOn(key)) {
5097			const existing = ret[key];
5098			const incoming = toMerge[key];
5099			if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) ret[key] = existing ? [].concat(existing, incoming) : incoming;
5100			else if (incoming == null && existing == null && !isModelListener(key)) ret[key] = incoming;
5101		} else if (key !== "") ret[key] = toMerge[key];
5102	}
5103	return ret;
5104}
5105function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
5106	callWithAsyncErrorHandling(hook, instance, 7, [vnode, prevVNode]);
5107}
5108var emptyAppContext = createAppContext();
5109var uid = 0;
5110function createComponentInstance(vnode, parent, suspense) {
5111	const type = vnode.type;
5112	const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
5113	const instance = {
5114		uid: uid++,
5115		vnode,
5116		type,
5117		parent,
5118		appContext,
5119		root: null,
5120		next: null,
5121		subTree: null,
5122		effect: null,
5123		update: null,
5124		job: null,
5125		scope: new EffectScope(true),
5126		render: null,
5127		proxy: null,
5128		exposed: null,
5129		exposeProxy: null,
5130		withProxy: null,
5131		provides: parent ? parent.provides : Object.create(appContext.provides),
5132		ids: parent ? parent.ids : [
5133			"",
5134			0,
5135			0
5136		],
5137		accessCache: null,
5138		renderCache: [],
5139		components: null,
5140		directives: null,
5141		propsOptions: normalizePropsOptions(type, appContext),
5142		emitsOptions: normalizeEmitsOptions(type, appContext),
5143		emit: null,
5144		emitted: null,
5145		propsDefaults: EMPTY_OBJ,
5146		inheritAttrs: type.inheritAttrs,
5147		ctx: EMPTY_OBJ,
5148		data: EMPTY_OBJ,
5149		props: EMPTY_OBJ,
5150		attrs: EMPTY_OBJ,
5151		slots: EMPTY_OBJ,
5152		refs: EMPTY_OBJ,
5153		setupState: EMPTY_OBJ,
5154		setupContext: null,
5155		suspense,
5156		suspenseId: suspense ? suspense.pendingId : 0,
5157		asyncDep: null,
5158		asyncResolved: false,
5159		isMounted: false,
5160		isUnmounted: false,
5161		isDeactivated: false,
5162		bc: null,
5163		c: null,
5164		bm: null,
5165		m: null,
5166		bu: null,
5167		u: null,
5168		um: null,
5169		bum: null,
5170		da: null,
5171		a: null,
5172		rtg: null,
5173		rtc: null,
5174		ec: null,
5175		sp: null
5176	};
5177	instance.ctx = { _: instance };
5178	instance.root = parent ? parent.root : instance;
5179	instance.emit = emit.bind(null, instance);
5180	if (vnode.ce) vnode.ce(instance);
5181	return instance;
5182}
5183var currentInstance = null;
5184var getCurrentInstance = () => currentInstance || currentRenderingInstance;
5185var internalSetCurrentInstance;
5186var setInSSRSetupState;
5187{
5188	const g = getGlobalThis();
5189	const registerGlobalSetter = (key, setter) => {
5190		let setters;
5191		if (!(setters = g[key])) setters = g[key] = [];
5192		setters.push(setter);
5193		return (v) => {
5194			if (setters.length > 1) setters.forEach((set) => set(v));
5195			else setters[0](v);
5196		};
5197	};
5198	internalSetCurrentInstance = registerGlobalSetter(`__VUE_INSTANCE_SETTERS__`, (v) => currentInstance = v);
5199	setInSSRSetupState = registerGlobalSetter(`__VUE_SSR_SETTERS__`, (v) => isInSSRComponentSetup = v);
5200}
5201var setCurrentInstance = (instance) => {
5202	const prev = currentInstance;
5203	internalSetCurrentInstance(instance);
5204	instance.scope.on();
5205	return () => {
5206		instance.scope.off();
5207		internalSetCurrentInstance(prev);
5208	};
5209};
5210var unsetCurrentInstance = () => {
5211	currentInstance && currentInstance.scope.off();
5212	internalSetCurrentInstance(null);
5213};
5214function isStatefulComponent(instance) {
5215	return instance.vnode.shapeFlag & 4;
5216}
5217var isInSSRComponentSetup = false;
5218function setupComponent(instance, isSSR = false, optimized = false) {
5219	isSSR && setInSSRSetupState(isSSR);
5220	const { props, children } = instance.vnode;
5221	const isStateful = isStatefulComponent(instance);
5222	initProps(instance, props, isStateful, isSSR);
5223	initSlots(instance, children, optimized || isSSR);
5224	const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
5225	isSSR && setInSSRSetupState(false);
5226	return setupResult;
5227}
5228function setupStatefulComponent(instance, isSSR) {
5229	const Component = instance.type;
5230	instance.accessCache = /* @__PURE__ */ Object.create(null);
5231	instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
5232	const { setup } = Component;
5233	if (setup) {
5234		pauseTracking();
5235		const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
5236		const reset = setCurrentInstance(instance);
5237		const setupResult = callWithErrorHandling(setup, instance, 0, [instance.props, setupContext]);
5238		const isAsyncSetup = isPromise(setupResult);
5239		resetTracking();
5240		reset();
5241		if ((isAsyncSetup || instance.sp) && !isAsyncWrapper(instance)) markAsyncBoundary(instance);
5242		if (isAsyncSetup) {
5243			setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
5244			if (isSSR) return setupResult.then((resolvedResult) => {
5245				setInSSRSetupState(true);

5246				try {
5247					handleSetupResult(instance, resolvedResult, isSSR);
5248				} finally {
5249					setInSSRSetupState(false);
5250				}
5251			}).catch((e) => {
5252				handleError(e, instance, 0);
5253			});
5254			else instance.asyncDep = setupResult;
5255		} else handleSetupResult(instance, setupResult, isSSR);
5256	} else finishComponentSetup(instance, isSSR);
5257}
5258function handleSetupResult(instance, setupResult, isSSR) {
5259	if (isFunction(setupResult)) {
5260		if (instance.type.__ssrInlineRender) instance.ssrRender = setupResult;
5261		else instance.render = setupResult;
5262	} else if (isObject$2(setupResult)) instance.setupState = proxyRefs(setupResult);
5263	finishComponentSetup(instance, isSSR);
5264}
5265function finishComponentSetup(instance, isSSR, skipOptions) {
5266	const Component = instance.type;
5267	if (!instance.render) instance.render = Component.render || NOOP;
5268	{
5269		const reset = setCurrentInstance(instance);
5270		pauseTracking();
5271		try {
5272			applyOptions(instance);
5273		} finally {
5274			resetTracking();
5275			reset();
5276		}
5277	}
5278}
5279var attrsProxyHandlers = { get(target, key) {
5280	track(target, "get", "");
5281	return target[key];
5282} };
5283function createSetupContext(instance) {
5284	const expose = (exposed) => {
5285		instance.exposed = exposed || {};
5286	};
5287	return {
5288		attrs: new Proxy(instance.attrs, attrsProxyHandlers),
5289		slots: instance.slots,
5290		emit: instance.emit,
5291		expose
5292	};
5293}
5294function getComponentPublicInstance(instance) {
5295	if (instance.exposed) return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
5296		get(target, key) {
5297			if (key in target) return target[key];
5298			else if (key in publicPropertiesMap) return publicPropertiesMap[key](instance);
5299		},
5300		has(target, key) {
5301			return key in target || key in publicPropertiesMap;
5302		}
5303	}));
5304	else return instance.proxy;
5305}
5306var classifyRE = /(?:^|[-_])\w/g;
5307var classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
5308function getComponentName(Component, includeInferred = true) {
5309	return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
5310}
5311function formatComponentName(instance, Component, isRoot = false) {
5312	let name = getComponentName(Component);
5313	if (!name && Component.__file) {
5314		const match = Component.__file.match(/([^/\\]+)\.\w+$/);
5315		if (match) name = match[1];
5316	}
5317	if (!name && instance) {
5318		const inferFromRegistry = (registry) => {
5319			for (const key in registry) if (registry[key] === Component) return key;
5320		};
5321		name = inferFromRegistry(instance.components) || instance.parent && inferFromRegistry(instance.parent.type.components) || inferFromRegistry(instance.appContext.components);
5322	}
5323	return name ? classify(name) : isRoot ? `App` : `Anonymous`;
5324}
5325function isClassComponent(value) {
5326	return isFunction(value) && "__vccOpts" in value;
5327}
5328var computed = (getterOrOptions, debugOptions) => {
5329	return /* @__PURE__ */ computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
5330};
5331function h(type, propsOrChildren, children) {
5332	try {
5333		setBlockTracking(-1);
5334		const l = arguments.length;
5335		if (l === 2) {
5336			if (isObject$2(propsOrChildren) && !isArray(propsOrChildren)) {
5337				if (isVNode(propsOrChildren)) return createVNode(type, null, [propsOrChildren]);
5338				return createVNode(type, propsOrChildren);
5339			} else return createVNode(type, null, propsOrChildren);
5340		} else {
5341			if (l > 3) children = Array.prototype.slice.call(arguments, 2);
5342			else if (l === 3 && isVNode(children)) children = [children];
5343			return createVNode(type, propsOrChildren, children);
5344		}
5345	} finally {
5346		setBlockTracking(1);
5347	}
5348}
5349var version = "3.5.43";
5350//#endregion
5351//#region node_modules/.pnpm/@[email protected]/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js
5352/**
5353* @vue/runtime-dom v3.5.43
5354* (c) 2018-present Yuxi (Evan) You and Vue contributors
5355* @license MIT

5356**/
5357var policy = void 0;
5358var tt = typeof window !== "undefined" && window.trustedTypes;
5359if (tt) try {
5360	policy = /* @__PURE__ */ tt.createPolicy("vue", { createHTML: (val) => val });
5361} catch (e) {}
5362var unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
5363var svgNS = "http://www.w3.org/2000/svg";
5364var mathmlNS = "http://www.w3.org/1998/Math/MathML";
5365var doc = typeof document !== "undefined" ? document : null;
5366var templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
5367var nodeOps = {
5368	insert: (child, parent, anchor) => {
5369		parent.insertBefore(child, anchor || null);
5370	},
5371	remove: (child) => {
5372		const parent = child.parentNode;
5373		if (parent) parent.removeChild(child);
5374	},
5375	createElement: (tag, namespace, is, props) => {
5376		const el = namespace === "svg" ? doc.createElementNS(svgNS, tag) : namespace === "mathml" ? doc.createElementNS(mathmlNS, tag) : is ? doc.createElement(tag, { is }) : doc.createElement(tag);
5377		if (tag === "select" && props && props.multiple != null) el.setAttribute("multiple", props.multiple);
5378		return el;
5379	},
5380	createText: (text) => doc.createTextNode(text),
5381	createComment: (text) => doc.createComment(text),
5382	setText: (node, text) => {
5383		node.nodeValue = text;
5384	},
5385	setElementText: (el, text) => {
5386		el.textContent = text;
5387	},
5388	parentNode: (node) => node.parentNode,
5389	nextSibling: (node) => node.nextSibling,
5390	querySelector: (selector) => doc.querySelector(selector),
5391	setScopeId(el, id) {
5392		el.setAttribute(id, "");
5393	},
5394	insertStaticContent(content, parent, anchor, namespace, start, end) {
5395		const before = anchor ? anchor.previousSibling : parent.lastChild;
5396		if (start && (start === end || start.nextSibling)) while (true) {
5397			parent.insertBefore(start.cloneNode(true), anchor);
5398			if (start === end || !(start = start.nextSibling)) break;
5399		}
5400		else {
5401			templateContainer.innerHTML = unsafeToTrustedHTML(namespace === "svg" ? `<svg>${content}</svg>` : namespace === "mathml" ? `<math>${content}</math>` : content);
5402			const template = templateContainer.content;
5403			if (namespace === "svg" || namespace === "mathml") {
5404				const wrapper = template.firstChild;
5405				while (wrapper.firstChild) template.appendChild(wrapper.firstChild);
5406				template.removeChild(wrapper);
5407			}
5408			parent.insertBefore(template, anchor);
5409		}
5410		return [before ? before.nextSibling : parent.firstChild, anchor ? anchor.previousSibling : parent.lastChild];
5411	}
5412};
5413var TRANSITION = "transition";
5414var ANIMATION = "animation";
5415var vtcKey = /* @__PURE__ */ Symbol("_vtc");
5416var DOMTransitionPropsValidators = {
5417	name: String,
5418	type: String,
5419	css: {
5420		type: Boolean,
5421		default: true
5422	},
5423	duration: [
5424		String,
5425		Number,
5426		Object
5427	],
5428	enterFromClass: String,
5429	enterActiveClass: String,
5430	enterToClass: String,
5431	appearFromClass: String,
5432	appearActiveClass: String,
5433	appearToClass: String,
5434	leaveFromClass: String,
5435	leaveActiveClass: String,
5436	leaveToClass: String
5437};
5438var TransitionPropsValidators = /* @__PURE__ */ extend({}, BaseTransitionPropsValidators, DOMTransitionPropsValidators);
5439var decorate$1 = (t) => {
5440	t.displayName = "Transition";
5441	t.props = TransitionPropsValidators;
5442	return t;
5443};
5444var Transition = /* @__PURE__ */ decorate$1((props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots));
5445var callHook = (hook, args = []) => {
5446	if (isArray(hook)) hook.forEach((h2) => h2(...args));
5447	else if (hook) hook(...args);
5448};
5449var hasExplicitCallback = (hook) => {
5450	return hook ? isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
5451};
5452function resolveTransitionProps(rawProps) {
5453	const baseProps = {};
5454	for (const key in rawProps) if (!(key in DOMTransitionPropsValidators)) baseProps[key] = rawProps[key];
5455	if (rawProps.css === false) return baseProps;
5456	const { name = "v", type, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;
5457	const durations = normalizeDuration(duration);
5458	const enterDuration = durations && durations[0];
5459	const leaveDuration = durations && durations[1];
5460	const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps;
5461	const finishEnter = (el, isAppear, done, isCancelled) => {
5462		el._enterCancelled = isCancelled;
5463		removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
5464		removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
5465		done && done();
5466	};
5467	const finishLeave = (el, done) => {
5468		el._isLeaving = false;

5469		removeTransitionClass(el, leaveFromClass);
5470		removeTransitionClass(el, leaveToClass);
5471		removeTransitionClass(el, leaveActiveClass);
5472		done && done();
5473	};
5474	const makeEnterHook = (isAppear) => {
5475		return (el, done) => {
5476			const hook = isAppear ? onAppear : onEnter;
5477			const resolve = () => finishEnter(el, isAppear, done);
5478			callHook(hook, [el, resolve]);
5479			nextFrame(() => {
5480				removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
5481				addTransitionClass(el, isAppear ? appearToClass : enterToClass);
5482				if (!hasExplicitCallback(hook)) whenTransitionEnds(el, type, enterDuration, resolve);
5483			});
5484		};
5485	};
5486	return extend(baseProps, {
5487		onBeforeEnter(el) {
5488			callHook(onBeforeEnter, [el]);
5489			addTransitionClass(el, enterFromClass);
5490			addTransitionClass(el, enterActiveClass);
5491		},
5492		onBeforeAppear(el) {
5493			callHook(onBeforeAppear, [el]);
5494			addTransitionClass(el, appearFromClass);
5495			addTransitionClass(el, appearActiveClass);
5496		},
5497		onEnter: makeEnterHook(false),
5498		onAppear: makeEnterHook(true),
5499		onLeave(el, done) {
5500			el._isLeaving = true;
5501			const resolve = () => finishLeave(el, done);
5502			addTransitionClass(el, leaveFromClass);
5503			if (!el._enterCancelled) {
5504				forceReflow(el);
5505				addTransitionClass(el, leaveActiveClass);
5506			} else {
5507				addTransitionClass(el, leaveActiveClass);
5508				forceReflow(el);
5509			}
5510			nextFrame(() => {
5511				if (!el._isLeaving) return;
5512				removeTransitionClass(el, leaveFromClass);
5513				addTransitionClass(el, leaveToClass);
5514				if (!hasExplicitCallback(onLeave)) whenTransitionEnds(el, type, leaveDuration, resolve);
5515			});
5516			callHook(onLeave, [el, resolve]);
5517		},
5518		onEnterCancelled(el) {
5519			finishEnter(el, false, void 0, true);
5520			callHook(onEnterCancelled, [el]);
5521		},
5522		onAppearCancelled(el) {
5523			finishEnter(el, true, void 0, true);
5524			callHook(onAppearCancelled, [el]);
5525		},
5526		onLeaveCancelled(el) {
5527			finishLeave(el);
5528			callHook(onLeaveCancelled, [el]);
5529		}
5530	});
5531}
5532function normalizeDuration(duration) {
5533	if (duration == null) return null;
5534	else if (isObject$2(duration)) return [NumberOf(duration.enter), NumberOf(duration.leave)];
5535	else {
5536		const n = NumberOf(duration);
5537		return [n, n];
5538	}
5539}
5540function NumberOf(val) {
5541	return toNumber(val);
5542}
5543function addTransitionClass(el, cls) {
5544	cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
5545	(el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
5546}
5547function removeTransitionClass(el, cls) {
5548	cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
5549	const _vtc = el[vtcKey];
5550	if (_vtc) {
5551		_vtc.delete(cls);
5552		if (!_vtc.size) el[vtcKey] = void 0;
5553	}
5554}
5555function nextFrame(cb) {
5556	requestAnimationFrame(() => {
5557		requestAnimationFrame(cb);
5558	});
5559}
5560var endId = 0;
5561function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {
5562	const id = el._endId = ++endId;
5563	const resolveIfNotStale = () => {
5564		if (id === el._endId) resolve();
5565	};
5566	if (explicitTimeout != null) return setTimeout(resolveIfNotStale, explicitTimeout);
5567	const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
5568	if (!type) return resolve();
5569	const endEvent = type + "end";
5570	let ended = 0;
5571	const end = () => {
5572		el.removeEventListener(endEvent, onEnd);
5573		resolveIfNotStale();
5574	};
5575	const onEnd = (e) => {
5576		if (e.target === el && ++ended >= propCount) end();
5577	};
5578	setTimeout(() => {
5579		if (ended < propCount) end();
5580	}, timeout + 1);
5581	el.addEventListener(endEvent, onEnd);
5582}
5583function getTransitionInfo(el, expectedType) {
5584	const styles = window.getComputedStyle(el);
5585	const getStyleProperties = (key) => (styles[key] || "").split(", ");
5586	const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
5587	const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
5588	const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
5589	const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
5590	const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
5591	const animationTimeout = getTimeout(animationDelays, animationDurations);
5592	let type = null;
5593	let timeout = 0;
5594	let propCount = 0;
5595	if (expectedType === TRANSITION) {
5596		if (transitionTimeout > 0) {
5597			type = TRANSITION;
5598			timeout = transitionTimeout;
5599			propCount = transitionDurations.length;
5600		}
5601	} else if (expectedType === ANIMATION) {
5602		if (animationTimeout > 0) {
5603			type = ANIMATION;
5604			timeout = animationTimeout;
5605			propCount = animationDurations.length;
5606		}
5607	} else {
5608		timeout = Math.max(transitionTimeout, animationTimeout);
5609		type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
5610		propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
5611	}
5612	const hasTransform = type === TRANSITION && /\b(?:transform|all)(?:,|$)/.test(getStyleProperties(`${TRANSITION}Property`).toString());
5613	return {
5614		type,
5615		timeout,
5616		propCount,
5617		hasTransform
5618	};
5619}
5620function getTimeout(delays, durations) {
5621	while (delays.length < durations.length) delays = delays.concat(delays);
5622	return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
5623}
5624function toMs(s) {
5625	if (s === "auto") return 0;
5626	return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
5627}
5628function forceReflow(el) {
5629	return (el ? el.ownerDocument : document).body.offsetHeight;
5630}
5631function patchClass(el, value, isSVG) {
5632	const transitionClasses = el[vtcKey];
5633	if (transitionClasses) value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
5634	if (value == null) el.removeAttribute("class");
5635	else if (isSVG) el.setAttribute("class", value);
5636	else el.className = value;
5637}
5638var vShowOriginalDisplay = /* @__PURE__ */ Symbol("_vod");
5639var vShowHidden = /* @__PURE__ */ Symbol("_vsh");
5640var vShow = {
5641	name: "show",
5642	beforeMount(el, { value }, { transition }) {
5643		el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
5644		if (transition && value) transition.beforeEnter(el);
5645		else setDisplay(el, value);
5646	},
5647	mounted(el, { value }, { transition }) {
5648		if (transition && value) transition.enter(el);
5649	},
5650	updated(el, { value, oldValue }, { transition }) {
5651		if (!value === !oldValue) return;
5652		if (transition) {
5653			if (value) {
5654				transition.beforeEnter(el);
5655				setDisplay(el, true);
5656				transition.enter(el);
5657			} else transition.leave(el, () => {
5658				setDisplay(el, false);
5659			});
5660		} else setDisplay(el, value);
5661	},
5662	beforeUnmount(el, { value }) {
5663		setDisplay(el, value);
5664	}
5665};
5666function setDisplay(el, value) {
5667	el.style.display = value ? el[vShowOriginalDisplay] : "none";
5668	el[vShowHidden] = !value;
5669}
5670var CSS_VAR_TEXT = /* @__PURE__ */ Symbol("");
5671var displayRE = /(?:^|;)\s*display\s*:/;
5672function patchStyle(el, prev, next) {
5673	const style = el.style;
5674	const isCssString = isString(next);
5675	let hasControlledDisplay = false;

5676	if (next && !isCssString) {
5677		if (prev) {
5678			if (!isString(prev)) {
5679				for (const key in prev) if (next[key] == null) setStyle(style, key, "");
5680			} else for (const prevStyle of prev.split(";")) {
5681				const key = prevStyle.slice(0, prevStyle.indexOf(":")).trim();
5682				if (next[key] == null) setStyle(style, key, "");
5683			}
5684		}
5685		for (const key in next) {
5686			if (key === "display") hasControlledDisplay = true;
5687			const value = next[key];
5688			if (value != null) {
5689				if (!shouldPreserveTextareaResizeStyle(el, key, !isString(prev) && prev ? prev[key] : void 0, value)) setStyle(style, key, value);
5690			} else setStyle(style, key, "");
5691		}
5692	} else if (isCssString) {
5693		if (prev !== next) {
5694			const cssVarText = style[CSS_VAR_TEXT];
5695			if (cssVarText) next += ";" + cssVarText;
5696			style.cssText = next;
5697			hasControlledDisplay = displayRE.test(next);
5698		}
5699	} else if (prev) el.removeAttribute("style");
5700	if (vShowOriginalDisplay in el) {
5701		el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : "";
5702		if (el[vShowHidden]) style.display = "none";
5703	}
5704}
5705var importantRE = /\s*!important$/;
5706function setStyle(style, name, val) {
5707	if (isArray(val)) val.forEach((v) => setStyle(style, name, v));
5708	else {
5709		if (val == null) val = "";
5710		if (name.startsWith("--")) {
5711			if (importantRE.test(val)) style.setProperty(name, val.replace(importantRE, ""), "important");
5712			else style.setProperty(name, val);
5713		} else {
5714			const prefixed = autoPrefix(style, name);
5715			if (importantRE.test(val)) style.setProperty(hyphenate$1(prefixed), val.replace(importantRE, ""), "important");
5716			else style[prefixed] = val;
5717		}
5718	}
5719}
5720var prefixes = [
5721	"Webkit",
5722	"Moz",
5723	"ms"
5724];
5725var prefixCache = {};
5726function autoPrefix(style, rawName) {
5727	const cached = prefixCache[rawName];
5728	if (cached) return cached;
5729	let name = camelize$1(rawName);
5730	if (name !== "filter" && name in style) return prefixCache[rawName] = name;
5731	name = capitalize(name);
5732	for (let i = 0; i < prefixes.length; i++) {
5733		const prefixed = prefixes[i] + name;
5734		if (prefixed in style) return prefixCache[rawName] = prefixed;
5735	}
5736	return rawName;
5737}
5738function shouldPreserveTextareaResizeStyle(el, key, prev, next) {
5739	return el.tagName === "TEXTAREA" && (key === "width" || key === "height") && isString(next) && prev === next;
5740}
5741var xlinkNS = "http://www.w3.org/1999/xlink";
5742function patchAttr(el, key, value, isSVG, instance, isBoolean = isSpecialBooleanAttr(key)) {
5743	if (isSVG && key.startsWith("xlink:")) {
5744		if (value == null) el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
5745		else el.setAttributeNS(xlinkNS, key, value);
5746	} else if (value == null || isBoolean && !includeBooleanAttr(value)) el.removeAttribute(key);
5747	else el.setAttribute(key, isBoolean ? "" : isSymbol(value) ? String(value) : value);
5748}
5749function patchDOMProp(el, key, value, parentComponent, attrName) {
5750	if (key === "innerHTML" || key === "textContent") {
5751		if (value != null) el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value;
5752		return;
5753	}
5754	const tag = el.tagName;
5755	if (key === "value" && tag !== "PROGRESS" && !tag.includes("-")) {
5756		const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value;
5757		const newValue = value == null ? el.type === "checkbox" ? "on" : "" : String(value);
5758		if (oldValue !== newValue || !("_value" in el)) el.value = newValue;
5759		if (value == null) el.removeAttribute(key);
5760		el._value = value;
5761		return;
5762	}
5763	let needRemove = false;
5764	if (value === "" || value == null) {
5765		const type = typeof el[key];
5766		if (type === "boolean") value = includeBooleanAttr(value);
5767		else if (value == null && type === "string") {
5768			value = "";
5769			needRemove = true;
5770		} else if (type === "number") {
5771			value = 0;
5772			needRemove = true;
5773		}
5774	}
5775	try {
5776		el[key] = value;
5777	} catch (e) {}
5778	needRemove && el.removeAttribute(attrName || key);
5779}
5780function addEventListener(el, event, handler, options) {
5781	el.addEventListener(event, handler, options);
5782}
5783function removeEventListener(el, event, handler, options) {
5784	el.removeEventListener(event, handler, options);
5785}
5786var veiKey = /* @__PURE__ */ Symbol("_vei");
5787function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
5788	const invokers = el[veiKey] || (el[veiKey] = {});
5789	const existingInvoker = invokers[rawName];

5790	if (nextValue && existingInvoker) existingInvoker.value = nextValue;
5791	else {
5792		const [name, options] = parseName(rawName);
5793		if (nextValue) addEventListener(el, name, invokers[rawName] = createInvoker(nextValue, instance), options);
5794		else if (existingInvoker) {
5795			removeEventListener(el, name, existingInvoker, options);
5796			invokers[rawName] = void 0;
5797		}
5798	}
5799}
5800var optionsModifierRE = /(Once|Passive|Capture)$/;
5801var optionsModifierEventRE = /^on:?(?:Once|Passive|Capture)$/;
5802function parseName(name) {
5803	let options;
5804	let m;
5805	while ((m = name.match(optionsModifierRE)) && !optionsModifierEventRE.test(name)) {
5806		if (!options) options = {};
5807		name = name.slice(0, name.length - m[1].length);
5808		options[m[1].toLowerCase()] = true;
5809	}
5810	return [name[2] === ":" ? name.slice(3) : hyphenate$1(name.slice(2)), options];
5811}
5812var cachedNow = 0;
5813var p = /* @__PURE__ */ Promise.resolve();
5814var getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
5815function createInvoker(initialValue, instance) {
5816	const invoker = (e) => {
5817		if (!e._vts) e._vts = Date.now();
5818		else if (e._vts <= invoker.attached) return;
5819		const value = invoker.value;
5820		if (isArray(value)) {
5821			const originalStop = e.stopImmediatePropagation;
5822			e.stopImmediatePropagation = () => {
5823				originalStop.call(e);
5824				e._stopped = true;
5825			};
5826			const handlers = value.slice();
5827			const args = [e];
5828			for (let i = 0; i < handlers.length; i++) {
5829				if (e._stopped) break;
5830				const handler = handlers[i];
5831				if (handler) callWithAsyncErrorHandling(handler, instance, 5, args);
5832			}
5833		} else callWithAsyncErrorHandling(value, instance, 5, [e]);
5834	};
5835	invoker.value = initialValue;
5836	invoker.attached = getNow();
5837	return invoker;
5838}
5839var isNativeOn = (key) =>

5839 key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
5840var patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => {
5841	const isSVG = namespace === "svg";
5842	if (key === "class") patchClass(el, nextValue, isSVG);
5843	else if (key === "style") patchStyle(el, prevValue, nextValue);
5844	else if (isOn(key)) {
5845		if (!isModelListener(key)) patchEvent(el, key, prevValue, nextValue, parentComponent);
5846	} else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
5847		patchDOMProp(el, key, nextValue);
5848		if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value");
5849	} else if (el._isVueCE && (shouldSetAsPropForVueCE(el, key) || el._def.__asyncLoader && (/[A-Z]/.test(key) || !isString(nextValue)))) patchDOMProp(el, camelize$1(key), nextValue, parentComponent, key);
5850	else {
5851		if (key === "true-value") el._trueValue = nextValue;
5852		else if (key === "false-value") el._falseValue = nextValue;
5853		patchAttr(el, key, nextValue, isSVG);
5854	}
5855};
5856function shouldSetAsProp(el, key, value, isSVG) {
5857	if (isSVG) {
5858		if (key === "innerHTML" || key === "textContent") return true;
5859		if (key in el && isNativeOn(key) && isFunction(value)) return true;
5860		return false;
5861	}
5862	if (key === "spellcheck" || key === "draggable" || key === "translate" || key === "autocorrect") return false;
5863	if (key === "sandbox" && el.tagName === "IFRAME") return false;
5864	if (key === "form") return false;
5865	if (key === "list" && el.tagName === "INPUT") return false;
5866	if (key === "type" && el.tagName === "TEXTAREA") return false;
5867	if (key === "width" || key === "height") {
5868		const tag = el.tagName;
5869		if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") return false;
5870	}
5871	if (isNativeOn(key) && isString(value)) return false;
5872	return key in el;
5873}
5874function shouldSetAsPropForVueCE(el, key) {
5875	const props = el._def.props;
5876	if (!props) return false;
5877	const camelKey = camelize$1(key);
5878	return Array.isArray(props) ? props.some((prop) => camelize$1(prop) === camelKey) : Object.keys(props).some((prop) => camelize$1(prop) === camelKey);
5879}
5880var getModelAssigner = (vnode) => {
5881	const fn = vnode.props["onUpdate:modelValue"] || false;
5882	return isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
5883};
5884function onCompositionStart(e) {
5885	e.target.composing = true;
5886}
5887function onCompositionEnd(e) {
5888	const target = e.target;
5889	if (target.composing) {
5890		target.composing = false;
5891		target.dispatchEvent(new Event("input"));
5892	}
5893}
5894var assignKey = /* @__PURE__ */ Symbol("_assign");
5895var initialValueKey = /* @__PURE__ */ Symbol("_initialValue");
5896function castValue(value, trim, number) {
5897	if (trim) value = value.trim();
5898	if (number) value = looseToNumber(value);
5899	return value;
5900}
5901var vModelText = {
5902	created(el, { modifiers: { lazy, trim, number } }, vnode) {
5903		if (el.parentNode) {
5904			if (el.type === "text") el[initialValueKey] = el.defaultValue.replace(/[\r\n]/g, "");
5905			else if (el.type === "textarea") el[initialValueKey] = el.defaultValue.replace(/\r\n?/g, "\n");
5906		}
5907		el[assignKey] = getModelAssigner(vnode);
5908		const castToNumber = number || vnode.props && vnode.props.type === "number";
5909		addEventListener(el, lazy ? "change" : "input", (e) => {
5910			if (e.target.composing) return;
5911			el[assignKey](castValue(el.value, trim, castToNumber));
5912		});
5913		if (trim || castToNumber) addEventListener(el, "change", () => {
5914			el.value = castValue(el.value, trim, castToNumber);
5915		});
5916		if (!lazy) {
5917			addEventListener(el, "compositionstart", onCompositionStart);
5918			addEventListener(el, "compositionend", onCompositionEnd);
5919			addEventListener(el, "change", onCompositionEnd);
5920		}
5921	},
5922	mounted(el, { value, modifiers: { trim, number } }) {
5923		const newValue = value == null ? "" : value;
5924		const initialValue = el[initialValueKey];
5925		delete el[initialValueKey];
5926		if (initialValue !== void 0 && (el.type === "text" || el.type === "textarea") && el.value !== initialValue) el[assignKey](castValue(el.value, trim, number));
5927		else el.value = newValue;
5928	},
5929	beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
5930		el[assignKey] = getModelAssigner(vnode);
5931		if (el.composing) return;
5932		const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? looseToNumber(el.value) : el.value;
5933		const newValue = value == null ? "" : value;
5934		if (elValue === newValue) return;
5935		const rootNode = el.getRootNode();
5936		if ((rootNode instanceof Document || rootNode instanceof ShadowRoot) && rootNode.activeElement === el && el.type !== "range") {
5937			if (lazy && value === oldValue) return;
5938			if (trim && el.value.trim() === newValue) return;
5939		}
5940		el.value = newValue;
5941	}
5942};
5943var vModelSelect = {
5944	deep: true,
5945	created(el, { value, modifiers: { number } }, vnode) {
5946		el._modelValue = value;
5947		addEventListener(el, "change", () => {
5948			const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map((o) => number ? looseToNumber(getValue(o)) : getValue(o));
5949			const multiple = el.multiple;
5950			const assignedValue = multiple ? isSet(el._modelValue) ? new Set(selectedVal) : selectedVal : selectedVal[0];
5951			const pending = el._pendingValue = [multiple, multiple ? isArray(assignedValue) ? selectedVal.slice() : selectedVal : assignedValue];
5952			try {
5953				el[assignKey](assignedValue);
5954			} finally {
5955				nextTick(() => {

5956					if (el._pendingValue === pending) el._pendingValue = void 0;
5957				});
5958			}
5959		});
5960		el[assignKey] = getModelAssigner(vnode);
5961	},
5962	mounted(el, { value }) {
5963		setSelected(el, value);
5964	},
5965	beforeUpdate(el, { value }, vnode) {
5966		el._modelValue = value;
5967		el[assignKey] = getModelAssigner(vnode);
5968	},
5969	updated(el, { value }) {
5970		const pending = el._pendingValue;
5971		el._pendingValue = void 0;
5972		if (!pending || pending[0] !== el.multiple || !isSameSelectValue(value, pending[1], pending[0])) setSelected(el, value);
5973	}
5974};
5975function isSameSelectValue(value, assignedValue, multiple) {
5976	if (!multiple) return looseEqual(value, assignedValue);
5977	if (isArray(value)) return looseEqual(value, assignedValue);
5978	if (isSet(value)) {
5979		if (value.size !== assignedValue.length) return false;
5980		for (const item of assignedValue) if (!value.has(item)) return false;
5981		return true;
5982	}
5983	return false;
5984}
5985function setSelected(el, value) {
5986	const isMultiple = el.multiple;
5987	const isArrayValue = isArray(value);
5988	if (isMultiple && !isArrayValue && !isSet(value)) return;
5989	for (let i = 0, l = el.options.length; i < l; i++) {
5990		const option = el.options[i];
5991		const optionValue = getValue(option);
5992		if (isMultiple) {
5993			if (isArrayValue) {
5994				const optionType = typeof optionValue;
5995				if (optionType === "string" || optionType === "number") option.selected = value.some((v) => String(v) === String(optionValue));
5996				else option.selected = looseIndexOf(value, optionValue) > -1;
5997			} else option.selected = value.has(optionValue);
5998		} else if (looseEqual(getValue(option), value)) {
5999			if (el.selectedIndex !== i) el.selectedIndex = i;
6000			return;
6001		}
6002	}
6003	if (!isMultiple && el.selectedIndex !== -1) el.selectedIndex = -1;
6004}
6005function getValue(el) {
6006	return "_value" in el ? el._value : el.value;
6007}
6008var systemModifiers = [
6009	"ctrl",
6010	"shift",
6011	"alt",
6012	"meta"
6013];
6014var modifierGuards = {
6015	stop: (e) => e.stopPropagation(),
6016	prevent: (e) => e.preventDefault(),
6017	self: (e) => e.target !== e.currentTarget,
6018	ctrl: (e) => !e.ctrlKey,
6019	shift: (e) => !e.shiftKey,
6020	alt: (e) => !e.altKey,
6021	meta: (e) => !e.metaKey,
6022	left: (e) => "button" in e && e.button !== 0,
6023	middle: (e) => "button" in e && e.button !== 1,
6024	right: (e) => "button" in e && e.button !== 2,
6025	exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
6026};
6027var withModifiers = (fn, modifiers) => {
6028	if (!fn) return fn;
6029	const cache = fn._withMods || (fn._withMods = {});
6030	const cacheKey = modifiers.join(".");
6031	return cache[cacheKey] || (cache[cacheKey] = ((event, ...args) => {
6032		for (let i = 0; i < modifiers.length; i++) {
6033			const guard = modifierGuards[modifiers[i]];
6034			if (guard && guard(event, modifiers)) return;
6035		}
6036		return fn(event, ...args);
6037	}));
6038};
6039var rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
6040var renderer;
6041var enabledHydration = false;
6042function ensureRenderer() {
6043	return renderer || (renderer = createRenderer(rendererOptions));
6044}
6045function ensureHydrationRenderer() {
6046	renderer = enabledHydration ? renderer : createHydrationRenderer(rendererOptions);
6047	enabledHydration = true;
6048	return renderer;
6049}
6050var createApp = ((...args) => {
6051	const app = ensureRenderer().createApp(...args);
6052	const { mount } = app;
6053	app.mount = (containerOrSelector) => {
6054		const container = normalizeContainer(containerOrSelector);
6055		if (!container) return;
6056		const component = app._component;
6057		if (!isFunction(component) && !component.render && !component.template) component.template = container.innerHTML;
6058		if (container.nodeType === 1) container.textContent = "";
6059		const proxy = mount(container, false, resolveRootNamespace(container));
6060		if (container instanceof Element) {
6061			container.removeAttribute("v-cloak");
6062			container.setAttribute("data-v-app", "");
6063		}
6064		return proxy;
6065	};
6066	return app;
6067});
6068var createSSRApp = ((...args) => {
6069	const app = ensureHydrationRenderer().createApp(...args);
6070	const { mount } = app;
6071	app.mount = (containerOrSelector) => {
6072		const container = normalizeContainer(containerOrSelector);
6073		if (container) return mount(container, true, resolveRootNamespace(container));
6074	};
6075	return app;
6076});
6077function resolveRootNamespace(container) {
6078	if (container instanceof SVGElement) return "svg";
6079	if (typeof MathMLElement === "function" && container instanceof MathMLElement) return "mathml";
6080}
6081function normalizeContainer(container) {
6082	if (isString(container)) return document.querySelector(container);
6083	return container;
6084}
6085//#endregion
6086//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/components/ClientOnly.js
6087var ClientOnly = /* @__PURE__ */ defineComponent({ setup(_, { slots }) {
6088	const show = /* @__PURE__ */ ref(false);
6089	onMounted(() => {
6090		show.value = true;
6091	});
6092	return () => show.value && slots.default ? slots.default() : null;
6093} });
6094//#endregion
6095//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/shared.js
6096var EXTERNAL_URL_RE = /^(?:[a-z]+:|\/\/)/i;
6097var APPEARANCE_KEY = "vitepress-theme-appearance";
6098var iconNameRE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
6099/**
6100* Parses a fully qualified `collection:name` icon name, corresponding to
6101* the `vpi-<collection>-<name>` class. Returns null for anything else,
6102* keeping malformed input out of generated selectors and class attributes.
6103*/
6104function parseIconName(name) {
6105	const colon = name.indexOf(":");
6106	if (colon === -1) return null;
6107	const collection = name.slice(0, colon);
6108	const icon = name.slice(colon + 1);
6109	if (!iconNameRE.test(collection) || !iconNameRE.test(icon)) return null;
6110	return {
6111		collection,
6112		icon
6113	};
6114}
6115/**
6116* Placeholder prepended to SSR-emitted URLs when base is relative, later
6117* replaced with each page's `../` prefix back to the site root.
6118*/
6119var RELATIVE_BASE_SENTINEL = "/__VP_BASE__/";
6120function isRelativeBase(base) {
6121	return base === "./";
6122}
6123/**
6124* Join two paths, collapsing slash collisions but keeping the `//` that
6125* follows a protocol.
6126*/
6127function joinPath(base, path) {
6128	const protocol = /^(?:[a-z]+:)?\/\//i.exec(base)?.[0] ?? "";
6129	return protocol + `${base.slice(protocol.length)}${path}`.replace(/\/+/g, "/");
6130}
6131var UnpackStackView = Symbol("stack-view:unpack");
6132var HASH_WITHOUT_FRAGMENT_RE = /#.*?(?=:~:|$)/;
6133var HASH_OR_QUERY_RE = /[?#].*$/;
6134var INDEX_OR_EXT_RE = /(?:(^|\/)index)?(?:\.(?:md|html))?$/;
6135var INVALID_CHAR_REGEX = /[\u0000-\u001F"#$&*+,:;<=>?[\]^`{|}\u007F]/g;
6136var DRIVE_LETTER_REGEX = /^[a-z]:/i;
6137var KNOWN_EXTENSIONS = /* @__PURE__ */ new Set();
6138var shellLangs = [
6139	"shellscript",
6140	"shell",
6141	"bash",
6142	"sh",
6143	"zsh"
6144];
6145var inBrowser = typeof document !== "undefined";
6146var notFoundPageData = {
6147	relativePath: "404.md",
6148	filePath: "",
6149	title: "404",
6150	description: "Not Found",
6151	headers: [],
6152	frontmatter: {
6153		sidebar: false,
6154		layout: "page"
6155	},
6156	lastUpdated: 0,
6157	isNotFound: true
6158};
6159function isActive(currentPath, currentHash, matchPath, asRegex = false, skipHashCheck = false) {
6160	currentPath = normalize(`/${currentPath}`);
6161	if (asRegex) return new RegExp(matchPath).test(currentPath);
6162	if (normalize(matchPath) !== currentPath) return false;

6163	if (skipHashCheck) return true;
6164	const hashMatch = matchPath.match(HASH_WITHOUT_FRAGMENT_RE);
6165	if (hashMatch) return currentHash === hashMatch[0];
6166	return true;
6167}
6168function normalize(path) {
6169	return decodeURI(path).replace(HASH_OR_QUERY_RE, "").replace(INDEX_OR_EXT_RE, "$1");
6170}
6171function isExternal(path) {
6172	return EXTERNAL_URL_RE.test(path);
6173}
6174function getLocaleForPath(siteData, relativePath) {
6175	return Object.keys(siteData?.locales || {}).find((key) => key !== "root" && !isExternal(key) && isActive(relativePath, "", `^/${key}/`, true)) || "root";
6176}
6177/**
6178* Resolves the site data for a route, layering the matched locale and
6179* additional configs over the root config.
6180*/
6181function resolveSiteDataByRoute(siteData, relativePath, filePath) {
6182	const localeIndex = getLocaleForPath(siteData, relativePath);
6183	const { label, link, markdown, ...localeConfig } = siteData.locales[localeIndex] ?? {};
6184	Object.assign(localeConfig, { localeIndex });
6185	const additionalConfigs = resolveAdditionalConfig(siteData, filePath || relativePath);
6186	return stackView({ head: mergeHead(siteData.head ?? [], localeConfig.head ?? [], ...additionalConfigs.map((data) => data.head ?? []).reverse()) }, ...additionalConfigs, localeConfig, siteData);
6187}
6188/**
6189* Create the page title string based on config.
6190*/
6191function createTitle(siteData, pageData) {
6192	const title = pageData.title || siteData.title;
6193	const template = pageData.titleTemplate ?? siteData.titleTemplate;
6194	if (typeof template === "string" && template.includes(":title")) return template.replace(/:title/g, title);
6195	const templateString = createTitleTemplate(siteData.title, template);
6196	if (title === templateString.slice(3)) return title;
6197	return `${title}${templateString}`;
6198}
6199function createTitleTemplate(siteTitle, template) {
6200	if (template === false) return "";
6201	if (template === true || template === void 0) return ` | ${siteTitle}`;
6202	if (siteTitle === template) return "";
6203	return ` | ${template}`;
6204}
6205function mergeHead(...headArrays) {
6206	const merged = [];
6207	const keyMap = /* @__PURE__ */ new Map();
6208	for (const current of headArrays) for (const tag of current) {
6209		const key = getHeadKey(tag);
6210		if (key == null) {
6211			merged.push(tag);
6212			continue;
6213		}
6214		const existingIndex = keyMap.get(key);
6215		if (existingIndex != null) merged[existingIndex] = tag;
6216		else {
6217			keyMap.set(key, merged.length);
6218			merged.push(tag);
6219		}
6220	}
6221	return merged;
6222}
6223function getHeadKey([type, attrs]) {
6224	if (attrs.id) return `id=${attrs.id}`;
6225	if (type !== "meta") return;
6226	for (const name in attrs) if (name !== "content") return `${name}=${attrs[name]}`;
6227}
6228function sanitizeFileName(name) {
6229	const match = DRIVE_LETTER_REGEX.exec(name);
6230	const driveLetter = match ? match[0] : "";
6231	return driveLetter + name.slice(driveLetter.length).replace(INVALID_CHAR_REGEX, "_").replace(/(^|\/)_+(?=[^/]*$)/, "$1");
6232}
6233function treatAsHtml(filename) {
6234	if (KNOWN_EXTENSIONS.size === 0) {
6235		const extraExts = {}.VITE_EXTRA_EXTENSIONS || "";
6236		("3g2,3gp,aac,ai,apng,au,avif,bin,bmp,cer,class,conf,crl,css,csv,dll,doc,eps,epub,exe,gif,gz,ics,ief,jar,jpe,jpeg,jpg,js,json,jsonld,m4a,man,mid,midi,mjs,mov,mp2,mp3,mp4,mpe,mpeg,mpg,mpp,oga,ogg,ogv,ogx,opus,otf,p10,p7c,p7m,p7s,pdf,png,ps,qt,roff,rtf,rtx,ser,svg,t,tif,tiff,tr,ts,tsv,ttf,txt,vtt,wav,weba,webm,webp,woff,woff2,xhtml,xml,yaml,yml,zip" + (extraExts && typeof extraExts === "string" ? "," + extraExts : "")).split(",").forEach((ext) => KNOWN_EXTENSIONS.add(ext));
6237	}
6238	const ext = filename.split(".").pop();
6239	return ext == null || !KNOWN_EXTENSIONS.has(ext.toLowerCase());
6240}
6241function escapeRegExp(str) {
6242	return str.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
6243}
6244function resolveAdditionalConfig({ additionalConfig }, path) {
6245	if (additionalConfig === void 0) return [];
6246	if (typeof additionalConfig === "function") return additionalConfig(path) ?? [];
6247	const configs = [];
6248	const segments = path.split("/").slice(0, -1);
6249	while (segments.length) {
6250		const key = `/${segments.join("/")}/`;
6251		configs.push(additionalConfig[key]);
6252		segments.pop();
6253	}
6254	configs.push(additionalConfig["/"]);
6255	return configs.filter((config) => config !== void 0);
6256}
6257/**
6258* Creates a readonly proxy behaving like a deep merge of the given layers,
6259* without mutating them. Earlier layers take precedence.
6260*/
6261function stackView(..._layers) {
6262	const layers = _layers.filter((layer) => isObject$1(layer));
6263	if (layers.length <= 1) return _layers[0];
6264	const allKeys = new Set(layers.flatMap((layer) => Reflect.ownKeys(layer)));

6265	const allKeysArray = [...allKeys];
6266	return new Proxy({}, {
6267		get(_, prop) {
6268			if (prop === UnpackStackView) return layers;
6269			return stackView(...layers.map((layer) => layer[prop]).filter((v) => v !== void 0));
6270		},
6271		set() {
6272			throw new Error("StackView is read-only and cannot be mutated.");
6273		},
6274		has(_, prop) {
6275			return allKeys.has(prop);
6276		},
6277		ownKeys() {
6278			return allKeysArray;
6279		},
6280		getOwnPropertyDescriptor(_, prop) {
6281			for (const layer of layers) {
6282				const descriptor = Object.getOwnPropertyDescriptor(layer, prop);
6283				if (descriptor) return descriptor;
6284			}
6285		}
6286	});
6287}
6288stackView.unpack = function(obj) {
6289	return obj?.[UnpackStackView];
6290};
6291function isObject$1(value) {
6292	return Object.prototype.toString.call(value) === "[object Object]";
6293}
6294function isShell(lang) {
6295	return shellLangs.includes(lang);
6296}
6297//#endregion
6298//#region node_modules/.pnpm/@[email protected][email protected]/node_modules/@vueuse/shared/dist/index.js
6299/**
6300* Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
6301*
6302* @param fn
6303*/
6304function tryOnScopeDispose(fn, failSilently) {
6305	if (getCurrentScope()) {
6306		onScopeDispose(fn, failSilently);
6307		return true;
6308	}
6309	return false;
6310}
6311var localProvidedStateMap = /* @__PURE__ */ new WeakMap();
6312/**
6313* On the basis of `inject`, it is allowed to directly call inject to obtain the value after call provide in the same component.
6314*
6315* @example
6316* ```ts
6317* injectLocal('MyInjectionKey', 1)
6318* const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
6319* ```
6320*
6321* @__NO_SIDE_EFFECTS__
6322*/
6323var injectLocal = (...args) => {
6324	var _getCurrentInstance;
6325	const key = args[0];
6326	const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
6327	const owner = instance !== null && instance !== void 0 ? instance : getCurrentScope();
6328	if (owner == null && !hasInjectionContext()) throw new Error("injectLocal must be called in setup");
6329	if (owner && localProvidedStateMap.has(owner) && key in localProvidedStateMap.get(owner)) return localProvidedStateMap.get(owner)[key];
6330	return inject(...args);
6331};
6332var isClient = typeof window !== "undefined" && typeof document !== "undefined";
6333typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
6334var notNullish = (val) => val != null;
6335var toString = Object.prototype.toString;
6336var isObject = (val) => toString.call(val) === "[object Object]";
6337var noop = () => {};
6338function toRef(...args) {
6339	if (args.length !== 1) return /* @__PURE__ */ toRef$1(...args);
6340	const r = args[0];

vendor: 8,429 bytes, lines 6341-6626

6341	return typeof r === "function" ? /* @__PURE__ */ readonly(customRef(() => ({
6342		get: r,
6343		set: noop
6344	}))) : /* @__PURE__ */ ref(r);
6345}
6346function createFilterWrapper(filter, fn) {
6347	function wrapper(...args) {
6348		return new Promise((resolve, reject) => {
6349			Promise.resolve(filter(() => fn.apply(this, args), {
6350				fn,
6351				thisArg: this,
6352				args
6353			})).then(resolve).catch(reject);
6354		});
6355	}
6356	if ("cancel" in filter) Object.assign(wrapper, {
6357		cancel: filter.cancel,
6358		flush: filter.flush,
6359		isPending: filter.isPending
6360	});
6361	return wrapper;
6362}
6363var bypassFilter = (invoke) => {
6364	return invoke();
6365};
6366/**
6367* Create an EventFilter that debounce the events
6368*/
6369function debounceFilter(ms, options = {}) {
6370	let timer;
6371	let maxTimer;
6372	let lastRejector = noop;
6373	let lastResolve = noop;
6374	const _pending = /* @__PURE__ */ shallowRef(false);
6375	const _clearTimeout = (timer) => {
6376		clearTimeout(timer);
6377		lastRejector();
6378		lastRejector = noop;
6379	};
6380	let lastInvoker;
6381	const handler = (invoke) => {
6382		const duration = toValue(ms);
6383		const maxDuration = toValue(options.maxWait);
6384		if (timer) _clearTimeout(timer);
6385		if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
6386			if (maxTimer) {
6387				_clearTimeout(maxTimer);
6388				maxTimer = void 0;
6389			}
6390			_pending.value = false;
6391			return Promise.resolve(invoke());
6392		}
6393		_pending.value = true;
6394		return new Promise((resolve, reject) => {
6395			lastRejector = options.rejectOnCancel ? reject : resolve;
6396			lastResolve = resolve;
6397			lastInvoker = invoke;
6398			if (maxDuration && !maxTimer) maxTimer = setTimeout(() => {
6399				if (timer) _clearTimeout(timer);
6400				maxTimer = void 0;
6401				_pending.value = false;
6402				resolve(lastInvoker());
6403			}, maxDuration);
6404			timer = setTimeout(() => {
6405				if (maxTimer) _clearTimeout(maxTimer);
6406				maxTimer = void 0;
6407				_pending.value = false;
6408				resolve(invoke());
6409			}, duration);
6410		});
6411	};
6412	return Object.assign(handler, {
6413		cancel: () => {
6414			if (timer) {
6415				_clearTimeout(timer);
6416				timer = void 0;
6417			}
6418			if (maxTimer) {
6419				_clearTimeout(maxTimer);
6420				maxTimer = void 0;
6421			}
6422			_pending.value = false;
6423			lastResolve = noop;
6424		},
6425		flush: () => {
6426			if (_pending.value) {
6427				if (timer) {
6428					clearTimeout(timer);
6429					timer = void 0;
6430				}
6431				if (maxTimer) {
6432					clearTimeout(maxTimer);
6433					maxTimer = void 0;
6434				}
6435				_pending.value = false;
6436				const resolve = lastResolve;
6437				lastRejector = noop;
6438				lastResolve = noop;
6439				resolve(lastInvoker());
6440			}
6441		},
6442		isPending: /* @__PURE__ */ shallowReadonly(_pending)
6443	});
6444}
6445function throttleFilter(...args) {
6446	let lastExec = 0;
6447	let timer;
6448	let isLeading = true;
6449	let lastRejector = noop;
6450	let lastValue;
6451	let ms;
6452	let trailing;
6453	let leading;
6454	let rejectOnCancel;
6455	if (!/* @__PURE__ */ isRef(args[0]) && typeof args[0] === "object") ({delay: ms, trailing = true, leading = true, rejectOnCancel = false} = args[0]);
6456	else [ms, trailing = true, leading = true, rejectOnCancel = false] = args;
6457	const clear = () => {
6458		if (timer) {
6459			clearTimeout(timer);
6460			timer = void 0;
6461			lastRejector();
6462			lastRejector = noop;
6463		}
6464	};
6465	const filter = (_invoke) => {
6466		const duration = toValue(ms);
6467		const elapsed = Date.now() - lastExec;
6468		const invoke = () => {
6469			return lastValue = _invoke();
6470		};
6471		clear();
6472		if (duration <= 0) {
6473			lastExec = Date.now();
6474			return invoke();
6475		}
6476		if (elapsed > duration) {
6477			lastExec = Date.now();
6478			if (leading || !isLeading) invoke();
6479		} else if (trailing) lastValue = new Promise((resolve, reject) => {
6480			lastRejector = rejectOnCancel ? reject : resolve;
6481			timer = setTimeout(() => {
6482				lastExec = Date.now();
6483				isLeading = true;
6484				resolve(invoke());
6485				clear();
6486			}, Math.max(0, duration - elapsed));
6487		});
6488		if (!leading && !timer) timer = setTimeout(() => isLeading = true, duration);
6489		isLeading = false;
6490		return lastValue;
6491	};
6492	return filter;
6493}
6494/**
6495* EventFilter that gives extra controls to pause and resume the filter
6496*
6497* @param extendFilter  Extra filter to apply when the PausableFilter is active, default to none
6498* @param options Options to configure the filter
6499*/
6500function pausableFilter(extendFilter = bypassFilter, options = {}) {
6501	const { initialState = "active" } = options;
6502	const isActive = toRef(initialState === "active");
6503	function pause() {
6504		isActive.value = false;
6505	}
6506	function resume() {
6507		isActive.value = true;
6508	}
6509	const eventFilter = (...args) => {
6510		if (isActive.value) extendFilter(...args);
6511	};
6512	return {
6513		isActive: /* @__PURE__ */ shallowReadonly(isActive),
6514		pause,
6515		resume,
6516		eventFilter
6517	};
6518}
6519/**
6520* Get a px value for SSR use, do not rely on this method outside of SSR as REM unit is assumed at 16px, which might not be the case on the client
6521*/
6522function pxValue(px) {
6523	return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
6524}
6525function toArray(value) {
6526	return Array.isArray(value) ? value : [value];
6527}
6528function getLifeCycleTarget(target) {
6529	return target || getCurrentInstance();
6530}
6531/**
6532* Debounce execution of a function.
6533*
6534* @see https://vueuse.org/useDebounceFn
6535* @param  fn          A function to be executed after delay milliseconds debounced.
6536* @param  ms          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
6537* @param  options     Options
6538*
6539* @return A new, debounced, function with isPending, cancel, and flush properties.
6540*/
6541function useDebounceFn(fn, ms = 200, options = {}) {
6542	return createFilterWrapper(debounceFilter(ms, options), fn);
6543}
6544/**
6545* Throttle execution of a function. Especially useful for rate limiting
6546* execution of handlers on events like resize and scroll.
6547*
6548* @param   fn             A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
6549*                                    to `callback` when the throttled-function is executed.
6550* @param   ms             A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
6551*                                    (default value: 200)
6552*
6553* @param [trailing] if true, call fn again after the time is up (default value: false)
6554*
6555* @param [leading] if true, call fn on the leading edge of the ms timeout (default value: true)
6556*
6557* @param [rejectOnCancel] if true, reject the last call if it's been cancel (default value: false)
6558*
6559* @return  A new, throttled, function.
6560*
6561* @__NO_SIDE_EFFECTS__
6562*/
6563function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
6564	return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn);
6565}
6566function watchWithFilter(source, cb, options = {}) {
6567	const { eventFilter = bypassFilter, ...watchOptions } = options;
6568	return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
6569}
6570/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
6571function watchPausable(source, cb, options = {}) {
6572	const { eventFilter: filter, initialState = "active", ...watchOptions } = options;
6573	const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
6574	return {
6575		stop: watchWithFilter(source, cb, {
6576			...watchOptions,
6577			eventFilter
6578		}),
6579		pause,
6580		resume,
6581		isActive
6582	};
6583}
6584/**
6585* Call onMounted() if it's inside a component lifecycle, if not, just call the function
6586*
6587* @param fn
6588* @param sync if set to false, it will run in the nextTick() of Vue
6589* @param target
6590*/
6591function tryOnMounted(fn, sync = true, target) {
6592	if (getLifeCycleTarget(target)) onMounted(fn, target);
6593	else if (sync) fn();
6594	else nextTick(fn);
6595}
6596/**
6597* Call onUnmounted() if it's inside a component lifecycle, if not, do nothing
6598*
6599* @param fn
6600* @param target
6601*/
6602function tryOnUnmounted(fn, target) {
6603	if (getLifeCycleTarget(target)) onUnmounted(fn, target);
6604}
6605function watchDebounced(source, cb, options = {}) {
6606	const { debounce = 0, maxWait = void 0, ...watchOptions } = options;
6607	return watchWithFilter(source, cb, {
6608		...watchOptions,
6609		eventFilter: debounceFilter(debounce, { maxWait })
6610	});
6611}
6612/**
6613* Shorthand for watching value with {immediate: true}
6614*
6615* @see https://vueuse.org/watchImmediate
6616*/
6617function watchImmediate(source, cb, options) {
6618	return watch(source, cb, {
6619		...options,
6620		immediate: true
6621	});
6622}
6623function whenever(source, cb, options) {
6624	const stop = watch(source, (v, ov, onInvalidate) => {
6625		if (v) {
6626			if (options === null || options === void 0 ? void 0 : options.once) 

vendor: 4,570 bytes, lines 6626-6749

6626nextTick(() => stop());
6627			cb(v, ov, onInvalidate);
6628		}
6629	}, {
6630		...options,
6631		once: false
6632	});
6633	return stop;
6634}
6635//#endregion
6636//#region node_modules/.pnpm/@[email protected][email protected]/node_modules/@vueuse/core/dist/index.js
6637function computedAsync(evaluationCallback, initialState, optionsOrRef) {
6638	var _globalThis$reportErr;
6639	let options;
6640	if (/* @__PURE__ */ isRef(optionsOrRef)) options = { evaluating: optionsOrRef };
6641	else options = optionsOrRef || {};
6642	const { lazy = false, flush = "sync", evaluating = void 0, shallow = true, onError = (_globalThis$reportErr = globalThis.reportError) !== null && _globalThis$reportErr !== void 0 ? _globalThis$reportErr : noop } = options;
6643	const started = /* @__PURE__ */ shallowRef(!lazy);
6644	const current = shallow ? /* @__PURE__ */ shallowRef(initialState) : /* @__PURE__ */ ref(initialState);
6645	let counter = 0;
6646	watchEffect(async (onInvalidate) => {
6647		if (!started.value) return;
6648		counter++;
6649		const counterAtBeginning = counter;
6650		let hasFinished = false;
6651		if (evaluating) Promise.resolve().then(() => {
6652			evaluating.value = true;
6653		});
6654		try {
6655			const result = await evaluationCallback((cancelCallback) => {
6656				onInvalidate(() => {
6657					if (evaluating) evaluating.value = false;
6658					if (!hasFinished) cancelCallback();
6659				});
6660			});
6661			if (counterAtBeginning === counter) current.value = result;
6662		} catch (e) {
6663			onError(e);
6664		} finally {
6665			if (evaluating && counterAtBeginning === counter) evaluating.value = false;
6666			hasFinished = true;
6667		}
6668	}, { flush });
6669	if (lazy) return computed(() => {
6670		started.value = true;
6671		return current.value;
6672	});
6673	else return current;
6674}
6675var defaultWindow = isClient ? window : void 0;
6676isClient && window.document;
6677isClient && window.navigator;
6678isClient && window.location;
6679/**
6680* Get the dom element of a ref of element or Vue component instance
6681*
6682* @param elRef
6683*/
6684function unrefElement(elRef) {
6685	var _$el;
6686	const plain = toValue(elRef);
6687	return (_$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _$el !== void 0 ? _$el : plain;
6688}
6689function useEventListener(...args) {
6690	const register = (el, event, listener, options) => {
6691		el.addEventListener(event, listener, options);
6692		return () => el.removeEventListener(event, listener, options);
6693	};
6694	const firstParamTargets = computed(() => {
6695		const test = toArray(toValue(args[0])).filter((e) => e != null);
6696		return test.every((e) => typeof e !== "string") ? test : void 0;
6697	});
6698	return watchImmediate(() => {
6699		var _firstParamTargets$va, _firstParamTargets$va2;
6700		return [
6701			(_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [defaultWindow].filter((e) => e != null),
6702			toArray(toValue(firstParamTargets.value ? args[1] : args[0])),
6703			toArray(unref(firstParamTargets.value ? args[2] : args[1])),
6704			toValue(firstParamTargets.value ? args[3] : args[2])
6705		];
6706	}, ([raw_targets, raw_events, raw_listeners, raw_options], _, onCleanup) => {
6707		if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
6708		const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
6709		const cleanups = raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))));
6710		onCleanup(() => {
6711			cleanups.forEach((fn) => fn());
6712		});
6713	}, { flush: "post" });
6714}
6715/**
6716* Mounted state in ref.
6717*
6718* @see https://vueuse.org/useMounted
6719*
6720* @__NO_SIDE_EFFECTS__
6721*/
6722function useMounted() {
6723	const isMounted = /* @__PURE__ */ shallowRef(false);
6724	const instance = getCurrentInstance();
6725	if (instance) onMounted(() => {
6726		isMounted.value = true;
6727	}, instance);
6728	return isMounted;
6729}
6730/* @__NO_SIDE_EFFECTS__ */
6731function useSupported(callback) {
6732	const isMounted = useMounted();
6733	return computed(() => {
6734		isMounted.value;
6735		return Boolean(callback());
6736	});
6737}
6738/**
6739* Watch for changes being made to the DOM tree.
6740*
6741* @see https://vueuse.org/useMutationObserver
6742* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver MutationObserver MDN
6743* @param target
6744* @param callback
6745* @param options
6746*/
6747function useMutationObserver(target, callback, options = {}) {
6748	const { window = defaultWindow, ...mutationOptions } = options;
6749	let observer;

6750	const isSupported = /* @__PURE__ */ useSupported(() => window && "MutationObserver" in window);
6751	const cleanup = () => {
6752		if (observer) {
6753			observer.disconnect();
6754			observer = void 0;
6755		}
6756	};
6757	const stopWatch = watch(computed(() => {
6758		const items = toArray(toValue(target)).map(unrefElement).filter(notNullish);
6759		return new Set(items);
6760	}), (newTargets) => {
6761		cleanup();
6762		if (isSupported.value && newTargets.size) {
6763			observer = new MutationObserver(callback);
6764			newTargets.forEach((el) => observer.observe(el, mutationOptions));
6765		}
6766	}, {
6767		immediate: true,
6768		flush: "post"
6769	});
6770	const takeRecords = () => {
6771		return observer === null || observer === void 0 ? void 0 : observer.takeRecords();
6772	};
6773	const stop = () => {
6774		stopWatch();
6775		cleanup();
6776	};
6777	tryOnScopeDispose(stop);
6778	return {
6779		isSupported,
6780		stop,
6781		takeRecords
6782	};
6783}
6784function createKeyPredicate(keyFilter) {
6785	if (typeof keyFilter === "function") return keyFilter;
6786	else if (typeof keyFilter === "string") return (event) => event.key === keyFilter;
6787	else if (Array.isArray(keyFilter)) return (event) => keyFilter.includes(event.key);
6788	return () => true;
6789}
6790function onKeyStroke(...args) {
6791	let key;
6792	let handler;
6793	let options = {};
6794	if (args.length === 3) {
6795		key = args[0];
6796		handler = args[1];
6797		options = args[2];
6798	} else if (args.length === 2) if (typeof args[1] === "object") {
6799		key = true;
6800		handler = args[0];
6801		options = args[1];
6802	} else {
6803		key = args[0];
6804		handler = args[1];
6805	}
6806	else {
6807		key = true;
6808		handler = args[0];
6809	}
6810	const { target = defaultWindow, eventName = "keydown", passive = false, dedupe = false } = options;
6811	const predicate = createKeyPredicate(key);
6812	const listener = (e) => {
6813		if (e.repeat && toValue(dedupe)) return;
6814		if (predicate(e)) handler(e);
6815	};
6816	return useEventListener(target, eventName, listener, passive);
6817}
6818var ssrWidthSymbol = Symbol("vueuse-ssr-width");
6819/* @__NO_SIDE_EFFECTS__ */
6820function useSSRWidth() {
6821	const ssrWidth = hasInjectionContext() ? injectLocal(ssrWidthSymbol, null) : null;
6822	return typeof ssrWidth === "number" ? ssrWidth : void 0;
6823}
6824/**
6825* Reactive Media Query.
6826*
6827* @see https://vueuse.org/useMediaQuery
6828* @param query
6829* @param options
6830*/
6831function useMediaQuery(query, options = {}) {
6832	const { window = defaultWindow, ssrWidth = /* @__PURE__ */ useSSRWidth() } = options;
6833	const isSupported = /* @__PURE__ */ useSupported(() =>

vendor: 17,478 bytes, lines 6833-7333

6833 window && "matchMedia" in window && typeof window.matchMedia === "function");
6834	const ssrSupport = /* @__PURE__ */ shallowRef(typeof ssrWidth === "number");
6835	const mediaQuery = /* @__PURE__ */ shallowRef();
6836	const matches = /* @__PURE__ */ shallowRef(false);
6837	const handler = (event) => {
6838		matches.value = event.matches;
6839	};
6840	watchEffect(() => {
6841		if (ssrSupport.value) {
6842			ssrSupport.value = !isSupported.value;
6843			const queryStrings = toValue(query).split(",");
6844			matches.value = queryStrings.some((queryString) => {
6845				const not = queryString.includes("not all");
6846				const minWidth = queryString.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
6847				const maxWidth = queryString.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
6848				let res = Boolean(minWidth || maxWidth);
6849				if (minWidth && res) res = ssrWidth >= pxValue(minWidth[1]);
6850				if (maxWidth && res) res = ssrWidth <= pxValue(maxWidth[1]);
6851				return not ? !res : res;
6852			});
6853			return;
6854		}
6855		if (!isSupported.value) return;
6856		mediaQuery.value = window.matchMedia(toValue(query));
6857		matches.value = mediaQuery.value.matches;
6858	});
6859	useEventListener(mediaQuery, "change", handler, { passive: true });
6860	return computed(() => matches.value);
6861}
6862var _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
6863var globalKey = "__vueuse_ssr_handlers__";
6864var handlers = /* #__PURE__ */ getHandlers();
6865function getHandlers() {
6866	if (!(globalKey in _global)) _global[globalKey] = _global[globalKey] || {};
6867	return _global[globalKey];
6868}
6869function getSSRHandler(key, fallback) {
6870	return handlers[key] || fallback;
6871}
6872/**
6873* Reactive dark theme preference.
6874*
6875* @see https://vueuse.org/usePreferredDark
6876* @param [options]
6877*
6878* @__NO_SIDE_EFFECTS__
6879*/
6880function usePreferredDark(options) {
6881	return useMediaQuery("(prefers-color-scheme: dark)", options);
6882}
6883function guessSerializerType(rawInit) {
6884	return rawInit == null ? "any" : rawInit instanceof Set ? "set" : rawInit instanceof Map ? "map" : rawInit instanceof Date ? "date" : typeof rawInit === "boolean" ? "boolean" : typeof rawInit === "string" ? "string" : typeof rawInit === "object" ? "object" : !Number.isNaN(rawInit) ? "number" : "any";
6885}
6886var StorageSerializers = {
6887	boolean: {
6888		read: (v) => v === "true",
6889		write: (v) => String(v)
6890	},
6891	object: {
6892		read: (v) => JSON.parse(v),
6893		write: (v) => JSON.stringify(v)
6894	},
6895	number: {
6896		read: (v) => Number.parseFloat(v),
6897		write: (v) => String(v)
6898	},
6899	any: {
6900		read: (v) => v,
6901		write: (v) => String(v)
6902	},
6903	string: {
6904		read: (v) => v,
6905		write: (v) => String(v)
6906	},
6907	map: {
6908		read: (v) => new Map(JSON.parse(v)),
6909		write: (v) => JSON.stringify(Array.from(v.entries()))
6910	},
6911	set: {
6912		read: (v) => new Set(JSON.parse(v)),
6913		write: (v) => JSON.stringify(Array.from(v))
6914	},
6915	date: {
6916		read: (v) => new Date(v),
6917		write: (v) => v.toISOString()
6918	}
6919};
6920var customStorageEventName = "vueuse-storage";
6921/**
6922* Reactive LocalStorage/SessionStorage.
6923*
6924* @see https://vueuse.org/useStorage
6925*/
6926function useStorage(key, defaults, storage, options = {}) {
6927	var _options$serializer;
6928	const { flush = "pre", deep = true, listenToStorageChanges = true, writeDefaults = true, mergeDefaults = false, shallow, window = defaultWindow, eventFilter, onError = (e) => {
6929		console.error(e);
6930	}, initOnMounted } = options;
6931	const data = (shallow ? shallowRef : ref)(typeof defaults === "function" ? defaults() : defaults);
6932	const keyComputed = computed(() => toValue(key));
6933	if (!storage) try {
6934		storage = getSSRHandler("getDefaultStorage", () => defaultWindow === null || defaultWindow === void 0 ? void 0 : defaultWindow.localStorage)();
6935	} catch (e) {
6936		onError(e);
6937	}
6938	if (!storage) return data;
6939	const rawInit = toValue(defaults);
6940	const type = guessSerializerType(rawInit);
6941	const serializer = (_options$serializer = options.serializer) !== null && _options$serializer !== void 0 ? _options$serializer : StorageSerializers[type];
6942	const { pause: pauseWatch, resume: resumeWatch } = watchPausable(data, (newValue) => write(newValue), {
6943		flush,
6944		deep,
6945		eventFilter
6946	});
6947	watch(keyComputed, () => update(), { flush });
6948	let firstMounted = false;
6949	const onStorageEvent = (ev) => {
6950		if (initOnMounted && !firstMounted) return;
6951		update(ev);
6952	};
6953	const onStorageCustomEvent = (ev) => {
6954		if (initOnMounted && !firstMounted) return;
6955		updateFromCustomEvent(ev);
6956	};
6957	/**
6958	* The custom event is needed for same-document syncing when using custom
6959	* storage backends, but it doesn't work across different documents.
6960	*
6961	* TODO: Consider implementing a BroadcastChannel-based solution that fixes this.
6962	*/
6963	if (window && listenToStorageChanges) if (storage instanceof Storage) useEventListener(window, "storage", onStorageEvent, { passive: true });
6964	else useEventListener(window, customStorageEventName, onStorageCustomEvent);
6965	if (initOnMounted) tryOnMounted(() => {
6966		firstMounted = true;
6967		update();
6968	});
6969	else update();
6970	function dispatchWriteEvent(oldValue, newValue) {
6971		if (window) {
6972			const payload = {
6973				key: keyComputed.value,
6974				oldValue,
6975				newValue,
6976				storageArea: storage
6977			};
6978			window.dispatchEvent(storage instanceof Storage ? new StorageEvent("storage", payload) : new CustomEvent(customStorageEventName, { detail: payload }));
6979		}
6980	}
6981	function write(v) {
6982		try {
6983			const oldValue = storage.getItem(keyComputed.value);
6984			if (v == null) {
6985				dispatchWriteEvent(oldValue, null);
6986				storage.removeItem(keyComputed.value);
6987			} else {
6988				const serialized = serializer.write(v);
6989				if (oldValue !== serialized) {
6990					storage.setItem(keyComputed.value, serialized);
6991					dispatchWriteEvent(oldValue, serialized);
6992				}
6993			}
6994		} catch (e) {
6995			onError(e);
6996		}
6997	}
6998	function read(event) {
6999		const rawValue = event ? event.newValue : storage.getItem(keyComputed.value);
7000		if (rawValue == null) {
7001			if (writeDefaults && rawInit != null) storage.setItem(keyComputed.value, serializer.write(rawInit));
7002			return rawInit;
7003		} else if (!event && mergeDefaults) {
7004			const value = serializer.read(rawValue);
7005			if (typeof mergeDefaults === "function") return mergeDefaults(value, rawInit);
7006			else if (type === "object" && !Array.isArray(value)) return {
7007				...rawInit,
7008				...value
7009			};
7010			return value;
7011		} else if (typeof rawValue !== "string") return rawValue;
7012		else return serializer.read(rawValue);
7013	}
7014	function update(event) {
7015		if (event && event.storageArea !== storage) return;
7016		if (event && event.key == null) {
7017			data.value = rawInit;
7018			return;
7019		}
7020		if (event && event.key !== keyComputed.value) return;
7021		pauseWatch();
7022		try {
7023			const serializedData = serializer.write(data.value);
7024			if (event === void 0 || (event === null || event === void 0 ? void 0 : event.newValue) !== serializedData) data.value = read(event);
7025		} catch (e) {
7026			onError(e);
7027		} finally {
7028			if (event) nextTick(resumeWatch);
7029			else resumeWatch();
7030		}
7031	}
7032	function updateFromCustomEvent(event) {
7033		update(event.detail);
7034	}
7035	return data;
7036}
7037var CSS_DISABLE_TRANS = "*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}";
7038/**
7039* Reactive color mode with auto data persistence.
7040*
7041* @see https://vueuse.org/useColorMode
7042* @param options
7043*/
7044function useColorMode(options = {}) {
7045	const { selector = "html", attribute = "class", initialValue = "auto", window = defaultWindow, storage, storageKey = "vueuse-color-scheme", listenToStorageChanges = true, storageRef, emitAuto, disableTransition = true } = options;
7046	const modes = {
7047		auto: "",
7048		light: "light",
7049		dark: "dark",
7050		...options.modes || {}
7051	};
7052	const preferredDark = usePreferredDark({ window });
7053	const system = computed(() => preferredDark.value ? "dark" : "light");
7054	const store = storageRef || (storageKey == null ? toRef(initialValue) : useStorage(storageKey, initialValue, storage, {
7055		window,
7056		listenToStorageChanges
7057	}));
7058	const state = computed(() => store.value === "auto" ? system.value : store.value);
7059	const updateHTMLAttrs = getSSRHandler("updateHTMLAttrs", (selector, attribute, value) => {
7060		const el = typeof selector === "string" ? window === null || window === void 0 ? void 0 : window.document.querySelector(selector) : unrefElement(selector);
7061		if (!el) return;
7062		const classesToAdd = /* @__PURE__ */ new Set();
7063		const classesToRemove = /* @__PURE__ */ new Set();
7064		let attributeToChange = null;
7065		if (attribute === "class") {
7066			const current = value.split(/\s/g);
7067			Object.values(modes).flatMap((i) => (i || "").split(/\s/g)).filter(Boolean).forEach((v) => {
7068				if (current.includes(v)) classesToAdd.add(v);
7069				else classesToRemove.add(v);
7070			});
7071		} else attributeToChange = {
7072			key: attribute,
7073			value
7074		};
7075		if (classesToAdd.size === 0 && classesToRemove.size === 0 && attributeToChange === null) return;
7076		let style;
7077		if (disableTransition) {
7078			style = window.document.createElement("style");
7079			style.appendChild(document.createTextNode(CSS_DISABLE_TRANS));
7080			window.document.head.appendChild(style);
7081		}
7082		for (const c of classesToAdd) el.classList.add(c);
7083		for (const c of classesToRemove) el.classList.remove(c);
7084		if (attributeToChange) el.setAttribute(attributeToChange.key, attributeToChange.value);
7085		if (disableTransition) {
7086			window.getComputedStyle(style).opacity;
7087			document.head.removeChild(style);
7088		}
7089	});
7090	function defaultOnChanged(mode) {
7091		var _modes$mode;
7092		updateHTMLAttrs(selector, attribute, (_modes$mode = modes[mode]) !== null && _modes$mode !== void 0 ? _modes$mode : mode);
7093	}
7094	function onChanged(mode) {
7095		if (options.onChanged) options.onChanged(mode, defaultOnChanged);
7096		else defaultOnChanged(mode);
7097	}
7098	watch(state, onChanged, {
7099		flush: "post",
7100		immediate: true
7101	});
7102	tryOnMounted(() => onChanged(state.value));
7103	const auto = computed({
7104		get() {
7105			return emitAuto ? store.value : state.value;
7106		},
7107		set(v) {
7108			store.value = v;
7109		}
7110	});
7111	return Object.assign(auto, {
7112		store,
7113		system,
7114		state
7115	});
7116}
7117/**
7118* Reactive dark mode with auto data persistence.
7119*
7120* @see https://vueuse.org/useDark
7121* @param options
7122*/
7123function useDark(options = {}) {
7124	const { valueDark = "dark", valueLight = "" } = options;
7125	const mode = useColorMode({
7126		...options,
7127		onChanged: (mode, defaultHandler) => {
7128			var _options$onChanged;
7129			if (options.onChanged) (_options$onChanged = options.onChanged) === null || _options$onChanged === void 0 || _options$onChanged.call(options, mode === "dark", defaultHandler, mode);
7130			else defaultHandler(mode);
7131		},
7132		modes: {
7133			dark: valueDark,
7134			light: valueLight
7135		}
7136	});
7137	const system = computed(() => mode.system.value);
7138	return computed({
7139		get() {
7140			return mode.value === "dark";
7141		},
7142		set(v) {
7143			const modeVal = v ? "dark" : "light";
7144			if (system.value === modeVal) mode.value = "auto";
7145			else mode.value = modeVal;
7146		}
7147	});
7148}
7149/**
7150* We have to check if the scroll amount is close enough to some threshold in order to
7151* more accurately calculate arrivedState. This is because scrollTop/scrollLeft are non-rounded
7152* numbers, while scrollHeight/scrollWidth and clientHeight/clientWidth are rounded.
7153* https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#determine_if_an_element_has_been_totally_scrolled
7154*/
7155var ARRIVED_STATE_THRESHOLD_PIXELS = 1;
7156/**
7157* Reactive scroll.
7158*
7159* @see https://vueuse.org/useScroll
7160* @param element
7161* @param options
7162*/
7163function useScroll(element, options = {}) {
7164	const { throttle = 0, idle = 200, onStop = noop, onScroll = noop, offset = {
7165		left: 0,
7166		right: 0,
7167		top: 0,
7168		bottom: 0
7169	}, observe: _observe = { mutation: false }, eventListenerOptions = {
7170		capture: false,
7171		passive: true
7172	}, behavior = "auto", window = defaultWindow, onError = (e) => {
7173		console.error(e);
7174	} } = options;
7175	const observe = typeof _observe === "boolean" ? { mutation: _observe } : _observe;
7176	const internalX = /* @__PURE__ */ shallowRef(0);
7177	const internalY = /* @__PURE__ */ shallowRef(0);
7178	const x = computed({
7179		get() {
7180			return internalX.value;
7181		},
7182		set(x) {
7183			scrollTo(x, void 0);
7184		}
7185	});
7186	const y = computed({
7187		get() {
7188			return internalY.value;
7189		},
7190		set(y) {
7191			scrollTo(void 0, y);
7192		}
7193	});
7194	function scrollTo(_x, _y) {
7195		var _ref, _toValue, _toValue2, _document;
7196		if (!window) return;
7197		const _element = toValue(element);
7198		if (!_element) return;
7199		(_ref = _element instanceof Document ? window.document.body : _element) === null || _ref === void 0 || _ref.scrollTo({
7200			top: (_toValue = toValue(_y)) !== null && _toValue !== void 0 ? _toValue : y.value,
7201			left: (_toValue2 = toValue(_x)) !== null && _toValue2 !== void 0 ? _toValue2 : x.value,
7202			behavior: toValue(behavior)
7203		});
7204		const scrollContainer = (_element === null || _element === void 0 || (_document = _element.document) === null || _document === void 0 ? void 0 : _document.documentElement) || (_element === null || _element === void 0 ? void 0 : _element.documentElement) || _element;
7205		if (x != null) internalX.value = scrollContainer.scrollLeft;
7206		if (y != null) internalY.value = scrollContainer.scrollTop;
7207	}
7208	const isScrolling = /* @__PURE__ */ shallowRef(false);
7209	const arrivedState = /* @__PURE__ */ reactive({
7210		left: true,
7211		right: false,
7212		top: true,
7213		bottom: false
7214	});
7215	const directions = /* @__PURE__ */ reactive({
7216		left: false,
7217		right: false,
7218		top: false,
7219		bottom: false
7220	});
7221	const onScrollEnd = (e) => {
7222		if (!isScrolling.value) return;
7223		isScrolling.value = false;
7224		directions.left = false;
7225		directions.right = false;
7226		directions.top = false;
7227		directions.bottom = false;
7228		onStop(e);
7229	};
7230	const onScrollEndDebounced = useDebounceFn(onScrollEnd, throttle + idle);
7231	const setArrivedState = (target) => {
7232		var _document2;
7233		if (!window) return;
7234		const el = (target === null || target === void 0 || (_document2 = target.document) === null || _document2 === void 0 ? void 0 : _document2.documentElement) || (target === null || target === void 0 ? void 0 : target.documentElement) || unrefElement(target);
7235		const { display, flexDirection, direction } = window.getComputedStyle(el);
7236		const directionMultipler = direction === "rtl" ? -1 : 1;
7237		const scrollLeft = el.scrollLeft;
7238		directions.left = scrollLeft < internalX.value;
7239		directions.right = scrollLeft > internalX.value;
7240		const left = Math.abs(scrollLeft * directionMultipler) <= (offset.left || 0);
7241		const right = Math.abs(scrollLeft * directionMultipler) + el.clientWidth >= el.scrollWidth - (offset.right || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
7242		if (display === "flex" && flexDirection === "row-reverse") {
7243			arrivedState.left = right;
7244			arrivedState.right = left;
7245		} else {
7246			arrivedState.left = left;
7247			arrivedState.right = right;
7248		}
7249		internalX.value = scrollLeft;
7250		let scrollTop = el.scrollTop;
7251		if (target === window.document && !scrollTop) scrollTop = window.document.body.scrollTop;
7252		directions.top = scrollTop < internalY.value;
7253		directions.bottom = scrollTop > internalY.value;
7254		const top = Math.abs(scrollTop) <= (offset.top || 0);
7255		const bottom = Math.abs(scrollTop) + el.clientHeight >= el.scrollHeight - (offset.bottom || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
7256		/**
7257		* reverse columns and rows behave exactly the other way around,
7258		* bottom is treated as top and top is treated as the negative version of bottom
7259		*/
7260		if (display === "flex" && flexDirection === "column-reverse") {
7261			arrivedState.top = bottom;
7262			arrivedState.bottom = top;
7263		} else {
7264			arrivedState.top = top;
7265			arrivedState.bottom = bottom;
7266		}
7267		internalY.value = scrollTop;
7268	};
7269	const onScrollHandler = (e) => {
7270		var _documentElement;
7271		if (!window) return;
7272		const eventTarget = (_documentElement = e.target.documentElement) !== null && _documentElement !== void 0 ? _documentElement : e.target;
7273		setArrivedState(eventTarget);
7274		isScrolling.value = true;
7275		onScrollEndDebounced(e);
7276		onScroll(e);
7277	};
7278	useEventListener(element, "scroll", throttle ? useThrottleFn(onScrollHandler, throttle, true, false) : onScrollHandler, eventListenerOptions);
7279	tryOnMounted(() => {
7280		try {
7281			const _element = toValue(element);
7282			if (!_element) return;
7283			setArrivedState(_element);
7284		} catch (e) {
7285			onError(e);
7286		}
7287	});
7288	if ((observe === null || observe === void 0 ? void 0 : observe.mutation) && element != null && element !== window && element !== document) useMutationObserver(element, () => {
7289		const _element = toValue(element);
7290		if (!_element) return;
7291		setArrivedState(_element);
7292	}, {
7293		attributes: true,
7294		childList: true,
7295		subtree: true
7296	});
7297	useEventListener(element, "scrollend", onScrollEnd, eventListenerOptions);
7298	return {
7299		x,
7300		y,
7301		isScrolling,
7302		arrivedState,
7303		directions,
7304		measure() {
7305			const _element = toValue(element);
7306			if (window && _element) setArrivedState(_element);
7307		}
7308	};
7309}
7310/**
7311* Reactive LocalStorage.
7312*
7313* @see https://vueuse.org/useLocalStorage
7314* @param key
7315* @param initialValue
7316* @param options
7317*/
7318function useLocalStorage(key, initialValue, options = {}) {
7319	const { window = defaultWindow } = options;
7320	return useStorage(key, initialValue, window === null || window === void 0 ? void 0 : window.localStorage, options);
7321}
7322/**
7323*
7324* Reactive useNavigatorLanguage
7325*
7326* Detects the currently selected user language and returns a reactive language
7327* @see https://vueuse.org/useNavigatorLanguage
7328*
7329* @__NO_SIDE_EFFECTS__
7330*/
7331function useNavigatorLanguage(options = {}) {
7332	const { window = defaultWindow } = options;
7333	const navigator = window === null || window === void 0 ? void 0 : window.navigator;

7334	const isSupported = /* @__PURE__ */ useSupported(() => navigator && "language" in navigator);
7335	const language = /* @__PURE__ */ shallowRef(navigator === null || navigator === void 0 ? void 0 : navigator.language);
7336	useEventListener(window, "languagechange", () => {
7337		if (navigator) language.value = navigator.language;
7338	}, { passive: true });
7339	return {
7340		isSupported,
7341		language
7342	};
7343}
7344/**
7345* Reactive SessionStorage.
7346*
7347* @see https://vueuse.org/useSessionStorage
7348* @param key
7349* @param initialValue
7350* @param options
7351*/
7352function useSessionStorage(key, initialValue, options = {}) {
7353	const { window = defaultWindow } = options;
7354	return useStorage(key, initialValue, window === null || window === void 0 ? void 0 : window.sessionStorage, options);
7355}
7356/**
7357* Reactive window scroll.
7358*
7359* @see https://vueuse.org/useWindowScroll
7360* @param options
7361*/
7362function useWindowScroll(options = {}) {
7363	const { window = defaultWindow, ...rest } = options;
7364	return useScroll(window, rest);
7365}
7366//#endregion
7367//#region ../../../../@siteData
7368var _siteData_default = window.__VP_SITE_DATA__;
7369//#endregion
7370//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/data.js
7371var dataSymbol = Symbol();
7372var siteDataRef = /* @__PURE__ */ shallowRef(/* @__PURE__ */ readonly(_siteData_default));
7373function initData(route) {
7374	const site = computed(() => resolveSiteDataByRoute(siteDataRef.value, route.data.relativePath, route.data.filePath));
7375	const appearance = site.value.appearance;
7376	const isDark = appearance === "force-dark" ? /* @__PURE__ */ ref(true) : appearance === "force-auto" ? usePreferredDark() : appearance ? useDark({
7377		storageKey: APPEARANCE_KEY,
7378		initialValue: () => appearance === "dark" ? "dark" : "auto",
7379		...typeof appearance === "object" ? appearance : {}
7380	}) : /* @__PURE__ */ ref(false);
7381	return {
7382		site,
7383		theme: computed(() => site.value.themeConfig),
7384		page: computed(() => route.data),
7385		frontmatter: computed(() => route.data.frontmatter),
7386		params: computed(() => route.data.params),
7387		lang: computed(() => site.value.lang),
7388		dir: computed(() => route.data.frontmatter.dir || site.value.dir),
7389		localeIndex: computed(() => site.value.localeIndex || "root"),
7390		title: computed(() => createTitle(site.value, route.data)),
7391		description: computed(() => route.data.description || site.value.description),
7392		isDark
7393	};
7394}
7395function useData() {
7396	const data = inject(dataSymbol);
7397	if (!data) throw new Error("vitepress data not properly injected in app");
7398	return data;
7399}
7400//#endregion
7401//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/utils.js
7402var resolvedBase;
7403/**
7404* Runtime base path used by the app.
7405*
7406* Usually this is the configured site base.
7407*
7408* For a relative base (`'./'`), the mount point is unknown at build time, so:
7409* - SSR: uses `RELATIVE_BASE_SENTINEL` (for per-page URL relativization)
7410* - dev browser: uses `'/'` (dev server always mounts at root)
7411* - prod browser: resolves from the page's `__VP_SITE_ROOT__`
7412*/
7413function runtimeBase() {
7414	if (resolvedBase === void 0) {
7415		const base = siteDataRef.value.base;
7416		if (!isRelativeBase(base)) return resolvedBase = base;
7417		if (!inBrowser) return resolvedBase = RELATIVE_BASE_SENTINEL;
7418		const root = window.__VP_SITE_ROOT__;
7419		resolvedBase = root ? decodeURIComponent(new URL(root, location.href).pathname) : "/";
7420	}
7421	return resolvedBase;
7422}
7423/**
7424* Prepend base to internal (non-relative) urls
7425*/
7426function withBase(path) {
7427	return EXTERNAL_URL_RE.test(path) || !path.startsWith("/") ? path : joinPath(runtimeBase(), path);
7428}
7429/**
7430* Converts a url path to the corresponding js chunk filename.
7431*/
7432function pathToFile(path) {
7433	let pagePath = path.replace(/\.html$/, "");
7434	pagePath = decodeURIComponent(pagePath);
7435	pagePath = pagePath.replace(/\/$/, "/index");
7436	if (inBrowser) {
7437		const base = runtimeBase();
7438		if (pagePath + "/" === base) pagePath = base;
7439		if (!pagePath.startsWith(base)) return null;
7440		pagePath = sanitizeFileName(pagePath.slice(base.length).replace(/\//g, "_") || "index") + ".md";
7441		let pageHash = __VP_HASH_MAP__[pagePath.toLowerCase()];
7442		if (!pageHash) {

7443			pagePath = pagePath.endsWith("_index.md") ? pagePath.slice(0, -9) + ".md" : pagePath.slice(0, -3) + "_index.md";
7444			pageHash = __VP_HASH_MAP__[pagePath.toLowerCase()];
7445		}
7446		if (!pageHash) return null;
7447		pagePath = `${base}assets/${pagePath}.${pageHash}.js`;
7448	} else pagePath = `./${sanitizeFileName(pagePath.slice(1).replace(/\//g, "_"))}.md.js`;
7449	return pagePath;
7450}
7451var contentUpdatedCallbacks = [];
7452/**
7453* Register callback that is called every time the markdown content is updated
7454* in the DOM.
7455*/
7456function onContentUpdated(fn) {
7457	contentUpdatedCallbacks.push(fn);
7458	tryOnUnmounted(() => {
7459		contentUpdatedCallbacks = contentUpdatedCallbacks.filter((f) => f !== fn);
7460	});
7461}
7462//#endregion
7463//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/composables/icon.js
7464/**
7465* Resolves an icon name (`collection:name`, e.g. `simple-icons:github`) to
7466* its `vpi-<collection>-<name>` class. During SSR the name is registered so
7467* the build emits its CSS rule; in dev the SVG is served on demand and
7468* applied to `el` inline.
7469*/
7470function useIcon(icon, el) {
7471	const parsed = computed(() => {
7472		const value = toValue(icon);
7473		return typeof value === "string" ? parseIconName(value) : null;
7474	});
7475	return computed(() => parsed.value ? `vpi-${parsed.value.collection}-${parsed.value.icon}` : void 0);
7476}
7477//#endregion
7478//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/router.js
7479var RouterSymbol = Symbol();
7480var fakeHost = "http://a.com";
7481var getDefaultRoute = () => ({
7482	path: "/",
7483	hash: "",
7484	query: "",
7485	component: null,
7486	data: notFoundPageData
7487});
7488function createRouter(loadPageModule, fallbackComponent) {
7489	const route = /* @__PURE__ */ reactive(getDefaultRoute());
7490	const router = {
7491		route,
7492		async go(href, options) {
7493			const { hash } = new URL(href, fakeHost);
7494			const hasTextFragment = inBrowser && document.fragmentDirective && hash.includes(":~:");
7495			href = normalizeHref(href);
7496			if (await router.onBeforeRouteChange?.(href) === false) return;
7497			if (!inBrowser || await changeRoute(href, {
7498				...options,
7499				hasTextFragment
7500			})) await loadPage(href, { initialLoad: !!options?.initialLoad });
7501			if (hasTextFragment) location.hash = hash;
7502			syncRouteQueryAndHash();
7503			await router.onAfterRouteChange?.(href);
7504		}
7505	};
7506	let latestPendingPath = null;
7507	async function loadPage(href, { scrollPosition = 0, isRetry = false, initialLoad = false } = {}) {
7508		if (await router.onBeforePageLoad?.(href) === false) return;
7509		const targetLoc = new URL(href, fakeHost);
7510		const pendingPath = latestPendingPath = targetLoc.pathname;
7511		try {
7512			let page = await loadPageModule(pendingPath);
7513			if (!page) throw new Error(`Page not found: ${pendingPath}`);
7514			if (latestPendingPath === pendingPath) {
7515				latestPendingPath = null;
7516				const { default: comp, __pageData } = page;
7517				if (!comp) throw new Error(`Invalid route component: ${comp}`);
7518				await router.onAfterPageLoad?.(href);
7519				route.path = inBrowser ? pendingPath : withBase(pendingPath);
7520				route.component = markRaw(comp);
7521				route.data = markRaw(__pageData);
7522				syncRouteQueryAndHash(targetLoc);
7523				if (inBrowser) nextTick(() => {
7524					let actualPathname = runtimeBase() + __pageData.relativePath.replace(/(?:(^|\/)index)?\.md$/, "$1");
7525					if (!siteDataRef.value.cleanUrls && !actualPathname.endsWith("/")) actualPathname += ".html";
7526					if (actualPathname !== targetLoc.pathname) {
7527						targetLoc.pathname = actualPathname;
7528						href = actualPathname + targetLoc.search + targetLoc.hash;
7529						history.replaceState({}, "", href);
7530					}
7531					if (!initialLoad) scrollTo(targetLoc.hash, scrollPosition);
7532				});
7533			}
7534		} catch (err) {
7535			if (!/fetch|Page not found/.test(err.message) && !/^\/404(\.html|\/)?$/.test(href)) console.error(err);
7536			if (!isRetry) try {
7537				const res = await fetch(runtimeBase() + "hashmap.json");
7538				window.__VP_HASH_MAP__ = await res.json();
7539				await loadPage(href, {
7540					scrollPosition,
7541					isRetry: true,
7542					initialLoad
7543				});
7544				return;
7545			} catch (e) {}
7546			if (latestPendingPath === pendingPath) {
7547				latestPendingPath = null;
7548				route.path = inBrowser ? pendingPath : withBase(pendingPath);
7549				route.component = fallbackComponent ? markRaw(fallbackComponent) : null;
7550				const relativePath = inBrowser ? route.path.replace(/(^|\/)$/, "$1index").replace(/(\.html)?$/, ".md").slice(runtimeBase().length) : "404.md";
7551				route.data = {
7552					...notFoundPageData,
7553					relativePath
7554				};
7555				syncRouteQueryAndHash(targetLoc);
7556			}
7557		}
7558	}
7559	function syncRouteQueryAndHash(loc = inBrowser ? location : {
7560		search: "",
7561		hash: ""
7562	}) {
7563		route.query = loc.search;
7564		route.hash = decodeURIComponent(loc.hash);
7565	}
7566	if (inBrowser) {
7567		if (history.state === null) history.replaceState({}, "");
7568		window.addEventListener("click", (e) => {
7569			if (e.defaultPrevented || !(e.target instanceof Element) || e.target.closest("button") || e.button !== 0 || e.ctrlKey || e.shiftKey || e.altKey || e.metaKey) return;
7570			const link = e.target.closest("a");
7571			if (!link || link.closest(".vp-raw") || link.hasAttribute("download") || link.hasAttribute("target")) return;
7572			const linkHref = link.getAttribute("href") ?? (link instanceof SVGAElement ? link.getAttribute("xlink:href") : null);
7573			if (linkHref == null) return;
7574			const { href, origin, pathname } = new URL(linkHref, link.baseURI);
7575			if (origin === new URL(location.href).origin && treatAsHtml(pathname)) {
7576				e.preventDefault();
7577				router.go(href);
7578			}
7579		}, { capture: true });
7580		window.addEventListener("popstate", async (e) => {
7581			if (e.state === null) return;
7582			const href = normalizeHref(location.href);
7583			await loadPage(href, { scrollPosition: e.state.scrollPosition || 0 });
7584			syncRouteQueryAndHash();
7585			await router.onAfterRouteChange?.(href);
7586		});
7587		window.addEventListener("hashchange", (e) => {
7588			e.preventDefault();
7589			syncRouteQueryAndHash();
7590		});
7591	}
7592	return router;
7593}
7594function useRouter() {
7595	const router = inject(RouterSymbol);
7596	if (!router) throw new Error("useRouter() is called without provider.");
7597	return router;
7598}
7599function useRoute() {
7600	return useRouter().route;
7601}
7602function scrollTo(hash, scrollPosition = 0) {
7603	if (!hash || scrollPosition) {
7604		window.scrollTo(0, scrollPosition);
7605		return;
7606	}
7607	let target = null;
7608	try {
7609		target = document.getElementById(decodeURIComponent(hash).slice(1));
7610	} catch (e) {
7611		console.warn(e);
7612	}
7613	if (!target) return;
7614	const scrollToTarget = () => {
7615		target.scrollIntoView({ block: "start" });

7616		target.focus({ preventScroll: true });
7617		if (document.activeElement === target) return;
7618		if (target.hasAttribute("tabindex")) return;
7619		const restoreTabindex = () => {
7620			target.removeAttribute("tabindex");
7621			target.removeEventListener("blur", restoreTabindex);
7622		};
7623		target.setAttribute("tabindex", "-1");
7624		target.addEventListener("blur", restoreTabindex);
7625		target.focus({ preventScroll: true });
7626		if (document.activeElement !== target) restoreTabindex();
7627	};
7628	requestAnimationFrame(scrollToTarget);
7629}
7630function normalizeHref(href) {
7631	const url = new URL(href, fakeHost);
7632	url.pathname = url.pathname.replace(/(^|\/)index(\.html)?$/, "$1");
7633	if (siteDataRef.value.cleanUrls) url.pathname = url.pathname.replace(/\.html$/, "");
7634	else if (!url.pathname.endsWith("/") && !url.pathname.endsWith(".html")) url.pathname += ".html";
7635	return url.pathname + url.search + url.hash.split(":~:")[0];
7636}
7637async function changeRoute(href, { initialLoad = false, replace = false, hasTextFragment = false } = {}) {
7638	const loc = normalizeHref(location.href);
7639	const nextUrl = new URL(href, location.origin);
7640	const currentUrl = new URL(loc, location.origin);
7641	if (href === loc) {
7642		if (!initialLoad) {
7643			if (!hasTextFragment) scrollTo(nextUrl.hash);
7644			return false;
7645		}
7646	} else {
7647		if (replace) history.replaceState({}, "", href);
7648		else {
7649			history.replaceState({ scrollPosition: window.scrollY }, "");
7650			history.pushState({}, "", href);
7651		}
7652		if (nextUrl.pathname === currentUrl.pathname) {
7653			if (nextUrl.hash !== currentUrl.hash) {
7654				window.dispatchEvent(new HashChangeEvent("hashchange", {
7655					oldURL: currentUrl.href,
7656					newURL: nextUrl.href
7657				}));
7658				if (!hasTextFragment) scrollTo(nextUrl.hash);
7659			}
7660			return false;
7661		}
7662	}
7663	return true;
7664}
7665//#endregion
7666//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/components/Content.js
7667var runCbs = () => contentUpdatedCallbacks.forEach((fn) => fn());
7668var Content = /* @__PURE__ */ defineComponent({
7669	name: "VitePressContent",
7670	props: { as: {
7671		type: [Object, String],
7672		default: "div"
7673	} },
7674	setup(props) {
7675		const { frontmatter, site } = useData();
7676		const route = useRoute();
7677		watch(frontmatter, runCbs, {
7678			deep: true,
7679			flush: "post"
7680		});
7681		return () => h(props.as, site.value.contentProps ?? { style: { position: "relative" } }, [route.component ? h(route.component, {
7682			onVnodeMounted: runCbs,
7683			onVnodeUpdated: runCbs,
7684			onVnodeUnmounted: runCbs
7685		}) : "404 Page Not Found"]);
7686	}
7687});
7688//#endregion
7689//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/composables/codeGroups.js
7690function useCodeGroups() {
7691	if (inBrowser) window.addEventListener("click", (e) => {
7692		const el = e.target;
7693		if (el.matches(".vp-code-group input")) {
7694			const group = el.parentElement?.parentElement;
7695			if (!group) return;
7696			const i = Array.from(group.querySelectorAll("input")).indexOf(el);
7697			if (i < 0) return;
7698			const blocks = group.querySelector(".blocks");
7699			if (!blocks) return;
7700			const current = Array.from(blocks.children).find((child) => child.classList.contains("active"));
7701			if (!current) return;
7702			const next = blocks.children[i];
7703			if (!next || current === next) return;
7704			current.classList.remove("active");
7705			activate(next);
7706			(group?.querySelector(`label[for="${el.id}"]`))?.scrollIntoView({ block: "nearest" });
7707		}
7708	});
7709}
7710function activate(el) {
7711	el.classList.add("active");
7712	window.dispatchEvent(new CustomEvent("vitepress:codeGroupTabActivate", { detail: el }));
7713}
7714//#endregion
7715//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/composables/copyCode.js
7716var ignoredNodes = [".vp-copy-ignore", ".diff.remove"].join(", ");
7717function useCopyCode() {
7718	if (inBrowser) {
7719		const timeoutIdMap = /* @__PURE__ */ new WeakMap();
7720		window.addEventListener("click", (e) => {
7721			const el = e.target;
7722			if (el.matches("div[class*=\"language-\"] > button.copy")) {
7723				const parent = el.parentElement;
7724				const sibling = el.nextElementSibling?.nextElementSibling;
7725				if (!parent || !sibling) return;
7726				const clone = sibling.cloneNode(true);

7727				clone.querySelectorAll(ignoredNodes).forEach((node) => node.remove());
7728				clone.innerHTML = clone.innerHTML.replace(/\n+/g, "\n");
7729				let text = clone.textContent || "";
7730				if (isShell(/language-(\w+)/.exec(parent.className)?.[1] || "")) text = text.replace(/^ *(\$|>) /gm, "").trim();
7731				copyToClipboard(text).then(() => {
7732					el.classList.add("copied");
7733					clearTimeout(timeoutIdMap.get(el));
7734					const timeoutId = window.setTimeout(() => {
7735						el.classList.remove("copied");
7736						el.blur();
7737						timeoutIdMap.delete(el);
7738					}, 2e3);
7739					timeoutIdMap.set(el, timeoutId);
7740				});
7741			}
7742		});
7743	}
7744}
7745async function copyToClipboard(text) {
7746	try {
7747		await navigator.clipboard.writeText(text);
7748	} catch {
7749		const element = document.createElement("textarea");
7750		const previouslyFocusedElement = document.activeElement;
7751		element.value = text;
7752		element.setAttribute("readonly", "");
7753		element.style.contain = "strict";
7754		element.style.position = "absolute";
7755		element.style.left = "-9999px";
7756		element.style.fontSize = "12pt";
7757		const selection = document.getSelection();
7758		const originalRange = selection ? selection.rangeCount > 0 && selection.getRangeAt(0) : null;
7759		document.body.appendChild(element);
7760		element.select();
7761		element.selectionStart = 0;
7762		element.selectionEnd = text.length;
7763		document.execCommand("copy");
7764		document.body.removeChild(element);
7765		if (originalRange) {
7766			selection.removeAllRanges();
7767			selection.addRange(originalRange);
7768		}
7769		if (previouslyFocusedElement) previouslyFocusedElement.focus();
7770	}
7771}
7772//#endregion
7773//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/composables/head.js
7774function useUpdateHead(route, siteDataByRouteRef) {
7775	let isFirstUpdate = true;
7776	let managedHeadElements = [];
7777	const updateHeadTags = (newTags) => {
7778		if (isFirstUpdate) {
7779			isFirstUpdate = false;

7780			newTags.forEach((tag) => {
7781				const headEl = createHeadElement(tag);
7782				for (const el of document.head.children) if (el.isEqualNode(headEl)) {
7783					managedHeadElements.push(el);
7784					return;
7785				}
7786			});
7787			return;
7788		}
7789		const newElements = newTags.map(createHeadElement);
7790		managedHeadElements.forEach((oldEl, oldIndex) => {
7791			const matchedIndex = newElements.findIndex((newEl) => newEl?.isEqualNode(oldEl ?? null));
7792			if (matchedIndex !== -1) delete newElements[matchedIndex];
7793			else {
7794				oldEl?.remove();
7795				delete managedHeadElements[oldIndex];
7796			}
7797		});
7798		newElements.forEach((el) => el && document.head.appendChild(el));
7799		managedHeadElements = [...managedHeadElements, ...newElements].filter(Boolean);
7800	};
7801	watchEffect(() => {
7802		const pageData = route.data;
7803		const siteData = siteDataByRouteRef.value;
7804		const pageDescription = pageData && pageData.description;
7805		const frontmatterHead = pageData && pageData.frontmatter.head || [];
7806		const title = createTitle(siteData, pageData);
7807		if (title !== document.title) document.title = title;
7808		const description = pageDescription || siteData.description;
7809		let metaDescriptionElement = document.querySelector(`meta[name=description]`);
7810		if (metaDescriptionElement) {
7811			if (metaDescriptionElement.getAttribute("content") !== description) metaDescriptionElement.setAttribute("content", description);
7812		} else createHeadElement(["meta", {
7813			name: "description",
7814			content: description
7815		}]);
7816		updateHeadTags(mergeHead(siteData.head, filterOutHeadDescription(frontmatterHead)));
7817	});
7818}
7819function createHeadElement([tag, attrs, innerHTML]) {
7820	const el = document.createElement(tag);
7821	for (const [key, value] of Object.entries(attrs)) el.setAttribute(key, value);
7822	if (innerHTML) el.innerHTML = innerHTML;
7823	if (tag === "script" && attrs.async == null) el.async = false;
7824	return el;
7825}
7826function isMetaDescription(headConfig) {
7827	return headConfig[0] === "meta" && headConfig[1] && headConfig[1].name === "description";
7828}
7829function filterOutHeadDescription(head) {
7830	return head.filter((h) => !isMetaDescription(h));
7831}
7832//#endregion
7833//#region node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/vitepress/dist/client/app/composables/preFetch.js
7834var hasFetched = /* @__PURE__ */ new Set();
7835var createLink = () => document.createElement("link");
7836var viaDOM = (url) => {
7837	const link = createLink();
7838	link.rel = `prefetch`;
7839	if (EXTERNAL_URL_RE.test(url)) link.crossOrigin = "";
7840	link.href = url;
7841	document.head.appendChild(link);
7842};
7843var viaXHR = (url) => {
7844	const req = new XMLHttpRequest();
7845	req.open("GET", url, true);
7846	req.withCredentials = !EXTERNAL_URL_RE.test(url);
7847	req.send();
7848};
7849var link;
7850var doFetch = inBrowser && (link = createLink()) && link.relList && link.relList.supports && link.relList.supports("prefetch") ? viaDOM : viaXHR;
7851function usePrefetch() {
7852	if (!inBrowser) return;
7853	if (!window.IntersectionObserver) return;
7854	let conn;
7855	if ((conn = navigator.connection) && (conn.saveData || /2g/.test(conn.effectiveType))) return;
7856	const rIC = window.requestIdleCallback || setTimeout;
7857	let observer = null;
7858	const observeLinks = () => {
7859		if (observer) observer.disconnect();
7860		observer = new IntersectionObserver((entries) => {
7861			entries.forEach((entry) => {
7862				if (entry.isIntersecting) {
7863					const link = entry.target;
7864					observer.unobserve(link);
7865					const { pathname } = link;
7866					if (!hasFetched.has(pathname)) {
7867						hasFetched.add(pathname);
7868						const pageChunkPath = pathToFile(pathname);
7869						if (pageChunkPath) doFetch(pageChunkPath);
7870					}
7871				}
7872			});
7873		});
7874		rIC(() => {
7875			document.querySelectorAll("#app a").forEach((link) => {
7876				const { hostname, pathname } = new URL(link.href instanceof SVGAnimatedString ? link.href.animVal : link.href, link.baseURI);
7877				const extMatch = pathname.match(/\.\w+$/);
7878				if (extMatch && extMatch[0] !== ".html") return;
7879				if (link.target !== "_blank" && hostname === location.hostname) {
7880					if (pathname !== location.pathname) observer.observe(link);
7881					else hasFetched.add(pathname);
7882				}
7883			});
7884		});
7885	};
7886	onMounted(observeLinks);
7887	const route = useRoute();
7888	watch(() => route.path, observeLinks);
7889	onUnmounted(() => {
7890		observer && observer.disconnect();
7891	});
7892}
7893//#endregion
7894//#region \0plugin-vue:export-helper
7895var _plugin_vue_export_helper_default = (sfc, props) => {
7896	const target = sfc.__vccOpts || sfc;
7897	for (const [key, val] of props) target[key] = val;
7898	return target;
7899};
7900//#endregion
7901//#region \0vite/preload-helper.js
7902var scriptRel = "modulepreload";
7903var assetsURL = function(dep) {
7904	return "/" + dep;
7905};
7906var seen = {};
7907var __vitePreload = function preload(baseModule, deps, importerUrl) {
7908	let promise = Promise.resolve();
7909	if (deps && deps.length > 0) {
7910		const links = document.getElementsByTagName("link");
7911		const cspNonceMeta = document.querySelector("meta[property=csp-nonce]");
7912		const cspNonce = cspNonceMeta?.nonce || cspNonceMeta?.getAttribute("nonce");
7913		function allSettled(promises) {
7914			return Promise.all(promises.map((p) => Promise.resolve(p).then((value) => ({
7915				status: "fulfilled",
7916				value
7917			}), (reason) => ({
7918				status: "rejected",
7919				reason
7920			}))));
7921		}
7922		function importMetaResolve(specifier) {
7923			if (import.meta.resolve) return import.meta.resolve(specifier);
7924			return new URL(
7925				specifier,
7926				/** #__KEEP__ */
7927				import.meta.url
7928			).href;
7929		}
7930		promise = allSettled(deps.map((dep) => {
7931			dep = assetsURL(dep, importerUrl);
7932			dep = importMetaResolve(dep);
7933			if (dep in seen) return;
7934			seen[dep] = true;

vendor: 2,969 bytes, lines 7935-7968

7935			const isCss = dep.endsWith(".css");
7936			for (let i = links.length - 1; i >= 0; i--) {
7937				const link = links[i];
7938				if (link.href === dep && (!isCss || link.rel === "stylesheet")) return;
7939			}
7940			const link = document.createElement("link");
7941			link.rel = isCss ? "stylesheet" : scriptRel;
7942			if (!isCss) link.as = "script";
7943			link.crossOrigin = "";
7944			link.href = dep;
7945			if (cspNonce) link.setAttribute("nonce", cspNonce);
7946			document.head.appendChild(link);
7947			if (isCss) return new Promise((res, rej) => {
7948				link.addEventListener("load", res);
7949				link.addEventListener("error", () => rej(/* @__PURE__ */ new Error(`Unable to preload CSS for ${dep}`)));
7950			});
7951		}).filter((p) => p !== void 0));
7952	}
7953	function handlePreloadError(err) {
7954		const e = new Event("vite:preloadError", { cancelable: true });
7955		e.payload = err;
7956		window.dispatchEvent(e);
7957		if (!e.defaultPrevented) throw err;
7958	}
7959	return promise.then((res) => {
7960		for (const item of res || []) {
7961			if (item.status !== "rejected") continue;
7962			handlePreloadError(item.reason);
7963		}
7964		return baseModule().catch(handlePreloadError);
7965	});
7966};
7967//#endregion
7968export { Teleport as $, notNullish as A, withCtx as At, isObject$1 as B, toValue as Bt, unrefElement as C, resolveDynamicComponent as Ct, useNavigatorLanguage as D, watch as Dt, useMediaQuery as E, useTemplateRef as Et, EXTERNAL_URL_RE as F, reactive as Ft, Transition as G, normalize as H, normalizeClass as Ht, escapeRegExp as I, readonly as It, vModelSelect as J, createApp as K, inBrowser as L, ref as Lt, tryOnScopeDispose as M, isRef as Mt, watchDebounced as N, markRaw as Nt, useSessionStorage as O, watchEffect as Ot, whenever as P, onScopeDispose as Pt, Fragment as Q, isActive as R, shallowReadonly as Rt, onKeyStroke as S, resolveComponent as St, useLocalStorage as T, useSlots as Tt, treatAsHtml as U, normalizeStyle as Ut, isRelativeBase as V, unref as Vt, ClientOnly as W, toDisplayString as Wt, vShow as X, vModelText as Y, withModifiers as Z, dataSymbol as _, onUpdated as _t, useCopyCode as a, createStaticVNode as at, useData as b, renderList as bt, RouterSymbol as c, defineAsyncComponent as ct, useRouter as d, inject as dt, computed as et, useIcon as f, mergeProps as ft, withBase as g, onUnmounted as gt, runtimeBase as h, onMounted as ht, useUpdateHead as i, createElementBlock as it, toArray as j, withDirectives as jt, useWindowScroll as k, watchPostEffect as kt, createRouter as l, defineComponent as lt, pathToFile as m, onBeforeUnmount as mt, _plugin_vue_export_helper_default as n, createBlock as nt, useCodeGroups as o, createTextVNode as ot, onContentUpdated as p, nextTick as pt, createSSRApp as q, usePrefetch as r, createCommentVNode as rt, Content as s, createVNode as st, __vitePreload as t, createBaseVNode as tt, useRoute as u, h as ut, initData as v, openBlock as vt, useEventListener as w, useId as wt, computedAsync as x, renderSlot as xt, siteDataRef as y, provide as yt, isExternal as z, shallowRef as zt };