nuxt-intlayer 6.1.6 → 7.0.0-canary.2

package/dist/esm/node_modules/.bun/@vue_reactivity@3.5.22/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.mjs

@@ -0,0 +1,1312 @@
+import { EMPTY_OBJ, NOOP, capitalize, def, extend, hasChanged, hasOwn, isArray, isFunction, isIntegerKey, isMap, isObject, isPlainObject, isSet, isSymbol, makeMap, remove, toRawType } from "../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.mjs";
+
+//#region ../../node_modules/.bun/@vue+reactivity@3.5.22/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+function warn(msg, ...args) {
+	console.warn(`[Vue warn] ${msg}`, ...args);
+}
+let activeEffectScope;
+var EffectScope = class {
+	constructor(detached = false) {
+		this.detached = detached;
+		/**
+		* @internal
+		*/
+		this._active = true;
+		/**
+		* @internal track `on` calls, allow `on` call multiple times
+		*/
+		this._on = 0;
+		/**
+		* @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;
+			}
+		} else warn(`cannot run an inactive effect scope.`);
+	}
+	/**
+	* This should only be called on non-detached scopes
+	* @internal
+	*/
+	on() {
+		if (++this._on === 1) {
+			this.prevScope = activeEffectScope;
+			activeEffectScope = this;
+		}
+	}
+	/**
+	* This should only be called on non-detached scopes
+	* @internal
+	*/
+	off() {
+		if (this._on > 0 && --this._on === 0) {
+			activeEffectScope = this.prevScope;
+			this.prevScope = void 0;
+		}
+	}
+	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;
+		}
+	}
+};
+function effectScope(detached) {
+	return new EffectScope(detached);
+}
+function getCurrentScope() {
+	return activeEffectScope;
+}
+function onScopeDispose(fn, failSilently = false) {
+	if (activeEffectScope) activeEffectScope.cleanups.push(fn);
+	else if (!failSilently) warn(`onScopeDispose() is called when there is no active effect scope to be associated with.`);
+}
+let activeSub;
+const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
+var 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 {
+			if (activeSub !== this) warn("Active effect was not restored correctly - this is likely a Vue internal bug.");
+			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);
+	}
+};
+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$1) {
+	if (computed$1.flags & 4 && !(computed$1.flags & 16)) return;
+	computed$1.flags &= -17;
+	if (computed$1.globalVersion === globalVersion) return;
+	computed$1.globalVersion = globalVersion;
+	if (!computed$1.isSSR && computed$1.flags & 128 && (!computed$1.deps && !computed$1._dirty || !isDirty(computed$1))) return;
+	computed$1.flags |= 2;
+	const dep = computed$1.dep;
+	const prevSub = activeSub;
+	const prevShouldTrack = shouldTrack;
+	activeSub = computed$1;
+	shouldTrack = true;
+	try {
+		prepareDeps(computed$1);
+		const value = computed$1.fn(computed$1._value);
+		if (dep.version === 0 || hasChanged(value, computed$1._value)) {
+			computed$1.flags |= 128;
+			computed$1._value = value;
+			dep.version++;
+		}
+	} catch (err) {
+		dep.version++;
+		throw err;
+	} finally {
+		activeSub = prevSub;
+		shouldTrack = prevShouldTrack;
+		cleanupDeps(computed$1);
+		computed$1.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.subsHead === link) dep.subsHead = nextSub;
+	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;
+}
+function cleanupEffect(e) {
+	const { cleanup } = e;
+	e.cleanup = void 0;
+	if (cleanup) {
+		const prevSub = activeSub;
+		activeSub = void 0;
+		try {
+			cleanup();
+		} finally {
+			activeSub = prevSub;
+		}
+	}
+}
+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$1) {
+		this.computed = computed$1;
+		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;
+		/**
+		* @internal
+		*/
+		this.__v_skip = true;
+		this.subsHead = void 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;
+			}
+		}
+		if (activeSub.onTrack) activeSub.onTrack(extend({ effect: activeSub }, debugInfo));
+		return link;
+	}
+	trigger(debugInfo) {
+		this.version++;
+		globalVersion++;
+		this.notify(debugInfo);
+	}
+	notify(debugInfo) {
+		startBatch();
+		try {
+			for (let head = this.subsHead; head; head = head.nextSub) if (head.sub.onTrigger && !(head.sub.flags & 8)) head.sub.onTrigger(extend({ effect: head.sub }, debugInfo));
+			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$1 = link.dep.computed;
+		if (computed$1 && !link.dep.subs) {
+			computed$1.flags |= 20;
+			for (let l = computed$1.deps; l; l = l.nextDep) addSub(l);
+		}
+		const currentTail = link.dep.subs;
+		if (currentTail !== link) {
+			link.prevSub = currentTail;
+			if (currentTail) currentTail.nextSub = link;
+		}
+		if (link.dep.subsHead === void 0) link.dep.subsHead = link;
+		link.dep.subs = link;
+	}
+}
+const targetMap = /* @__PURE__ */ new WeakMap();
+const ITERATE_KEY = Symbol("Object iterate");
+const MAP_KEY_ITERATE_KEY = Symbol("Map keys iterate");
+const ARRAY_ITERATE_KEY = Symbol("Array iterate");
+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({
+			target,
+			type,
+			key
+		});
+	}
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+	const depsMap = targetMap.get(target);
+	if (!depsMap) {
+		globalVersion++;
+		return;
+	}
+	const run = (dep) => {
+		if (dep) dep.trigger({
+			target,
+			type,
+			key,
+			newValue,
+			oldValue,
+			oldTarget
+		});
+	};
+	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 = 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;
+}
+const 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);
+	}
+};
+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.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 && !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;
+}
+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 = 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, 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)) {
+			const value = targetIsArray && isIntegerKey(key) ? res : res.value;
+			return isReadonly2 && isObject(value) ? readonly(value) : value;
+		}
+		if (isObject(res)) return isReadonly2 ? readonly(res) : reactive(res);
+		return res;
+	}
+};
+var 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) {
+				warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target[key]);
+				return true;
+			} 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);
+	}
+};
+var ReadonlyReactiveHandler = class extends BaseReactiveHandler {
+	constructor(isShallow2 = false) {
+		super(true, isShallow2);
+	}
+	set(target, key) {
+		warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+		return true;
+	}
+	deleteProperty(target, key) {
+		warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+		return true;
+	}
+};
+const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
+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 = 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) {
+		{
+			const key = args[0] ? `on key "${args[0]}" ` : ``;
+			warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+		}
+		return type === "delete" ? false : type === "clear" ? void 0 : this;
+	};
+}
+function createInstrumentations(readonly$1, shallow) {
+	const instrumentations = {
+		get(key) {
+			const target = this["__v_raw"];
+			const rawTarget = toRaw(target);
+			const rawKey = toRaw(key);
+			if (!readonly$1) {
+				if (hasChanged(key, rawKey)) track(rawTarget, "get", key);
+				track(rawTarget, "get", rawKey);
+			}
+			const { has } = getProto(rawTarget);
+			const wrap = shallow ? toShallow : readonly$1 ? 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$1 && track(toRaw(target), "iterate", ITERATE_KEY);
+			return target.size;
+		},
+		has(key) {
+			const target = this["__v_raw"];
+			const rawTarget = toRaw(target);
+			const rawKey = toRaw(key);
+			if (!readonly$1) {
+				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$1 ? toReadonly : toReactive;
+			!readonly$1 && track(rawTarget, "iterate", ITERATE_KEY);
+			return target.forEach((value, key) => {
+				return callback.call(thisArg, wrap(value), wrap(key), observed);
+			});
+		}
+	};
+	extend(instrumentations, readonly$1 ? {
+		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);
+			} else checkIdentityKeys(target, has, 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);
+			} else checkIdentityKeys(target, has, 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 = isMap(target) ? new Map(target) : new Set(target);
+			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$1, 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 shallowReadonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, true) };
+function checkIdentityKeys(target, has, key) {
+	const rawKey = toRaw(key);
+	if (rawKey !== key && has.call(target, rawKey)) {
+		const type = toRawType(target);
+		warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
+	}
+}
+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;
+	}
+}
+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 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)) {
+		warn(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`);
+		return target;
+	}
+	if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) return target;
+	const targetType = getTargetType(target);
+	if (targetType === 0) return target;
+	const existingProxy = proxyMap.get(target);
+	if (existingProxy) return existingProxy;
+	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;
+}
+const toReactive = (value) => isObject(value) ? reactive(value) : value;
+const toReadonly = (value) => isObject(value) ? readonly(value) : value;
+function isRef(r) {
+	return r ? r["__v_isRef"] === true : false;
+}
+function ref(value) {
+	return createRef(value, false);
+}
+function createRef(rawValue, shallow) {
+	if (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 : toRaw(value);
+		this._value = isShallow2 ? value : toReactive(value);
+		this["__v_isShallow"] = isShallow2;
+	}
+	get value() {
+		this.dep.track({
+			target: this,
+			type: "get",
+			key: "value"
+		});
+		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({
+				target: this,
+				type: "set",
+				key: "value",
+				newValue,
+				oldValue
+			});
+		}
+	}
+};
+function unref(ref2) {
+	return isRef(ref2) ? ref2.value : ref2;
+}
+const 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);
+	}
+};
+function proxyRefs(objectWithRefs) {
+	return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+var 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({
+			target: this,
+			type: "get",
+			key: "value"
+		});
+		refreshComputed(this);
+		if (link) link.version = this.dep.version;
+		return this._value;
+	}
+	set value(newValue) {
+		if (this.setter) this.setter(newValue);
+		else warn("Write operation failed: computed value is readonly");
+	}
+};
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+	let getter;
+	let setter;
+	if (isFunction(getterOrOptions)) getter = getterOrOptions;
+	else {
+		getter = getterOrOptions.get;
+		setter = getterOrOptions.set;
+	}
+	const cRef = new ComputedRefImpl(getter, setter, isSSR);
+	if (debugOptions && !isSSR) {
+		cRef.onTrack = debugOptions.onTrack;
+		cRef.onTrigger = debugOptions.onTrigger;
+	}
+	return cRef;
+}
+const INITIAL_WATCHER_VALUE = {};
+const cleanupMap = /* @__PURE__ */ new WeakMap();
+let activeWatcher = void 0;
+function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
+	if (owner) {
+		let cleanups = cleanupMap.get(owner);
+		if (!cleanups) cleanupMap.set(owner, cleanups = []);
+		cleanups.push(cleanupFn);
+	} else if (!failSilently) warn(`onWatcherCleanup() was called when there was no active watcher to associate with.`);
+}
+function watch(source, cb, options = EMPTY_OBJ) {
+	const { immediate, deep, once, scheduler, augmentJob, call } = options;
+	const warnInvalidSource = (s) => {
+		(options.onWarn || warn)(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`);
+	};
+	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 warnInvalidSource(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;
+		warnInvalidSource(source);
+	}
+	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
+					];
+					oldValue = newValue;
+					call ? call(cb, 3, args) : cb(...args);
+				} 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);
+		}
+	};
+	effect.onTrack = options.onTrack;
+	effect.onTrigger = options.onTrigger;
+	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 Map();
+	if ((seen.get(value) || 0) >= depth) return value;
+	seen.set(value, depth);
+	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;
+}
+
+//#endregion
+export { EffectScope, ReactiveEffect, computed, effectScope, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, onWatcherCleanup, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReadonly, toRaw, track, unref, watch };
+//# sourceMappingURL=reactivity.esm-bundler.mjs.map