cck-ui 0.0.1 → 0.0.2

package/dist/index.full.mjs

@@ -1,4 +1,6 @@
-/*! CCK UI v0.0.1 */
+/*! CCK UI v0.0.2 */
+
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, getCurrentInstance, inject, mergeProps, normalizeClass, openBlock, readonly, ref, renderSlot, resolveDynamicComponent, unref, useSlots, withCtx } from "vue";
 
 //#region ../../packages/cck-ui/make-installer.ts
 const INSTALLED_KEY = Symbol("INSTALLED_KEY");
@@ -999,29 +1001,10 @@ function makeMap(str) {
 	for (const key of str.split(",")) map[key] = 1;
 	return (val) => val in map;
 }
-const EMPTY_OBJ = {};
-const EMPTY_ARR = [];
-const NO = () => false;
-const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && (key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
-const isModelListener = (key) => key.startsWith("onUpdate:");
-const extend = Object.assign;
-const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
 const isArray = Array.isArray;
-const isMap = (val) => toTypeString(val) === "[object Map]";
-const isFunction = (val) => typeof val === "function";
 const isString = (val) => typeof val === "string";
-const isSymbol = (val) => typeof val === "symbol";
-const isObject = (val) => val !== null && typeof val === "object";
-const isPromise = (val) => {
-	return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
-};
-const objectToString = Object.prototype.toString;
-const toTypeString = (value) => objectToString.call(value);
-const toRawType = (value) => {
-	return toTypeString(value).slice(8, -1);
-};
-const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
 const cacheStringFunction = (fn) => {
 	const cache = /* @__PURE__ */ Object.create(null);
 	return ((str) => {
@@ -1040,47 +1023,6 @@ const capitalize = cacheStringFunction((str) => {
 const toHandlerKey = cacheStringFunction((str) => {
 	return str ? `on${capitalize(str)}` : ``;
 });
-const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
-let _globalThis;
-const getGlobalThis = () => {
-	return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
-};
-function normalizeStyle(value) {
-	if (isArray(value)) {
-		const res = {};
-		for (let i = 0; i < value.length; i++) {
-			const item = value[i];
-			const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
-			if (normalized) for (const key in normalized) res[key] = normalized[key];
-		}
-		return res;
-	} else if (isString(value) || isObject(value)) return value;
-}
-const listDelimiterRE = /;(?![^(]*\))/g;
-const propertyDelimiterRE = /:([^]+)/;
-const styleCommentRE = /\/\*[^]*?\*\//g;
-function parseStringStyle(cssText) {
-	const ret = {};
-	cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
-		if (item) {
-			const tmp = item.split(propertyDelimiterRE);
-			tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
-		}
-	});
-	return ret;
-}
-function normalizeClass(value) {
-	let res = "";
-	if (isString(value)) res = value;
-	else if (isArray(value)) for (let i = 0; i < value.length; i++) {
-		const normalized = normalizeClass(value[i]);
-		if (normalized) res += normalized + " ";
-	}
-	else if (isObject(value)) {
-		for (const name in value) if (value[name]) res += name + " ";
-	}
-	return res.trim();
-}
 const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
 const isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
 
@@ -1144,1355 +1086,6 @@ const withInstall = (main, extra) => {
 	return main;
 };
 
-//#endregion
-//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.35/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
-/**
-* @vue/reactivity v3.5.35
-* (c) 2018-present Yuxi (Evan) You and Vue contributors
-* @license MIT
-**/
-let activeSub;
-let batchDepth = 0;
-let batchedSub;
-let batchedComputed;
-function batch(sub, isComputed = false) {
-	sub.flags |= 8;
-	if (isComputed) {
-		sub.next = batchedComputed;
-		batchedComputed = sub;
-		return;
-	}
-	sub.next = batchedSub;
-	batchedSub = sub;
-}
-function startBatch() {
-	batchDepth++;
-}
-function endBatch() {
-	if (--batchDepth > 0) return;
-	if (batchedComputed) {
-		let e = batchedComputed;
-		batchedComputed = void 0;
-		while (e) {
-			const next = e.next;
-			e.next = void 0;
-			e.flags &= -9;
-			e = next;
-		}
-	}
-	let error;
-	while (batchedSub) {
-		let e = batchedSub;
-		batchedSub = void 0;
-		while (e) {
-			const next = e.next;
-			e.next = void 0;
-			e.flags &= -9;
-			if (e.flags & 1) try {
-				e.trigger();
-			} catch (err) {
-				if (!error) error = err;
-			}
-			e = next;
-		}
-	}
-	if (error) throw error;
-}
-function prepareDeps(sub) {
-	for (let link = sub.deps; link; link = link.nextDep) {
-		link.version = -1;
-		link.prevActiveLink = link.dep.activeLink;
-		link.dep.activeLink = link;
-	}
-}
-function cleanupDeps(sub) {
-	let head;
-	let tail = sub.depsTail;
-	let link = tail;
-	while (link) {
-		const prev = link.prevDep;
-		if (link.version === -1) {
-			if (link === tail) tail = prev;
-			removeSub(link);
-			removeDep(link);
-		} else head = link;
-		link.dep.activeLink = link.prevActiveLink;
-		link.prevActiveLink = void 0;
-		link = prev;
-	}
-	sub.deps = head;
-	sub.depsTail = tail;
-}
-function isDirty(sub) {
-	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;
-	if (sub._dirty) return true;
-	return false;
-}
-function refreshComputed(computed) {
-	if (computed.flags & 4 && !(computed.flags & 16)) return;
-	computed.flags &= -17;
-	if (computed.globalVersion === globalVersion) return;
-	computed.globalVersion = globalVersion;
-	if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) return;
-	computed.flags |= 2;
-	const dep = computed.dep;
-	const prevSub = activeSub;
-	const prevShouldTrack = shouldTrack;
-	activeSub = computed;
-	shouldTrack = true;
-	try {
-		prepareDeps(computed);
-		const value = computed.fn(computed._value);
-		if (dep.version === 0 || hasChanged(value, computed._value)) {
-			computed.flags |= 128;
-			computed._value = value;
-			dep.version++;
-		}
-	} catch (err) {
-		dep.version++;
-		throw err;
-	} finally {
-		activeSub = prevSub;
-		shouldTrack = prevShouldTrack;
-		cleanupDeps(computed);
-		computed.flags &= -3;
-	}
-}
-function removeSub(link, soft = false) {
-	const { dep, prevSub, nextSub } = link;
-	if (prevSub) {
-		prevSub.nextSub = nextSub;
-		link.prevSub = void 0;
-	}
-	if (nextSub) {
-		nextSub.prevSub = prevSub;
-		link.nextSub = void 0;
-	}
-	if (dep.subs === link) {
-		dep.subs = prevSub;
-		if (!prevSub && dep.computed) {
-			dep.computed.flags &= -5;
-			for (let l = dep.computed.deps; l; l = l.nextDep) removeSub(l, true);
-		}
-	}
-	if (!soft && !--dep.sc && dep.map) dep.map.delete(dep.key);
-}
-function removeDep(link) {
-	const { prevDep, nextDep } = link;
-	if (prevDep) {
-		prevDep.nextDep = nextDep;
-		link.prevDep = void 0;
-	}
-	if (nextDep) {
-		nextDep.prevDep = prevDep;
-		link.nextDep = void 0;
-	}
-}
-let shouldTrack = true;
-const trackStack = [];
-function pauseTracking() {
-	trackStack.push(shouldTrack);
-	shouldTrack = false;
-}
-function resetTracking() {
-	const last = trackStack.pop();
-	shouldTrack = last === void 0 ? true : last;
-}
-let globalVersion = 0;
-var Link = class {
-	constructor(sub, dep) {
-		this.sub = sub;
-		this.dep = dep;
-		this.version = dep.version;
-		this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
-	}
-};
-var Dep = class {
-	constructor(computed) {
-		this.computed = computed;
-		this.version = 0;
-		this.activeLink = void 0;
-		this.subs = void 0;
-		this.map = void 0;
-		this.key = void 0;
-		this.sc = 0;
-		this.__v_skip = true;
-	}
-	track(debugInfo) {
-		if (!activeSub || !shouldTrack || activeSub === this.computed) return;
-		let link = this.activeLink;
-		if (link === void 0 || link.sub !== activeSub) {
-			link = this.activeLink = new Link(activeSub, this);
-			if (!activeSub.deps) activeSub.deps = activeSub.depsTail = link;
-			else {
-				link.prevDep = activeSub.depsTail;
-				activeSub.depsTail.nextDep = link;
-				activeSub.depsTail = link;
-			}
-			addSub(link);
-		} else if (link.version === -1) {
-			link.version = this.version;
-			if (link.nextDep) {
-				const next = link.nextDep;
-				next.prevDep = link.prevDep;
-				if (link.prevDep) link.prevDep.nextDep = next;
-				link.prevDep = activeSub.depsTail;
-				link.nextDep = void 0;
-				activeSub.depsTail.nextDep = link;
-				activeSub.depsTail = link;
-				if (activeSub.deps === link) activeSub.deps = next;
-			}
-		}
-		return link;
-	}
-	trigger(debugInfo) {
-		this.version++;
-		globalVersion++;
-		this.notify(debugInfo);
-	}
-	notify(debugInfo) {
-		startBatch();
-		try {
-			for (let link = this.subs; link; link = link.prevSub) if (link.sub.notify()) link.sub.dep.notify();
-		} finally {
-			endBatch();
-		}
-	}
-};
-function addSub(link) {
-	link.dep.sc++;
-	if (link.sub.flags & 4) {
-		const computed = link.dep.computed;
-		if (computed && !link.dep.subs) {
-			computed.flags |= 20;
-			for (let l = computed.deps; l; l = l.nextDep) addSub(l);
-		}
-		const currentTail = link.dep.subs;
-		if (currentTail !== link) {
-			link.prevSub = currentTail;
-			if (currentTail) currentTail.nextSub = link;
-		}
-		link.dep.subs = link;
-	}
-}
-const targetMap = /* @__PURE__ */ new WeakMap();
-const ITERATE_KEY = /* @__PURE__ */ Symbol("");
-const MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol("");
-const ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("");
-function track(target, type, key) {
-	if (shouldTrack && activeSub) {
-		let depsMap = targetMap.get(target);
-		if (!depsMap) targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
-		let dep = depsMap.get(key);
-		if (!dep) {
-			depsMap.set(key, dep = new Dep());
-			dep.map = depsMap;
-			dep.key = key;
-		}
-		dep.track();
-	}
-}
-function trigger(target, type, key, newValue, oldValue, oldTarget) {
-	const depsMap = targetMap.get(target);
-	if (!depsMap) {
-		globalVersion++;
-		return;
-	}
-	const run = (dep) => {
-		if (dep) dep.trigger();
-	};
-	startBatch();
-	if (type === "clear") depsMap.forEach(run);
-	else {
-		const targetIsArray = isArray(target);
-		const isArrayIndex = targetIsArray && isIntegerKey(key);
-		if (targetIsArray && key === "length") {
-			const newLength = Number(newValue);
-			depsMap.forEach((dep, key2) => {
-				if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) run(dep);
-			});
-		} else {
-			if (key !== void 0 || depsMap.has(void 0)) run(depsMap.get(key));
-			if (isArrayIndex) run(depsMap.get(ARRAY_ITERATE_KEY));
-			switch (type) {
-				case "add":
-					if (!targetIsArray) {
-						run(depsMap.get(ITERATE_KEY));
-						if (isMap(target)) run(depsMap.get(MAP_KEY_ITERATE_KEY));
-					} else if (isArrayIndex) run(depsMap.get("length"));
-					break;
-				case "delete":
-					if (!targetIsArray) {
-						run(depsMap.get(ITERATE_KEY));
-						if (isMap(target)) run(depsMap.get(MAP_KEY_ITERATE_KEY));
-					}
-					break;
-				case "set":
-					if (isMap(target)) run(depsMap.get(ITERATE_KEY));
-					break;
-			}
-		}
-	}
-	endBatch();
-}
-function reactiveReadArray(array) {
-	const raw = /* @__PURE__ */ toRaw(array);
-	if (raw === array) return raw;
-	track(raw, "iterate", ARRAY_ITERATE_KEY);
-	return /* @__PURE__ */ isShallow(array) ? raw : raw.map(toReactive);
-}
-function shallowReadArray(arr) {
-	track(arr = /* @__PURE__ */ toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
-	return arr;
-}
-function toWrapped(target, item) {
-	if (/* @__PURE__ */ isReadonly(target)) return /* @__PURE__ */ isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
-	return toReactive(item);
-}
-const arrayInstrumentations = {
-	__proto__: null,
-	[Symbol.iterator]() {
-		return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
-	},
-	concat(...args) {
-		return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
-	},
-	entries() {
-		return iterator(this, "entries", (value) => {
-			value[1] = toWrapped(this, value[1]);
-			return value;
-		});
-	},
-	every(fn, thisArg) {
-		return apply(this, "every", fn, thisArg, void 0, arguments);
-	},
-	filter(fn, thisArg) {
-		return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments);
-	},
-	find(fn, thisArg) {
-		return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments);
-	},
-	findIndex(fn, thisArg) {
-		return apply(this, "findIndex", fn, thisArg, void 0, arguments);
-	},
-	findLast(fn, thisArg) {
-		return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments);
-	},
-	findLastIndex(fn, thisArg) {
-		return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
-	},
-	forEach(fn, thisArg) {
-		return apply(this, "forEach", fn, thisArg, void 0, arguments);
-	},
-	includes(...args) {
-		return searchProxy(this, "includes", args);
-	},
-	indexOf(...args) {
-		return searchProxy(this, "indexOf", args);
-	},
-	join(separator) {
-		return reactiveReadArray(this).join(separator);
-	},
-	lastIndexOf(...args) {
-		return searchProxy(this, "lastIndexOf", args);
-	},
-	map(fn, thisArg) {
-		return apply(this, "map", fn, thisArg, void 0, arguments);
-	},
-	pop() {
-		return noTracking(this, "pop");
-	},
-	push(...args) {
-		return noTracking(this, "push", args);
-	},
-	reduce(fn, ...args) {
-		return reduce(this, "reduce", fn, args);
-	},
-	reduceRight(fn, ...args) {
-		return reduce(this, "reduceRight", fn, args);
-	},
-	shift() {
-		return noTracking(this, "shift");
-	},
-	some(fn, thisArg) {
-		return apply(this, "some", fn, thisArg, void 0, arguments);
-	},
-	splice(...args) {
-		return noTracking(this, "splice", args);
-	},
-	toReversed() {
-		return reactiveReadArray(this).toReversed();
-	},
-	toSorted(comparer) {
-		return reactiveReadArray(this).toSorted(comparer);
-	},
-	toSpliced(...args) {
-		return reactiveReadArray(this).toSpliced(...args);
-	},
-	unshift(...args) {
-		return noTracking(this, "unshift", args);
-	},
-	values() {
-		return iterator(this, "values", (item) => toWrapped(this, item));
-	}
-};
-function iterator(self, method, wrapValue) {
-	const arr = shallowReadArray(self);
-	const iter = arr[method]();
-	if (arr !== self && !/* @__PURE__ */ isShallow(self)) {
-		iter._next = iter.next;
-		iter.next = () => {
-			const result = iter._next();
-			if (!result.done) result.value = wrapValue(result.value);
-			return result;
-		};
-	}
-	return iter;
-}
-const arrayProto = Array.prototype;
-function apply(self, method, fn, thisArg, wrappedRetFn, args) {
-	const arr = shallowReadArray(self);
-	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
-	const methodFn = arr[method];
-	if (methodFn !== arrayProto[method]) {
-		const result2 = methodFn.apply(self, args);
-		return needsWrap ? toReactive(result2) : result2;
-	}
-	let wrappedFn = fn;
-	if (arr !== self) {
-		if (needsWrap) wrappedFn = function(item, index) {
-			return fn.call(this, toWrapped(self, item), index, self);
-		};
-		else if (fn.length > 2) wrappedFn = function(item, index) {
-			return fn.call(this, item, index, self);
-		};
-	}
-	const result = methodFn.call(arr, wrappedFn, thisArg);
-	return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
-}
-function reduce(self, method, fn, args) {
-	const arr = shallowReadArray(self);
-	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
-	let wrappedFn = fn;
-	let wrapInitialAccumulator = false;
-	if (arr !== self) {
-		if (needsWrap) {
-			wrapInitialAccumulator = args.length === 0;
-			wrappedFn = function(acc, item, index) {
-				if (wrapInitialAccumulator) {
-					wrapInitialAccumulator = false;
-					acc = toWrapped(self, acc);
-				}
-				return fn.call(this, acc, toWrapped(self, item), index, self);
-			};
-		} else if (fn.length > 3) wrappedFn = function(acc, item, index) {
-			return fn.call(this, acc, item, index, self);
-		};
-	}
-	const result = arr[method](wrappedFn, ...args);
-	return wrapInitialAccumulator ? toWrapped(self, result) : result;
-}
-function searchProxy(self, method, args) {
-	const arr = /* @__PURE__ */ toRaw(self);
-	track(arr, "iterate", ARRAY_ITERATE_KEY);
-	const res = arr[method](...args);
-	if ((res === -1 || res === false) && /* @__PURE__ */ isProxy(args[0])) {
-		args[0] = /* @__PURE__ */ toRaw(args[0]);
-		return arr[method](...args);
-	}
-	return res;
-}
-function noTracking(self, method, args = []) {
-	pauseTracking();
-	startBatch();
-	const res = (/* @__PURE__ */ toRaw(self))[method].apply(self, args);
-	endBatch();
-	resetTracking();
-	return res;
-}
-const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
-const builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
-function hasOwnProperty(key) {
-	if (!isSymbol(key)) key = String(key);
-	const obj = /* @__PURE__ */ toRaw(this);
-	track(obj, "has", key);
-	return obj.hasOwnProperty(key);
-}
-var BaseReactiveHandler = class {
-	constructor(_isReadonly = false, _isShallow = false) {
-		this._isReadonly = _isReadonly;
-		this._isShallow = _isShallow;
-	}
-	get(target, key, receiver) {
-		if (key === "__v_skip") return target["__v_skip"];
-		const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
-		if (key === "__v_isReactive") return !isReadonly2;
-		else if (key === "__v_isReadonly") return isReadonly2;
-		else if (key === "__v_isShallow") return isShallow2;
-		else if (key === "__v_raw") {
-			if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) return target;
-			return;
-		}
-		const targetIsArray = isArray(target);
-		if (!isReadonly2) {
-			let fn;
-			if (targetIsArray && (fn = arrayInstrumentations[key])) return fn;
-			if (key === "hasOwnProperty") return hasOwnProperty;
-		}
-		const res = Reflect.get(target, key, /* @__PURE__ */ isRef(target) ? target : receiver);
-		if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) return res;
-		if (!isReadonly2) track(target, "get", key);
-		if (isShallow2) return res;
-		if (/* @__PURE__ */ isRef(res)) {
-			const value = targetIsArray && isIntegerKey(key) ? res : res.value;
-			return isReadonly2 && isObject(value) ? /* @__PURE__ */ readonly(value) : value;
-		}
-		if (isObject(res)) return isReadonly2 ? /* @__PURE__ */ readonly(res) : /* @__PURE__ */ reactive(res);
-		return res;
-	}
-};
-var MutableReactiveHandler = class extends BaseReactiveHandler {
-	constructor(isShallow2 = false) {
-		super(false, isShallow2);
-	}
-	set(target, key, value, receiver) {
-		let oldValue = target[key];
-		const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
-		if (!this._isShallow) {
-			const isOldValueReadonly = /* @__PURE__ */ isReadonly(oldValue);
-			if (!/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) {
-				oldValue = /* @__PURE__ */ toRaw(oldValue);
-				value = /* @__PURE__ */ toRaw(value);
-			}
-			if (!isArrayWithIntegerKey && /* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) if (isOldValueReadonly) return true;
-			else {
-				oldValue.value = value;
-				return true;
-			}
-		}
-		const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
-		const result = Reflect.set(target, key, value, /* @__PURE__ */ isRef(target) ? target : receiver);
-		if (target === /* @__PURE__ */ toRaw(receiver)) {
-			if (!hadKey) trigger(target, "add", key, value);
-			else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
-		}
-		return result;
-	}
-	deleteProperty(target, key) {
-		const hadKey = hasOwn(target, key);
-		const oldValue = target[key];
-		const result = Reflect.deleteProperty(target, key);
-		if (result && hadKey) trigger(target, "delete", key, void 0, oldValue);
-		return result;
-	}
-	has(target, key) {
-		const result = Reflect.has(target, key);
-		if (!isSymbol(key) || !builtInSymbols.has(key)) track(target, "has", key);
-		return result;
-	}
-	ownKeys(target) {
-		track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
-		return Reflect.ownKeys(target);
-	}
-};
-var ReadonlyReactiveHandler = class extends BaseReactiveHandler {
-	constructor(isShallow2 = false) {
-		super(true, isShallow2);
-	}
-	set(target, key) {
-		return true;
-	}
-	deleteProperty(target, key) {
-		return true;
-	}
-};
-const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
-const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
-const toShallow = (value) => value;
-const getProto = (v) => Reflect.getPrototypeOf(v);
-function createIterableMethod(method, isReadonly2, isShallow2) {
-	return function(...args) {
-		const target = this["__v_raw"];
-		const rawTarget = /* @__PURE__ */ toRaw(target);
-		const targetIsMap = isMap(rawTarget);
-		const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
-		const isKeyOnly = method === "keys" && targetIsMap;
-		const innerIterator = target[method](...args);
-		const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
-		!isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
-		return extend(Object.create(innerIterator), { next() {
-			const { value, done } = innerIterator.next();
-			return done ? {
-				value,
-				done
-			} : {
-				value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
-				done
-			};
-		} });
-	};
-}
-function createReadonlyMethod(type) {
-	return function(...args) {
-		return type === "delete" ? false : type === "clear" ? void 0 : this;
-	};
-}
-function createInstrumentations(readonly, shallow) {
-	const instrumentations = {
-		get(key) {
-			const target = this["__v_raw"];
-			const rawTarget = /* @__PURE__ */ toRaw(target);
-			const rawKey = /* @__PURE__ */ toRaw(key);
-			if (!readonly) {
-				if (hasChanged(key, rawKey)) track(rawTarget, "get", key);
-				track(rawTarget, "get", rawKey);
-			}
-			const { has } = getProto(rawTarget);
-			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
-			if (has.call(rawTarget, key)) return wrap(target.get(key));
-			else if (has.call(rawTarget, rawKey)) return wrap(target.get(rawKey));
-			else if (target !== rawTarget) target.get(key);
-		},
-		get size() {
-			const target = this["__v_raw"];
-			!readonly && track(/* @__PURE__ */ toRaw(target), "iterate", ITERATE_KEY);
-			return target.size;
-		},
-		has(key) {
-			const target = this["__v_raw"];
-			const rawTarget = /* @__PURE__ */ toRaw(target);
-			const rawKey = /* @__PURE__ */ toRaw(key);
-			if (!readonly) {
-				if (hasChanged(key, rawKey)) track(rawTarget, "has", key);
-				track(rawTarget, "has", rawKey);
-			}
-			return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
-		},
-		forEach(callback, thisArg) {
-			const observed = this;
-			const target = observed["__v_raw"];
-			const rawTarget = /* @__PURE__ */ toRaw(target);
-			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
-			!readonly && track(rawTarget, "iterate", ITERATE_KEY);
-			return target.forEach((value, key) => {
-				return callback.call(thisArg, wrap(value), wrap(key), observed);
-			});
-		}
-	};
-	extend(instrumentations, readonly ? {
-		add: createReadonlyMethod("add"),
-		set: createReadonlyMethod("set"),
-		delete: createReadonlyMethod("delete"),
-		clear: createReadonlyMethod("clear")
-	} : {
-		add(value) {
-			const target = /* @__PURE__ */ toRaw(this);
-			const proto = getProto(target);
-			const rawValue = /* @__PURE__ */ toRaw(value);
-			const valueToAdd = !shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value) ? rawValue : value;
-			if (!(proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue))) {
-				target.add(valueToAdd);
-				trigger(target, "add", valueToAdd, valueToAdd);
-			}
-			return this;
-		},
-		set(key, value) {
-			if (!shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) value = /* @__PURE__ */ toRaw(value);
-			const target = /* @__PURE__ */ toRaw(this);
-			const { has, get } = getProto(target);
-			let hadKey = has.call(target, key);
-			if (!hadKey) {
-				key = /* @__PURE__ */ toRaw(key);
-				hadKey = has.call(target, key);
-			}
-			const oldValue = get.call(target, key);
-			target.set(key, value);
-			if (!hadKey) trigger(target, "add", key, value);
-			else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
-			return this;
-		},
-		delete(key) {
-			const target = /* @__PURE__ */ toRaw(this);
-			const { has, get } = getProto(target);
-			let hadKey = has.call(target, key);
-			if (!hadKey) {
-				key = /* @__PURE__ */ toRaw(key);
-				hadKey = has.call(target, key);
-			}
-			const oldValue = get ? get.call(target, key) : void 0;
-			const result = target.delete(key);
-			if (hadKey) trigger(target, "delete", key, void 0, oldValue);
-			return result;
-		},
-		clear() {
-			const target = /* @__PURE__ */ toRaw(this);
-			const hadItems = target.size !== 0;
-			const oldTarget = void 0;
-			const result = target.clear();
-			if (hadItems) trigger(target, "clear", void 0, void 0, oldTarget);
-			return result;
-		}
-	});
-	[
-		"keys",
-		"values",
-		"entries",
-		Symbol.iterator
-	].forEach((method) => {
-		instrumentations[method] = createIterableMethod(method, readonly, shallow);
-	});
-	return instrumentations;
-}
-function createInstrumentationGetter(isReadonly2, shallow) {
-	const instrumentations = createInstrumentations(isReadonly2, shallow);
-	return (target, key, receiver) => {
-		if (key === "__v_isReactive") return !isReadonly2;
-		else if (key === "__v_isReadonly") return isReadonly2;
-		else if (key === "__v_raw") return target;
-		return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
-	};
-}
-const mutableCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, false) };
-const readonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, false) };
-const reactiveMap = /* @__PURE__ */ new WeakMap();
-const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
-const readonlyMap = /* @__PURE__ */ new WeakMap();
-const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
-function targetTypeMap(rawType) {
-	switch (rawType) {
-		case "Object":
-		case "Array": return 1;
-		case "Map":
-		case "Set":
-		case "WeakMap":
-		case "WeakSet": return 2;
-		default: return 0;
-	}
-}
-// @__NO_SIDE_EFFECTS__
-function reactive(target) {
-	if (/* @__PURE__ */ isReadonly(target)) return target;
-	return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
-}
-// @__NO_SIDE_EFFECTS__
-function readonly(target) {
-	return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
-}
-function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
-	if (!isObject(target)) return target;
-	if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) return target;
-	if (target["__v_skip"] || !Object.isExtensible(target)) return target;
-	const existingProxy = proxyMap.get(target);
-	if (existingProxy) return existingProxy;
-	const targetType = targetTypeMap(toRawType(target));
-	if (targetType === 0) return target;
-	const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
-	proxyMap.set(target, proxy);
-	return proxy;
-}
-// @__NO_SIDE_EFFECTS__
-function isReactive(value) {
-	if (/* @__PURE__ */ isReadonly(value)) return /* @__PURE__ */ isReactive(value["__v_raw"]);
-	return !!(value && value["__v_isReactive"]);
-}
-// @__NO_SIDE_EFFECTS__
-function isReadonly(value) {
-	return !!(value && value["__v_isReadonly"]);
-}
-// @__NO_SIDE_EFFECTS__
-function isShallow(value) {
-	return !!(value && value["__v_isShallow"]);
-}
-// @__NO_SIDE_EFFECTS__
-function isProxy(value) {
-	return value ? !!value["__v_raw"] : false;
-}
-// @__NO_SIDE_EFFECTS__
-function toRaw(observed) {
-	const raw = observed && observed["__v_raw"];
-	return raw ? /* @__PURE__ */ toRaw(raw) : observed;
-}
-const toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value;
-const toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value;
-// @__NO_SIDE_EFFECTS__
-function isRef(r) {
-	return r ? r["__v_isRef"] === true : false;
-}
-// @__NO_SIDE_EFFECTS__
-function ref(value) {
-	return createRef(value, false);
-}
-function createRef(rawValue, shallow) {
-	if (/* @__PURE__ */ isRef(rawValue)) return rawValue;
-	return new RefImpl(rawValue, shallow);
-}
-var RefImpl = class {
-	constructor(value, isShallow2) {
-		this.dep = new Dep();
-		this["__v_isRef"] = true;
-		this["__v_isShallow"] = false;
-		this._rawValue = isShallow2 ? value : /* @__PURE__ */ toRaw(value);
-		this._value = isShallow2 ? value : toReactive(value);
-		this["__v_isShallow"] = isShallow2;
-	}
-	get value() {
-		this.dep.track();
-		return this._value;
-	}
-	set value(newValue) {
-		const oldValue = this._rawValue;
-		const useDirectValue = this["__v_isShallow"] || /* @__PURE__ */ isShallow(newValue) || /* @__PURE__ */ isReadonly(newValue);
-		newValue = useDirectValue ? newValue : /* @__PURE__ */ toRaw(newValue);
-		if (hasChanged(newValue, oldValue)) {
-			this._rawValue = newValue;
-			this._value = useDirectValue ? newValue : toReactive(newValue);
-			this.dep.trigger();
-		}
-	}
-};
-function unref(ref2) {
-	return /* @__PURE__ */ isRef(ref2) ? ref2.value : ref2;
-}
-var ComputedRefImpl = class {
-	constructor(fn, setter, isSSR) {
-		this.fn = fn;
-		this.setter = setter;
-		this._value = void 0;
-		this.dep = new Dep(this);
-		this.__v_isRef = true;
-		this.deps = void 0;
-		this.depsTail = void 0;
-		this.flags = 16;
-		this.globalVersion = globalVersion - 1;
-		this.next = void 0;
-		this.effect = this;
-		this["__v_isReadonly"] = !setter;
-		this.isSSR = isSSR;
-	}
-	notify() {
-		this.flags |= 16;
-		if (!(this.flags & 8) && activeSub !== this) {
-			batch(this, true);
-			return true;
-		}
-	}
-	get value() {
-		const link = this.dep.track();
-		refreshComputed(this);
-		if (link) link.version = this.dep.version;
-		return this._value;
-	}
-	set value(newValue) {
-		if (this.setter) this.setter(newValue);
-	}
-};
-// @__NO_SIDE_EFFECTS__
-function computed$1(getterOrOptions, debugOptions, isSSR = false) {
-	let getter;
-	let setter;
-	if (isFunction(getterOrOptions)) getter = getterOrOptions;
-	else {
-		getter = getterOrOptions.get;
-		setter = getterOrOptions.set;
-	}
-	return new ComputedRefImpl(getter, setter, isSSR);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.35/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
-/**
-* @vue/runtime-core v3.5.35
-* (c) 2018-present Yuxi (Evan) You and Vue contributors
-* @license MIT
-**/
-function callWithErrorHandling(fn, instance, type, args) {
-	try {
-		return args ? fn(...args) : fn();
-	} catch (err) {
-		handleError(err, instance, type);
-	}
-}
-function callWithAsyncErrorHandling(fn, instance, type, args) {
-	if (isFunction(fn)) {
-		const res = callWithErrorHandling(fn, instance, type, args);
-		if (res && isPromise(res)) res.catch((err) => {
-			handleError(err, instance, type);
-		});
-		return res;
-	}
-	if (isArray(fn)) {
-		const values = [];
-		for (let i = 0; i < fn.length; i++) values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
-		return values;
-	}
-}
-function handleError(err, instance, type, throwInDev = true) {
-	const contextVNode = instance ? instance.vnode : null;
-	const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
-	if (instance) {
-		let cur = instance.parent;
-		const exposedInstance = instance.proxy;
-		const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
-		while (cur) {
-			const errorCapturedHooks = cur.ec;
-			if (errorCapturedHooks) {
-				for (let i = 0; i < errorCapturedHooks.length; i++) if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) return;
-			}
-			cur = cur.parent;
-		}
-		if (errorHandler) {
-			pauseTracking();
-			callWithErrorHandling(errorHandler, null, 10, [
-				err,
-				exposedInstance,
-				errorInfo
-			]);
-			resetTracking();
-			return;
-		}
-	}
-	logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
-}
-function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
-	if (throwInProd) throw err;
-	else console.error(err);
-}
-let devtools$1;
-let buffer = [];
-let devtoolsNotInstalled = false;
-function emit$1(event, ...args) {
-	if (devtools$1) devtools$1.emit(event, ...args);
-	else if (!devtoolsNotInstalled) buffer.push({
-		event,
-		args
-	});
-}
-const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated");
-// @__NO_SIDE_EFFECTS__
-function createDevtoolsComponentHook(hook) {
-	return (component) => {
-		emit$1(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : void 0, component);
-	};
-}
-let currentRenderingInstance = null;
-let currentScopeId = null;
-function setCurrentRenderingInstance(instance) {
-	const prev = currentRenderingInstance;
-	currentRenderingInstance = instance;
-	currentScopeId = instance && instance.type.__scopeId || null;
-	return prev;
-}
-function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
-	if (!ctx) return fn;
-	if (fn._n) return fn;
-	const renderFnWithContext = (...args) => {
-		if (renderFnWithContext._d) setBlockTracking(-1);
-		const prevInstance = setCurrentRenderingInstance(ctx);
-		let res;
-		try {
-			res = fn(...args);
-		} finally {
-			setCurrentRenderingInstance(prevInstance);
-			if (renderFnWithContext._d) setBlockTracking(1);
-		}
-		if (__VUE_PROD_DEVTOOLS__) devtoolsComponentUpdated(ctx);
-		return res;
-	};
-	renderFnWithContext._n = true;
-	renderFnWithContext._c = true;
-	renderFnWithContext._d = true;
-	return renderFnWithContext;
-}
-function inject(key, defaultValue, treatDefaultAsFactory = false) {
-	const instance = getCurrentInstance();
-	if (instance || currentApp) {
-		let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
-		if (provides && key in provides) return provides[key];
-		else if (arguments.length > 1) return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
-	}
-}
-const isTeleport = (type) => type.__isTeleport;
-function setTransitionHooks(vnode, hooks) {
-	if (vnode.shapeFlag & 6 && vnode.component) {
-		vnode.transition = hooks;
-		setTransitionHooks(vnode.component.subTree, hooks);
-	} else if (vnode.shapeFlag & 128) {
-		vnode.ssContent.transition = hooks.clone(vnode.ssContent);
-		vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
-	} else vnode.transition = hooks;
-}
-// @__NO_SIDE_EFFECTS__
-function defineComponent(options, extraOptions) {
-	return isFunction(options) ? /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))() : options;
-}
-const requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
-const cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
-const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
-function injectHook(type, hook, target = currentInstance, prepend = false) {
-	if (target) {
-		const hooks = target[type] || (target[type] = []);
-		const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
-			pauseTracking();
-			const reset = setCurrentInstance(target);
-			const res = callWithAsyncErrorHandling(hook, target, type, args);
-			reset();
-			resetTracking();
-			return res;
-		});
-		if (prepend) hooks.unshift(wrappedHook);
-		else hooks.push(wrappedHook);
-		return wrappedHook;
-	}
-}
-const createHook = (lifecycle) => (hook, target = currentInstance) => {
-	if (!isInSSRComponentSetup || lifecycle === "sp") injectHook(lifecycle, (...args) => hook(...args), target);
-};
-const onBeforeMount = createHook("bm");
-const onMounted = createHook("m");
-const onBeforeUpdate = createHook("bu");
-const onUpdated = createHook("u");
-const onBeforeUnmount = createHook("bum");
-const onUnmounted = createHook("um");
-const onServerPrefetch = createHook("sp");
-const onRenderTriggered = createHook("rtg");
-const onRenderTracked = createHook("rtc");
-const COMPONENTS = "components";
-const NULL_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol.for("v-ndc");
-function resolveDynamicComponent(component) {
-	if (isString(component)) return resolveAsset(COMPONENTS, component, false) || component;
-	else return component || NULL_DYNAMIC_COMPONENT;
-}
-function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
-	const instance = currentRenderingInstance || currentInstance;
-	if (instance) {
-		const Component = instance.type;
-		if (type === COMPONENTS) {
-			const selfName = getComponentName(Component, false);
-			if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) return Component;
-		}
-		const res = resolve(instance[type] || Component[type], name) || resolve(instance.appContext[type], name);
-		if (!res && maybeSelfReference) return Component;
-		return res;
-	}
-}
-function resolve(registry, name) {
-	return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
-}
-function renderSlot(slots, name, props = {}, fallback, noSlotted) {
-	if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
-		const hasProps = Object.keys(props).length > 0;
-		if (name !== "default") props.name = name;
-		return openBlock(), createBlock(Fragment, null, [createVNode("slot", props, fallback && fallback())], hasProps ? -2 : 64);
-	}
-	let slot = slots[name];
-	if (slot && slot._c) slot._d = false;
-	openBlock();
-	const validSlotContent = slot && ensureValidVNode(slot(props));
-	const slotKey = props.key || validSlotContent && validSlotContent.key;
-	const rendered = createBlock(Fragment, { key: (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) + (!validSlotContent && fallback ? "_fb" : "") }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 ? 64 : -2);
-	if (!noSlotted && rendered.scopeId) rendered.slotScopeIds = [rendered.scopeId + "-s"];
-	if (slot && slot._c) slot._d = true;
-	return rendered;
-}
-function ensureValidVNode(vnodes) {
-	return vnodes.some((child) => {
-		if (!isVNode(child)) return true;
-		if (child.type === Comment) return false;
-		if (child.type === Fragment && !ensureValidVNode(child.children)) return false;
-		return true;
-	}) ? vnodes : null;
-}
-function useSlots() {
-	return getContext("useSlots").slots;
-}
-function getContext(calledFunctionName) {
-	const i = getCurrentInstance();
-	return i.setupContext || (i.setupContext = createSetupContext(i));
-}
-function createAppContext() {
-	return {
-		app: null,
-		config: {
-			isNativeTag: NO,
-			performance: false,
-			globalProperties: {},
-			optionMergeStrategies: {},
-			errorHandler: void 0,
-			warnHandler: void 0,
-			compilerOptions: {}
-		},
-		mixins: [],
-		components: {},
-		directives: {},
-		provides: /* @__PURE__ */ Object.create(null),
-		optionsCache: /* @__PURE__ */ new WeakMap(),
-		propsCache: /* @__PURE__ */ new WeakMap(),
-		emitsCache: /* @__PURE__ */ new WeakMap()
-	};
-}
-let currentApp = null;
-const internalObjectProto = {};
-const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
-const isSuspense = (type) => type.__isSuspense;
-const Fragment = /* @__PURE__ */ Symbol.for("v-fgt");
-const Text = /* @__PURE__ */ Symbol.for("v-txt");
-const Comment = /* @__PURE__ */ Symbol.for("v-cmt");
-const blockStack = [];
-let currentBlock = null;
-function openBlock(disableTracking = false) {
-	blockStack.push(currentBlock = disableTracking ? null : []);
-}
-function closeBlock() {
-	blockStack.pop();
-	currentBlock = blockStack[blockStack.length - 1] || null;
-}
-let isBlockTreeEnabled = 1;
-function setBlockTracking(value, inVOnce = false) {
-	isBlockTreeEnabled += value;
-	if (value < 0 && currentBlock && inVOnce) currentBlock.hasOnce = true;
-}
-function setupBlock(vnode) {
-	vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
-	closeBlock();
-	if (isBlockTreeEnabled > 0 && currentBlock) currentBlock.push(vnode);
-	return vnode;
-}
-function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
-	return setupBlock(createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, true));
-}
-function createBlock(type, props, children, patchFlag, dynamicProps) {
-	return setupBlock(createVNode(type, props, children, patchFlag, dynamicProps, true));
-}
-function isVNode(value) {
-	return value ? value.__v_isVNode === true : false;
-}
-const normalizeKey = ({ key }) => key != null ? key : null;
-const normalizeRef = ({ ref, ref_key, ref_for }) => {
-	if (typeof ref === "number") ref = "" + ref;
-	return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? {
-		i: currentRenderingInstance,
-		r: ref,
-		k: ref_key,
-		f: !!ref_for
-	} : ref : null;
-};
-function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
-	const vnode = {
-		__v_isVNode: true,
-		__v_skip: true,
-		type,
-		props,
-		key: props && normalizeKey(props),
-		ref: props && normalizeRef(props),
-		scopeId: currentScopeId,
-		slotScopeIds: null,
-		children,
-		component: null,
-		suspense: null,
-		ssContent: null,
-		ssFallback: null,
-		dirs: null,
-		transition: null,
-		el: null,
-		anchor: null,
-		target: null,
-		targetStart: null,
-		targetAnchor: null,
-		staticCount: 0,
-		shapeFlag,
-		patchFlag,
-		dynamicProps,
-		dynamicChildren: null,
-		appContext: null,
-		ctx: currentRenderingInstance
-	};
-	if (needFullChildrenNormalization) {
-		normalizeChildren(vnode, children);
-		if (shapeFlag & 128) type.normalize(vnode);
-	} else if (children) vnode.shapeFlag |= isString(children) ? 8 : 16;
-	if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock && (vnode.patchFlag > 0 || shapeFlag & 6) && vnode.patchFlag !== 32) currentBlock.push(vnode);
-	return vnode;
-}
-const createVNode = _createVNode;
-function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
-	if (!type || type === NULL_DYNAMIC_COMPONENT) type = Comment;
-	if (isVNode(type)) {
-		const cloned = cloneVNode(type, props, true);
-		if (children) normalizeChildren(cloned, children);
-		if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) if (cloned.shapeFlag & 6) currentBlock[currentBlock.indexOf(type)] = cloned;
-		else currentBlock.push(cloned);
-		cloned.patchFlag = -2;
-		return cloned;
-	}
-	if (isClassComponent(type)) type = type.__vccOpts;
-	if (props) {
-		props = guardReactiveProps(props);
-		let { class: klass, style } = props;
-		if (klass && !isString(klass)) props.class = normalizeClass(klass);
-		if (isObject(style)) {
-			if (isProxy(style) && !isArray(style)) style = extend({}, style);
-			props.style = normalizeStyle(style);
-		}
-	}
-	const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
-	return createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, isBlockNode, true);
-}
-function guardReactiveProps(props) {
-	if (!props) return null;
-	return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
-}
-function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
-	const { props, ref, patchFlag, children, transition } = vnode;
-	const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
-	const cloned = {
-		__v_isVNode: true,
-		__v_skip: true,
-		type: vnode.type,
-		props: mergedProps,
-		key: mergedProps && normalizeKey(mergedProps),
-		ref: extraProps && extraProps.ref ? mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref,
-		scopeId: vnode.scopeId,
-		slotScopeIds: vnode.slotScopeIds,
-		children,
-		target: vnode.target,
-		targetStart: vnode.targetStart,
-		targetAnchor: vnode.targetAnchor,
-		staticCount: vnode.staticCount,
-		shapeFlag: vnode.shapeFlag,
-		patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
-		dynamicProps: vnode.dynamicProps,
-		dynamicChildren: vnode.dynamicChildren,
-		appContext: vnode.appContext,
-		dirs: vnode.dirs,
-		transition,
-		component: vnode.component,
-		suspense: vnode.suspense,
-		ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
-		ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
-		placeholder: vnode.placeholder,
-		el: vnode.el,
-		anchor: vnode.anchor,
-		ctx: vnode.ctx,
-		ce: vnode.ce
-	};
-	if (transition && cloneTransition) setTransitionHooks(cloned, transition.clone(cloned));
-	return cloned;
-}
-function createTextVNode(text = " ", flag = 0) {
-	return createVNode(Text, null, text, flag);
-}
-function createCommentVNode(text = "", asBlock = false) {
-	return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
-}
-function normalizeChildren(vnode, children) {
-	let type = 0;
-	const { shapeFlag } = vnode;
-	if (children == null) children = null;
-	else if (isArray(children)) type = 16;
-	else if (typeof children === "object") if (shapeFlag & 65) {
-		const slot = children.default;
-		if (slot) {
-			slot._c && (slot._d = false);
-			normalizeChildren(vnode, slot());
-			slot._c && (slot._d = true);
-		}
-		return;
-	} else {
-		type = 32;
-		const slotFlag = children._;
-		if (!slotFlag && !isInternalObject(children)) children._ctx = currentRenderingInstance;
-		else if (slotFlag === 3 && currentRenderingInstance) if (currentRenderingInstance.slots._ === 1) children._ = 1;
-		else {
-			children._ = 2;
-			vnode.patchFlag |= 1024;
-		}
-	}
-	else if (isFunction(children)) {
-		children = {
-			default: children,
-			_ctx: currentRenderingInstance
-		};
-		type = 32;
-	} else {
-		children = String(children);
-		if (shapeFlag & 64) {
-			type = 16;
-			children = [createTextVNode(children)];
-		} else type = 8;
-	}
-	vnode.children = children;
-	vnode.shapeFlag |= type;
-}
-function mergeProps(...args) {
-	const ret = {};
-	for (let i = 0; i < args.length; i++) {
-		const toMerge = args[i];
-		for (const key in toMerge) if (key === "class") {
-			if (ret.class !== toMerge.class) ret.class = normalizeClass([ret.class, toMerge.class]);
-		} else if (key === "style") ret.style = normalizeStyle([ret.style, toMerge.style]);
-		else if (isOn(key)) {
-			const existing = ret[key];
-			const incoming = toMerge[key];
-			if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) ret[key] = existing ? [].concat(existing, incoming) : incoming;
-			else if (incoming == null && existing == null && !isModelListener(key)) ret[key] = incoming;
-		} else if (key !== "") ret[key] = toMerge[key];
-	}
-	return ret;
-}
-const emptyAppContext = createAppContext();
-let currentInstance = null;
-const getCurrentInstance = () => currentInstance || currentRenderingInstance;
-let internalSetCurrentInstance;
-let setInSSRSetupState;
-{
-	const g = getGlobalThis();
-	const registerGlobalSetter = (key, setter) => {
-		let setters;
-		if (!(setters = g[key])) setters = g[key] = [];
-		setters.push(setter);
-		return (v) => {
-			if (setters.length > 1) setters.forEach((set) => set(v));
-			else setters[0](v);
-		};
-	};
-	internalSetCurrentInstance = registerGlobalSetter(`__VUE_INSTANCE_SETTERS__`, (v) => currentInstance = v);
-	setInSSRSetupState = registerGlobalSetter(`__VUE_SSR_SETTERS__`, (v) => isInSSRComponentSetup = v);
-}
-const setCurrentInstance = (instance) => {
-	const prev = currentInstance;
-	internalSetCurrentInstance(instance);
-	instance.scope.on();
-	return () => {
-		instance.scope.off();
-		internalSetCurrentInstance(prev);
-	};
-};
-let isInSSRComponentSetup = false;
-const attrsProxyHandlers = { get(target, key) {
-	track(target, "get", "");
-	return target[key];
-} };
-function createSetupContext(instance) {
-	const expose = (exposed) => {
-		instance.exposed = exposed || {};
-	};
-	return {
-		attrs: new Proxy(instance.attrs, attrsProxyHandlers),
-		slots: instance.slots,
-		emit: instance.emit,
-		expose
-	};
-}
-function getComponentName(Component, includeInferred = true) {
-	return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
-}
-function isClassComponent(value) {
-	return isFunction(value) && "__vccOpts" in value;
-}
-const computed = (getterOrOptions, debugOptions) => {
-	return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
-};
-
 //#endregion
 //#region ../../packages/hooks/use-namespace/index.ts
 const defaultNamespace = "c";
@@ -2857,9 +1450,9 @@ var button_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineCom
 				style: unref(buttonStyle),
 				onClick: unref(handleClick)
 			}), {
-				default: withCtx(() => [createBaseVNode("span", { class: normalizeClass(innerClass.value) }, [
+				default: withCtx(() => [createElementVNode("span", { class: normalizeClass(innerClass.value) }, [
 					_ctx.$slots["left-section"] ? (openBlock(), createElementBlock("span", _hoisted_1, [renderSlot(_ctx.$slots, "left-section")])) : __props.leftSection ? (openBlock(), createElementBlock("span", _hoisted_2, [(openBlock(), createBlock(resolveDynamicComponent(__props.leftSection)))])) : createCommentVNode("v-if", true),
-					createBaseVNode("span", { class: normalizeClass(labelClass.value) }, [renderSlot(_ctx.$slots, "default")], 2),
+					createElementVNode("span", { class: normalizeClass(labelClass.value) }, [renderSlot(_ctx.$slots, "default")], 2),
 					_ctx.$slots["right-section"] ? (openBlock(), createElementBlock("span", _hoisted_3, [renderSlot(_ctx.$slots, "right-section")])) : __props.rightSection ? (openBlock(), createElementBlock("span", _hoisted_4, [(openBlock(), createBlock(resolveDynamicComponent(__props.rightSection)))])) : createCommentVNode("v-if", true)
 				], 2)]),
 				_: 3