cck-ui 0.0.1 → 0.0.2

package/dist/index.full.js

@@ -1,10 +1,10 @@
-/*! CCK UI v0.0.1 */
+/*! CCK UI v0.0.2 */
 
 (function(global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CckUi = {})));
-})(this, function(exports) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('vue')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vue'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CckUi = {}), global.Vue));
+})(this, function(exports, vue) {
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
 //#region ../../packages/cck-ui/make-installer.ts
@@ -1006,29 +1006,10 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 		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) => {
@@ -1047,47 +1028,6 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 	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`);
 
@@ -1151,1355 +1091,6 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 		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";
@@ -2513,9 +1104,9 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 	};
 	const namespaceContextKey = Symbol("namespaceContextKey");
 	const useGetDerivedNamespace = (namespaceOverrides) => {
-		const derivedNamespace = namespaceOverrides || (getCurrentInstance() ? inject(namespaceContextKey, ref("c")) : ref("c"));
-		return computed(() => {
-			return unref(derivedNamespace) || "c";
+		const derivedNamespace = namespaceOverrides || ((0, vue.getCurrentInstance)() ? (0, vue.inject)(namespaceContextKey, (0, vue.ref)("c")) : (0, vue.ref)("c"));
+		return (0, vue.computed)(() => {
+			return (0, vue.unref)(derivedNamespace) || "c";
 		});
 	};
 	const useNamespace = (block, namespaceOverrides) => {
@@ -2563,8 +1154,8 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 //#endregion
 //#region ../../packages/hooks/use-prop/index.ts
 	const useProp = (name) => {
-		const vm = getCurrentInstance();
-		return computed(() => (vm?.proxy?.$props)?.[name]);
+		const vm = (0, vue.getCurrentInstance)();
+		return (0, vue.computed)(() => (vm?.proxy?.$props)?.[name]);
 	};
 
 //#endregion
@@ -2573,7 +1164,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 		if (typeof document === "undefined") return "light";
 		return document.documentElement.dataset.cColorScheme === "dark" ? "dark" : "light";
 	};
-	const colorScheme = ref(getCurrentScheme());
+	const colorScheme = (0, vue.ref)(getCurrentScheme());
 	if (typeof window !== "undefined") new MutationObserver(() => {
 		const newScheme = getCurrentScheme();
 		if (newScheme !== colorScheme.value) colorScheme.value = newScheme;
@@ -2581,7 +1172,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 		attributes: true,
 		attributeFilter: ["data-c-color-scheme"]
 	});
-	const useColorScheme = () => readonly(colorScheme);
+	const useColorScheme = () => (0, vue.readonly)(colorScheme);
 
 //#endregion
 //#region ../../packages/components/form/src/constants.ts
@@ -2591,9 +1182,9 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 //#region ../../packages/components/form/src/hooks/use-form-common-props.ts
 	const useFormDisabled = (fallback) => {
 		const disabled = useProp("disabled");
-		const form = inject(formContextKey, void 0);
-		return computed(() => {
-			return disabled.value ?? unref(fallback) ?? form?.disabled ?? false;
+		const form = (0, vue.inject)(formContextKey, void 0);
+		return (0, vue.computed)(() => {
+			return disabled.value ?? (0, vue.unref)(fallback) ?? form?.disabled ?? false;
 		});
 	};
 
@@ -2601,11 +1192,11 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 //#region ../../packages/components/button/src/use-button.ts
 	const useButton = (props, slots) => {
 		const _disabled = useFormDisabled();
-		const _ref = ref();
+		const _ref = (0, vue.ref)();
 		const { hasLeftSlot, hasRightSlot } = slots;
 		const hasLeftSection = hasLeftSlot || !!props.leftSection;
 		const hasRightSection = hasRightSlot || !!props.rightSection;
-		const _props = computed(() => {
+		const _props = (0, vue.computed)(() => {
 			const _attrs = {
 				"data-disabled": _disabled.value || props.loading || void 0,
 				"data-block": props.fullWidth || void 0,
@@ -2674,7 +1265,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 	};
 	function useButtonCustomStyle(props) {
 		const colorScheme = useColorScheme();
-		return computed(() => {
+		return (0, vue.computed)(() => {
 			const styles = {};
 			const { color, gradient, justify, variant } = props;
 			const scheme = colorScheme.value;
@@ -2768,7 +1359,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 		key: 3,
 		"data-position": "right"
 	};
-	var button_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	var button_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ (0, vue.defineComponent)({
 		name: "CButton",
 		__name: "button",
 		props: {
@@ -2834,9 +1425,9 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 			}
 		},
 		setup(__props, { expose: __expose }) {
-			const slots = useSlots();
-			const hasLeftSlot = computed(() => !!slots["left-section"]);
-			const hasRightSlot = computed(() => !!slots["right-section"]);
+			const slots = (0, vue.useSlots)();
+			const hasLeftSlot = (0, vue.computed)(() => !!slots["left-section"]);
+			const hasRightSlot = (0, vue.computed)(() => !!slots["right-section"]);
 			const props = __props;
 			const { _disabled, _props, _ref, handleClick } = useButton(props, {
 				hasLeftSlot: hasLeftSlot.value,
@@ -2844,14 +1435,14 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 			});
 			const buttonStyle = useButtonCustomStyle(props);
 			const ns = useNamespace("button");
-			const buttonClass = computed(() => [
+			const buttonClass = (0, vue.computed)(() => [
 				useNamespace("focus").b("auto"),
 				!_disabled.value && useNamespace("active").b(),
 				ns.e("root"),
 				ns.is("loading", props.loading)
 			]);
-			const innerClass = computed(() => [ns.e("inner")]);
-			const labelClass = computed(() => [ns.e("label")]);
+			const innerClass = (0, vue.computed)(() => [ns.e("inner")]);
+			const labelClass = (0, vue.computed)(() => [ns.e("label")]);
 			__expose({
 				disabled: _disabled.value,
 				ref: _ref,
@@ -2859,15 +1450,15 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 				variant: props.variant
 			});
 			return (_ctx, _cache) => {
-				return openBlock(), createBlock(resolveDynamicComponent(__props.tag), mergeProps(unref(_props), {
+				return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(__props.tag), (0, vue.mergeProps)((0, vue.unref)(_props), {
 					class: buttonClass.value,
-					style: unref(buttonStyle),
-					onClick: unref(handleClick)
+					style: (0, vue.unref)(buttonStyle),
+					onClick: (0, vue.unref)(handleClick)
 				}), {
-					default: withCtx(() => [createBaseVNode("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),
-						_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)
+					default: (0, vue.withCtx)(() => [(0, vue.createElementVNode)("span", { class: (0, vue.normalizeClass)(innerClass.value) }, [
+						_ctx.$slots["left-section"] ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_1, [(0, vue.renderSlot)(_ctx.$slots, "left-section")])) : __props.leftSection ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_2, [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(__props.leftSection)))])) : (0, vue.createCommentVNode)("v-if", true),
+						(0, vue.createElementVNode)("span", { class: (0, vue.normalizeClass)(labelClass.value) }, [(0, vue.renderSlot)(_ctx.$slots, "default")], 2),
+						_ctx.$slots["right-section"] ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_3, [(0, vue.renderSlot)(_ctx.$slots, "right-section")])) : __props.rightSection ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_4, [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(__props.rightSection)))])) : (0, vue.createCommentVNode)("v-if", true)
 					], 2)]),
 					_: 3
 				}, 16, [
@@ -2889,7 +1480,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 
 //#endregion
 //#region ../../packages/components/icon/src/icon.vue?vue&type=script&setup=true&lang.ts
-	var icon_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	var icon_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ (0, vue.defineComponent)({
 		name: "CIcon",
 		inheritAttrs: false,
 		__name: "icon",
@@ -2906,7 +1497,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 		setup(__props) {
 			const props = __props;
 			const ns = useNamespace("icon");
-			const style = computed(() => {
+			const style = (0, vue.computed)(() => {
 				const { size, color } = props;
 				if (!size && !color) return {};
 				return {
@@ -2915,10 +1506,10 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 				};
 			});
 			return (_ctx, _cache) => {
-				return openBlock(), createElementBlock("i", mergeProps({
-					class: unref(ns).b(),
+				return (0, vue.openBlock)(), (0, vue.createElementBlock)("i", (0, vue.mergeProps)({
+					class: (0, vue.unref)(ns).b(),
 					style: style.value
-				}, _ctx.$attrs), [renderSlot(_ctx.$slots, "default")], 16);
+				}, _ctx.$attrs), [(0, vue.renderSlot)(_ctx.$slots, "default")], 16);
 			};
 		}
 	});