vona-cli-set-api 1.0.496 → 1.1.3

package/cli/templates/create/project/cabloy-basic/boilerplate/src/suite/cabloy-basic/modules/basic-siteadmin/assets/site/ssr-cabloyBasicAdmin-5.0.0/client/assets/vue-BuTKVo3e.js

@@ -0,0 +1,1306 @@
+import { n as __esmMin } from "./rolldown-runtime-CSj9S6Td.js";
+import { A as isObject, C as init_shared_esm_bundler, D as isIntegerKey, E as isFunction, I as isSet, M as isPlainObject, O as isMap, T as isArray, V as makeMap, W as remove, _ as extend, b as hasOwn, d as EMPTY_OBJ, g as def, p as NOOP, q as toRawType, y as hasChanged, z as isSymbol } from "./vue-BeTi6w4D.js";
+//#region node_modules/.pnpm/@cabloy+vue-reactivity@3.5.16/node_modules/@cabloy/vue-reactivity/dist/reactivity.esm-bundler.js
+function effectScope(detached) {
+	return new EffectScope(detached);
+}
+function getCurrentScope() {
+	return activeEffectScope;
+}
+function onScopeDispose(fn, failSilently = false) {
+	if (activeEffectScope) activeEffectScope.cleanups.push(fn);
+}
+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;
+	const dep = computed.dep;
+	computed.flags |= 2;
+	if (dep.version > 0 && !computed.isSSR && computed.deps && !isDirty(computed)) {
+		computed.flags &= -3;
+		return;
+	}
+	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._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;
+	}
+}
+function pauseTracking() {
+	trackStack.push(shouldTrack);
+	shouldTrack = false;
+}
+function resetTracking() {
+	const last = trackStack.pop();
+	shouldTrack = last === void 0 ? true : last;
+}
+function cleanupEffect(e) {
+	const { cleanup } = e;
+	e.cleanup = void 0;
+	if (cleanup) {
+		const prevSub = activeSub;
+		activeSub = void 0;
+		try {
+			cleanup();
+		} finally {
+			activeSub = prevSub;
+		}
+	}
+}
+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;
+	}
+}
+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 getDepFromReactive(object, key) {
+	const depMap = targetMap.get(object);
+	return depMap && depMap.get(key);
+}
+function reactiveReadArray(array) {
+	const raw = toRaw(array);
+	if (raw === array) return raw;
+	track(raw, "iterate", ARRAY_ITERATE_KEY);
+	return isShallow(array) ? raw : raw.map(toReactive);
+}
+function shallowReadArray(arr) {
+	track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
+	return arr;
+}
+function iterator(self, method, wrapValue) {
+	const arr = shallowReadArray(self);
+	const iter = arr[method]();
+	if (arr !== self && !isShallow(self)) {
+		iter._next = iter.next;
+		iter.next = () => {
+			const result = iter._next();
+			if (result.value) result.value = wrapValue(result.value);
+			return result;
+		};
+	}
+	return iter;
+}
+function apply(self, method, fn, thisArg, wrappedRetFn, args) {
+	const arr = shallowReadArray(self);
+	const needsWrap = arr !== self && !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, toReactive(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);
+	let wrappedFn = fn;
+	if (arr !== self) {
+		if (!isShallow(self)) wrappedFn = function(acc, item, index) {
+			return fn.call(this, acc, toReactive(item), index, self);
+		};
+		else if (fn.length > 3) wrappedFn = function(acc, item, index) {
+			return fn.call(this, acc, item, index, self);
+		};
+	}
+	return arr[method](wrappedFn, ...args);
+}
+function searchProxy(self, method, args) {
+	const arr = toRaw(self);
+	track(arr, "iterate", ARRAY_ITERATE_KEY);
+	const res = arr[method](...args);
+	if ((res === -1 || res === false) && isProxy(args[0])) {
+		args[0] = toRaw(args[0]);
+		return arr[method](...args);
+	}
+	return res;
+}
+function noTracking(self, method, args = []) {
+	pauseTracking();
+	startBatch();
+	const res = toRaw(self)[method].apply(self, args);
+	endBatch();
+	resetTracking();
+	return res;
+}
+function hasOwnProperty(key) {
+	if (!isSymbol(key)) key = String(key);
+	const obj = toRaw(this);
+	track(obj, "has", key);
+	return obj.hasOwnProperty(key);
+}
+function unrefNested(ref) {
+	return isRef(ref) ? unrefNested(ref.value) : ref;
+}
+function createIterableMethod(method, isReadonly2, isShallow2) {
+	return function(...args) {
+		const target = this["__v_raw"];
+		const rawTarget = 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 {
+			next() {
+				const { value, done } = innerIterator.next();
+				return done ? {
+					value,
+					done
+				} : {
+					value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+					done
+				};
+			},
+			[Symbol.iterator]() {
+				return this;
+			}
+		};
+	};
+}
+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 = toRaw(target);
+			const rawKey = 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(toRaw(target), "iterate", ITERATE_KEY);
+			return Reflect.get(target, "size", target);
+		},
+		has(key) {
+			const target = this["__v_raw"];
+			const rawTarget = toRaw(target);
+			const rawKey = 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 = 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) {
+			if (!shallow && !isShallow(value) && !isReadonly(value)) value = toRaw(value);
+			const target = toRaw(this);
+			if (!getProto(target).has.call(target, value)) {
+				target.add(value);
+				trigger(target, "add", value, value);
+			}
+			return this;
+		},
+		set(key, value) {
+			if (!shallow && !isShallow(value) && !isReadonly(value)) value = toRaw(value);
+			const target = toRaw(this);
+			const { has, get } = getProto(target);
+			let hadKey = has.call(target, key);
+			if (!hadKey) {
+				key = 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 = toRaw(this);
+			const { has, get } = getProto(target);
+			let hadKey = has.call(target, key);
+			if (!hadKey) {
+				key = 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 = 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);
+	};
+}
+function targetTypeMap(rawType) {
+	switch (rawType) {
+		case "Object":
+		case "Array": return 1;
+		case "Map":
+		case "Set":
+		case "WeakMap":
+		case "WeakSet": return 2;
+		default: return 0;
+	}
+}
+function getTargetType(value) {
+	return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
+}
+function reactive(target) {
+	if (isReadonly(target)) return target;
+	return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+}
+function shallowReactive(target) {
+	return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
+}
+function readonly(target) {
+	return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+}
+function shallowReadonly(target) {
+	return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+	if (!isObject(target)) return target;
+	if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) return target;
+	const existingProxy = proxyMap.get(target);
+	if (existingProxy) return existingProxy;
+	const targetType = getTargetType(target);
+	if (targetType === 0) return target;
+	const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
+	proxyMap.set(target, proxy);
+	return proxy;
+}
+function isReactive(value) {
+	if (isReadonly(value)) return isReactive(value["__v_raw"]);
+	return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+	return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+	return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+	return value ? !!value["__v_raw"] : false;
+}
+function toRaw(observed) {
+	const raw = observed && observed["__v_raw"];
+	return raw ? toRaw(raw) : observed;
+}
+function markRaw(value) {
+	if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) def(value, "__v_skip", true);
+	return value;
+}
+function isRef(r) {
+	return r ? r["__v_isRef"] === true : false;
+}
+function ref(value) {
+	return createRef(value, false);
+}
+function shallowRef(value) {
+	return createRef(value, true);
+}
+function createRef(rawValue, shallow) {
+	if (isRef(rawValue)) return rawValue;
+	return new RefImpl(rawValue, shallow);
+}
+function unref(ref2) {
+	return isRef(ref2) ? ref2.value : ref2;
+}
+function proxyRefs(objectWithRefs) {
+	return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+function customRef(factory) {
+	return new CustomRefImpl(factory);
+}
+function toRefs(object) {
+	const ret = isArray(object) ? new Array(object.length) : {};
+	for (const key in object) ret[key] = propertyToRef(object, key);
+	return ret;
+}
+function toRef(source, key, defaultValue) {
+	if (isRef(source)) return source;
+	else if (isFunction(source)) return new GetterRefImpl(source);
+	else if (isObject(source) && arguments.length > 1) return propertyToRef(source, key, defaultValue);
+	else return ref(source);
+}
+function propertyToRef(source, key, defaultValue) {
+	const val = source[key];
+	return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
+}
+function computed(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);
+}
+function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
+	if (owner) {
+		let cleanups = cleanupMap.get(owner);
+		if (!cleanups) cleanupMap.set(owner, cleanups = []);
+		cleanups.push(cleanupFn);
+	}
+}
+function watch(source, cb, options = EMPTY_OBJ) {
+	const { immediate, deep, once, scheduler, augmentJob, call } = options;
+	const reactiveGetter = (source2) => {
+		if (deep) return source2;
+		if (isShallow(source2) || deep === false || deep === 0) return traverse(source2, 1);
+		return traverse(source2);
+	};
+	let effect;
+	let getter;
+	let cleanup;
+	let boundCleanup;
+	let forceTrigger = false;
+	let isMultiSource = false;
+	if (isRef(source)) {
+		getter = () => source.value;
+		forceTrigger = isShallow(source);
+	} else if (isReactive(source)) {
+		getter = () => reactiveGetter(source);
+		forceTrigger = true;
+	} else if (isArray(source)) {
+		isMultiSource = true;
+		forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
+		getter = () => source.map((s) => {
+			if (isRef(s)) return s.value;
+			else if (isReactive(s)) return reactiveGetter(s);
+			else if (isFunction(s)) return call ? call(s, 2) : s();
+		});
+	} else if (isFunction(source)) if (cb) getter = call ? () => call(source, 2) : source;
+	else getter = () => {
+		if (cleanup) {
+			pauseTracking();
+			try {
+				cleanup();
+			} finally {
+				resetTracking();
+			}
+		}
+		const currentEffect = activeWatcher;
+		activeWatcher = effect;
+		try {
+			return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
+		} finally {
+			activeWatcher = currentEffect;
+		}
+	};
+	else getter = NOOP;
+	if (cb && deep) {
+		const baseGetter = getter;
+		const depth = deep === true ? Infinity : deep;
+		getter = () => traverse(baseGetter(), depth);
+	}
+	const scope = getCurrentScope();
+	const watchHandle = () => {
+		effect.stop();
+		if (scope && scope.active) remove(scope.effects, effect);
+	};
+	if (once && cb) {
+		const _cb = cb;
+		cb = (...args) => {
+			_cb(...args);
+			watchHandle();
+		};
+	}
+	let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+	const job = (immediateFirstRun) => {
+		if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) return;
+		if (cb) {
+			const newValue = effect.run();
+			if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
+				if (cleanup) cleanup();
+				const currentWatcher = activeWatcher;
+				activeWatcher = effect;
+				try {
+					const args = [
+						newValue,
+						oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+						boundCleanup
+					];
+					call ? call(cb, 3, args) : cb(...args);
+					oldValue = newValue;
+				} finally {
+					activeWatcher = currentWatcher;
+				}
+			}
+		} else effect.run();
+	};
+	if (augmentJob) augmentJob(job);
+	effect = new ReactiveEffect(getter);
+	effect.scheduler = scheduler ? () => scheduler(job, false) : job;
+	boundCleanup = (fn) => onWatcherCleanup(fn, false, effect);
+	cleanup = effect.onStop = () => {
+		const cleanups = cleanupMap.get(effect);
+		if (cleanups) {
+			if (call) call(cleanups, 4);
+			else for (const cleanup2 of cleanups) cleanup2();
+			cleanupMap.delete(effect);
+		}
+	};
+	if (cb) if (immediate) job(true);
+	else oldValue = effect.run();
+	else if (scheduler) scheduler(job.bind(null, true), true);
+	else effect.run();
+	watchHandle.pause = effect.pause.bind(effect);
+	watchHandle.resume = effect.resume.bind(effect);
+	watchHandle.stop = watchHandle;
+	return watchHandle;
+}
+function traverse(value, depth = Infinity, seen) {
+	if (depth <= 0 || !isObject(value) || value["__v_skip"]) return value;
+	seen = seen || /* @__PURE__ */ new Set();
+	if (seen.has(value)) return value;
+	seen.add(value);
+	depth--;
+	if (isRef(value)) traverse(value.value, depth, seen);
+	else if (isArray(value)) for (let i = 0; i < value.length; i++) traverse(value[i], depth, seen);
+	else if (isSet(value) || isMap(value)) value.forEach((v) => {
+		traverse(v, depth, seen);
+	});
+	else if (isPlainObject(value)) {
+		for (const key in value) traverse(value[key], depth, seen);
+		for (const key of Object.getOwnPropertySymbols(value)) if (Object.prototype.propertyIsEnumerable.call(value, key)) traverse(value[key], depth, seen);
+	}
+	return value;
+}
+var activeEffectScope, EffectScope, activeSub, pausedQueueEffects, ReactiveEffect, batchDepth, batchedSub, batchedComputed, shouldTrack, trackStack, globalVersion, Link, Dep, targetMap, ITERATE_KEY, MAP_KEY_ITERATE_KEY, ARRAY_ITERATE_KEY, arrayInstrumentations, arrayProto, isNonTrackableKeys, builtInSymbols, BaseReactiveHandler, MutableReactiveHandler, ReadonlyReactiveHandler, mutableHandlers, readonlyHandlers, shallowReactiveHandlers, shallowReadonlyHandlers, toShallow, getProto, mutableCollectionHandlers, shallowCollectionHandlers, readonlyCollectionHandlers, shallowReadonlyCollectionHandlers, reactiveMap, shallowReactiveMap, readonlyMap, shallowReadonlyMap, toReactive, toReadonly, RefImpl, shallowUnwrapHandlers, CustomRefImpl, ObjectRefImpl, GetterRefImpl, ComputedRefImpl, INITIAL_WATCHER_VALUE, cleanupMap, activeWatcher;
+var init_reactivity_esm_bundler = __esmMin((() => {
+	init_shared_esm_bundler();
+	EffectScope = class {
+		constructor(detached = false) {
+			this.detached = detached;
+			/**
+			* @internal
+			*/
+			this._active = true;
+			/**
+			* @internal
+			*/
+			this.effects = [];
+			/**
+			* @internal
+			*/
+			this.cleanups = [];
+			this._isPaused = false;
+			this.parent = activeEffectScope;
+			if (!detached && activeEffectScope) this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
+		}
+		get active() {
+			return this._active;
+		}
+		pause() {
+			if (this._active) {
+				this._isPaused = true;
+				let i, l;
+				if (this.scopes) for (i = 0, l = this.scopes.length; i < l; i++) this.scopes[i].pause();
+				for (i = 0, l = this.effects.length; i < l; i++) this.effects[i].pause();
+			}
+		}
+		/**
+		* Resumes the effect scope, including all child scopes and effects.
+		*/
+		resume() {
+			if (this._active) {
+				if (this._isPaused) {
+					this._isPaused = false;
+					let i, l;
+					if (this.scopes) for (i = 0, l = this.scopes.length; i < l; i++) this.scopes[i].resume();
+					for (i = 0, l = this.effects.length; i < l; i++) this.effects[i].resume();
+				}
+			}
+		}
+		run(fn) {
+			if (this._active) {
+				const currentEffectScope = activeEffectScope;
+				try {
+					activeEffectScope = this;
+					return fn();
+				} finally {
+					activeEffectScope = currentEffectScope;
+				}
+			}
+		}
+		/**
+		* This should only be called on non-detached scopes
+		* @internal
+		*/
+		on() {
+			activeEffectScope = this;
+		}
+		/**
+		* This should only be called on non-detached scopes
+		* @internal
+		*/
+		off() {
+			activeEffectScope = this.parent;
+		}
+		stop(fromParent) {
+			if (this._active) {
+				this._active = false;
+				let i, l;
+				for (i = 0, l = this.effects.length; i < l; i++) this.effects[i].stop();
+				this.effects.length = 0;
+				for (i = 0, l = this.cleanups.length; i < l; i++) this.cleanups[i]();
+				this.cleanups.length = 0;
+				if (this.scopes) {
+					for (i = 0, l = this.scopes.length; i < l; i++) this.scopes[i].stop(true);
+					this.scopes.length = 0;
+				}
+				if (!this.detached && this.parent && !fromParent) {
+					const last = this.parent.scopes.pop();
+					if (last && last !== this) {
+						this.parent.scopes[this.index] = last;
+						last.index = this.index;
+					}
+				}
+				this.parent = void 0;
+			}
+		}
+	};
+	pausedQueueEffects = /* @__PURE__ */ new WeakSet();
+	ReactiveEffect = class {
+		constructor(fn) {
+			this.fn = fn;
+			/**
+			* @internal
+			*/
+			this.deps = void 0;
+			/**
+			* @internal
+			*/
+			this.depsTail = void 0;
+			/**
+			* @internal
+			*/
+			this.flags = 5;
+			/**
+			* @internal
+			*/
+			this.next = void 0;
+			/**
+			* @internal
+			*/
+			this.cleanup = void 0;
+			this.scheduler = void 0;
+			if (activeEffectScope && activeEffectScope.active) activeEffectScope.effects.push(this);
+		}
+		pause() {
+			this.flags |= 64;
+		}
+		resume() {
+			if (this.flags & 64) {
+				this.flags &= -65;
+				if (pausedQueueEffects.has(this)) {
+					pausedQueueEffects.delete(this);
+					this.trigger();
+				}
+			}
+		}
+		/**
+		* @internal
+		*/
+		notify() {
+			if (this.flags & 2 && !(this.flags & 32)) return;
+			if (!(this.flags & 8)) batch(this);
+		}
+		run() {
+			if (!(this.flags & 1)) return this.fn();
+			this.flags |= 2;
+			cleanupEffect(this);
+			prepareDeps(this);
+			const prevEffect = activeSub;
+			const prevShouldTrack = shouldTrack;
+			activeSub = this;
+			shouldTrack = true;
+			try {
+				return this.fn();
+			} finally {
+				cleanupDeps(this);
+				activeSub = prevEffect;
+				shouldTrack = prevShouldTrack;
+				this.flags &= -3;
+			}
+		}
+		stop() {
+			if (this.flags & 1) {
+				for (let link = this.deps; link; link = link.nextDep) removeSub(link);
+				this.deps = this.depsTail = void 0;
+				cleanupEffect(this);
+				this.onStop && this.onStop();
+				this.flags &= -2;
+			}
+		}
+		trigger() {
+			if (this.flags & 64) pausedQueueEffects.add(this);
+			else if (this.scheduler) this.scheduler();
+			else this.runIfDirty();
+		}
+		/**
+		* @internal
+		*/
+		runIfDirty() {
+			if (isDirty(this)) this.run();
+		}
+		get dirty() {
+			return isDirty(this);
+		}
+	};
+	batchDepth = 0;
+	shouldTrack = true;
+	trackStack = [];
+	globalVersion = 0;
+	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;
+		}
+	};
+	Dep = class {
+		constructor(computed) {
+			this.computed = computed;
+			this.version = 0;
+			/**
+			* Link between this dep and the current active effect
+			*/
+			this.activeLink = void 0;
+			/**
+			* Doubly linked list representing the subscribing effects (tail)
+			*/
+			this.subs = void 0;
+			/**
+			* For object property deps cleanup
+			*/
+			this.map = void 0;
+			this.key = void 0;
+			/**
+			* Subscriber counter
+			*/
+			this.sc = 0;
+		}
+		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();
+			}
+		}
+	};
+	targetMap = /* @__PURE__ */ new WeakMap();
+	ITERATE_KEY = Symbol("");
+	MAP_KEY_ITERATE_KEY = Symbol("");
+	ARRAY_ITERATE_KEY = Symbol("");
+	arrayInstrumentations = {
+		__proto__: null,
+		[Symbol.iterator]() {
+			return iterator(this, Symbol.iterator, toReactive);
+		},
+		concat(...args) {
+			return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
+		},
+		entries() {
+			return iterator(this, "entries", (value) => {
+				value[1] = toReactive(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(toReactive), arguments);
+		},
+		find(fn, thisArg) {
+			return apply(this, "find", fn, thisArg, toReactive, arguments);
+		},
+		findIndex(fn, thisArg) {
+			return apply(this, "findIndex", fn, thisArg, void 0, arguments);
+		},
+		findLast(fn, thisArg) {
+			return apply(this, "findLast", fn, thisArg, toReactive, 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", toReactive);
+		}
+	};
+	arrayProto = Array.prototype;
+	isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+	builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
+	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, 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 (isRef(res)) return targetIsArray && isIntegerKey(key) ? res : unrefNested(res);
+			if (isObject(res)) return isReadonly2 ? readonly(res) : reactive(res);
+			return res;
+		}
+	};
+	MutableReactiveHandler = class extends BaseReactiveHandler {
+		constructor(isShallow2 = false) {
+			super(false, isShallow2);
+		}
+		set(target, key, value, receiver) {
+			let oldValue = target[key];
+			if (!this._isShallow) {
+				const isOldValueReadonly = isReadonly(oldValue);
+				if (!isShallow(value) && !isReadonly(value)) {
+					oldValue = toRaw(oldValue);
+					value = toRaw(value);
+				}
+				if (!isArray(target) && isRef(oldValue) && !isRef(value)) if (isOldValueReadonly) return false;
+				else {
+					oldValue.value = value;
+					return true;
+				}
+			}
+			const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+			const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
+			if (target === 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);
+		}
+	};
+	ReadonlyReactiveHandler = class extends BaseReactiveHandler {
+		constructor(isShallow2 = false) {
+			super(true, isShallow2);
+		}
+		set(target, key) {
+			return true;
+		}
+		deleteProperty(target, key) {
+			return true;
+		}
+	};
+	mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+	readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+	shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
+	shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
+	toShallow = (value) => value;
+	getProto = (v) => Reflect.getPrototypeOf(v);
+	mutableCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, false) };
+	shallowCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, true) };
+	readonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, false) };
+	shallowReadonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, true) };
+	reactiveMap = /* @__PURE__ */ new WeakMap();
+	shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+	readonlyMap = /* @__PURE__ */ new WeakMap();
+	shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+	toReactive = (value) => isObject(value) ? reactive(value) : value;
+	toReadonly = (value) => isObject(value) ? readonly(value) : value;
+	RefImpl = class {
+		constructor(value, isShallow2) {
+			this.dep = new Dep();
+			this["__v_isRef"] = true;
+			this["__v_isShallow"] = false;
+			this._rawValue = isShallow2 ? value : 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"] || isShallow(newValue) || isReadonly(newValue);
+			newValue = useDirectValue ? newValue : toRaw(newValue);
+			if (hasChanged(newValue, oldValue)) {
+				this._rawValue = newValue;
+				this._value = useDirectValue ? newValue : toReactive(newValue);
+				this.dep.trigger();
+			}
+		}
+	};
+	shallowUnwrapHandlers = {
+		get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
+		set: (target, key, value, receiver) => {
+			const oldValue = target[key];
+			if (isRef(oldValue) && !isRef(value)) {
+				oldValue.value = value;
+				return true;
+			} else return Reflect.set(target, key, value, receiver);
+		}
+	};
+	CustomRefImpl = class {
+		constructor(factory) {
+			this["__v_isRef"] = true;
+			this._value = void 0;
+			const dep = this.dep = new Dep();
+			const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
+			this._get = get;
+			this._set = set;
+		}
+		get value() {
+			return this._value = this._get();
+		}
+		set value(newVal) {
+			this._set(newVal);
+		}
+	};
+	ObjectRefImpl = class {
+		constructor(_object, _key, _defaultValue) {
+			this._object = _object;
+			this._key = _key;
+			this._defaultValue = _defaultValue;
+			this["__v_isRef"] = true;
+			this._value = void 0;
+		}
+		get value() {
+			const val = this._object[this._key];
+			return this._value = val === void 0 ? this._defaultValue : val;
+		}
+		set value(newVal) {
+			this._object[this._key] = newVal;
+		}
+		get dep() {
+			return getDepFromReactive(toRaw(this._object), this._key);
+		}
+	};
+	GetterRefImpl = class {
+		constructor(_getter) {
+			this._getter = _getter;
+			this["__v_isRef"] = true;
+			this["__v_isReadonly"] = true;
+			this._value = void 0;
+		}
+		get value() {
+			return this._value = this._getter();
+		}
+	};
+	ComputedRefImpl = class {
+		constructor(fn, setter, isSSR) {
+			this.fn = fn;
+			this.setter = setter;
+			/**
+			* @internal
+			*/
+			this._value = void 0;
+			/**
+			* @internal
+			*/
+			this.dep = new Dep(this);
+			/**
+			* @internal
+			*/
+			this.__v_isRef = true;
+			/**
+			* @internal
+			*/
+			this.deps = void 0;
+			/**
+			* @internal
+			*/
+			this.depsTail = void 0;
+			/**
+			* @internal
+			*/
+			this.flags = 16;
+			/**
+			* @internal
+			*/
+			this.globalVersion = globalVersion - 1;
+			/**
+			* @internal
+			*/
+			this.next = void 0;
+			this.effect = this;
+			this["__v_isReadonly"] = !setter;
+			this.isSSR = isSSR;
+		}
+		/**
+		* @internal
+		*/
+		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);
+		}
+	};
+	INITIAL_WATCHER_VALUE = {};
+	cleanupMap = /* @__PURE__ */ new WeakMap();
+	activeWatcher = void 0;
+}));
+//#endregion
+export { toRef as C, trigger as D, traverse as E, unref as O, toRaw as S, track as T, ref as _, effectScope as a, shallowReadonly as b, isProxy as c, markRaw as d, onScopeDispose as f, readonly as g, reactive as h, customRef as i, watch as k, isReactive as l, proxyRefs as m, ReactiveEffect as n, getCurrentScope as o, pauseTracking as p, computed as r, init_reactivity_esm_bundler as s, EffectScope as t, isRef as u, resetTracking as v, toRefs as w, shallowRef as x, shallowReactive as y };