nuxt-intlayer 7.0.0-canary.2 → 7.0.0

package/dist/cjs/node_modules/.bun/@vue_reactivity@3.5.22/node_modules/@vue/reactivity/dist/reactivity.cjs.prod.cjs

@@ -1,1457 +0,0 @@
-const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.cjs');
-const require_index = require('../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/index.cjs');
-
-//#region ../../node_modules/.bun/@vue+reactivity@3.5.22/node_modules/@vue/reactivity/dist/reactivity.cjs.prod.js
-var require_reactivity_cjs_prod = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.bun/@vue+reactivity@3.5.22/node_modules/@vue/reactivity/dist/reactivity.cjs.prod.js": ((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	var shared = require_index.require_shared();
-	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;
-				}
-			}
-		}
-		/**
-		* 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);
-	}
-	let activeSub;
-	const EffectFlags = {
-		"ACTIVE": 1,
-		"1": "ACTIVE",
-		"RUNNING": 2,
-		"2": "RUNNING",
-		"TRACKING": 4,
-		"4": "TRACKING",
-		"NOTIFIED": 8,
-		"8": "NOTIFIED",
-		"DIRTY": 16,
-		"16": "DIRTY",
-		"ALLOW_RECURSE": 32,
-		"32": "ALLOW_RECURSE",
-		"PAUSED": 64,
-		"64": "PAUSED",
-		"EVALUATED": 128,
-		"128": "EVALUATED"
-	};
-	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 {
-				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 || shared.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.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 effect(fn, options) {
-		if (fn.effect instanceof ReactiveEffect) fn = fn.effect.fn;
-		const e = new ReactiveEffect(fn);
-		if (options) shared.extend(e, options);
-		try {
-			e.run();
-		} catch (err) {
-			e.stop();
-			throw err;
-		}
-		const runner = e.run.bind(e);
-		runner.effect = e;
-		return runner;
-	}
-	function stop(runner) {
-		runner.effect.stop();
-	}
-	let shouldTrack = true;
-	const trackStack = [];
-	function pauseTracking() {
-		trackStack.push(shouldTrack);
-		shouldTrack = false;
-	}
-	function enableTracking() {
-		trackStack.push(shouldTrack);
-		shouldTrack = true;
-	}
-	function resetTracking() {
-		const last = trackStack.pop();
-		shouldTrack = last === void 0 ? true : last;
-	}
-	function onEffectCleanup(fn, failSilently = false) {
-		if (activeSub instanceof ReactiveEffect) activeSub.cleanup = fn;
-	}
-	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;
-		}
-		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$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;
-			}
-			link.dep.subs = link;
-		}
-	}
-	const targetMap = /* @__PURE__ */ new WeakMap();
-	const ITERATE_KEY = Symbol("");
-	const MAP_KEY_ITERATE_KEY = Symbol("");
-	const ARRAY_ITERATE_KEY = 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 = shared.isArray(target);
-			const isArrayIndex = targetIsArray && shared.isIntegerKey(key);
-			if (targetIsArray && key === "length") {
-				const newLength = Number(newValue);
-				depsMap.forEach((dep, key2) => {
-					if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !shared.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 (shared.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 (shared.isMap(target)) run(depsMap.get(MAP_KEY_ITERATE_KEY));
-						}
-						break;
-					case "set":
-						if (shared.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;
-	}
-	const arrayInstrumentations = {
-		__proto__: null,
-		[Symbol.iterator]() {
-			return iterator(this, Symbol.iterator, toReactive);
-		},
-		concat(...args) {
-			return reactiveReadArray(this).concat(...args.map((x) => shared.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__ */ shared.makeMap(`__proto__,__v_isRef,__isVue`);
-	const builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(shared.isSymbol));
-	function hasOwnProperty(key) {
-		if (!shared.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 = shared.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 (shared.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 && shared.isIntegerKey(key) ? res : res.value;
-				return isReadonly2 && shared.isObject(value) ? readonly(value) : value;
-			}
-			if (shared.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 (!shared.isArray(target) && isRef(oldValue) && !isRef(value)) if (isOldValueReadonly) return true;
-				else {
-					oldValue.value = value;
-					return true;
-				}
-			}
-			const hadKey = shared.isArray(target) && shared.isIntegerKey(key) ? Number(key) < target.length : shared.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 (shared.hasChanged(value, oldValue)) trigger(target, "set", key, value);
-			}
-			return result;
-		}
-		deleteProperty(target, key) {
-			const hadKey = shared.hasOwn(target, key);
-			target[key];
-			const result = Reflect.deleteProperty(target, key);
-			if (result && hadKey) trigger(target, "delete", key, void 0);
-			return result;
-		}
-		has(target, key) {
-			const result = Reflect.has(target, key);
-			if (!shared.isSymbol(key) || !builtInSymbols.has(key)) track(target, "has", key);
-			return result;
-		}
-		ownKeys(target) {
-			track(target, "iterate", shared.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 shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
-	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 = shared.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$1, shallow) {
-		const instrumentations = {
-			get(key) {
-				const target = this["__v_raw"];
-				const rawTarget = toRaw(target);
-				const rawKey = toRaw(key);
-				if (!readonly$1) {
-					if (shared.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 (shared.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);
-				});
-			}
-		};
-		shared.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);
-				}
-				const oldValue = get.call(target, key);
-				target.set(key, value);
-				if (!hadKey) trigger(target, "add", key, value);
-				else if (shared.hasChanged(value, oldValue)) trigger(target, "set", key, value);
-				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);
-				}
-				get && get.call(target, key);
-				const result = target.delete(key);
-				if (hadKey) trigger(target, "delete", key, void 0);
-				return result;
-			},
-			clear() {
-				const target = toRaw(this);
-				const hadItems = target.size !== 0;
-				const result = target.clear();
-				if (hadItems) trigger(target, "clear", void 0, void 0);
-				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(shared.hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
-		};
-	}
-	const mutableCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, false) };
-	const shallowCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, true) };
-	const readonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, false) };
-	const shallowReadonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, true) };
-	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(shared.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 (!shared.isObject(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 (!shared.hasOwn(value, "__v_skip") && Object.isExtensible(value)) shared.def(value, "__v_skip", true);
-		return value;
-	}
-	const toReactive = (value) => shared.isObject(value) ? reactive(value) : value;
-	const toReadonly = (value) => shared.isObject(value) ? readonly(value) : 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);
-	}
-	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();
-			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 (shared.hasChanged(newValue, oldValue)) {
-				this._rawValue = newValue;
-				this._value = useDirectValue ? newValue : toReactive(newValue);
-				this.dep.trigger();
-			}
-		}
-	};
-	function triggerRef(ref2) {
-		if (ref2.dep) ref2.dep.trigger();
-	}
-	function unref(ref2) {
-		return isRef(ref2) ? ref2.value : ref2;
-	}
-	function toValue(source) {
-		return shared.isFunction(source) ? source() : unref(source);
-	}
-	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 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);
-		}
-	};
-	function customRef(factory) {
-		return new CustomRefImpl(factory);
-	}
-	function toRefs(object) {
-		const ret = shared.isArray(object) ? new Array(object.length) : {};
-		for (const key in object) ret[key] = propertyToRef(object, key);
-		return ret;
-	}
-	var 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);
-		}
-	};
-	var 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();
-		}
-	};
-	function toRef(source, key, defaultValue) {
-		if (isRef(source)) return source;
-		else if (shared.isFunction(source)) return new GetterRefImpl(source);
-		else if (shared.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);
-	}
-	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();
-			refreshComputed(this);
-			if (link) link.version = this.dep.version;
-			return this._value;
-		}
-		set value(newValue) {
-			if (this.setter) this.setter(newValue);
-		}
-	};
-	function computed(getterOrOptions, debugOptions, isSSR = false) {
-		let getter;
-		let setter;
-		if (shared.isFunction(getterOrOptions)) getter = getterOrOptions;
-		else {
-			getter = getterOrOptions.get;
-			setter = getterOrOptions.set;
-		}
-		return new ComputedRefImpl(getter, setter, isSSR);
-	}
-	const TrackOpTypes = {
-		"GET": "get",
-		"HAS": "has",
-		"ITERATE": "iterate"
-	};
-	const TriggerOpTypes = {
-		"SET": "set",
-		"ADD": "add",
-		"DELETE": "delete",
-		"CLEAR": "clear"
-	};
-	const ReactiveFlags = {
-		"SKIP": "__v_skip",
-		"IS_REACTIVE": "__v_isReactive",
-		"IS_READONLY": "__v_isReadonly",
-		"IS_SHALLOW": "__v_isShallow",
-		"RAW": "__v_raw",
-		"IS_REF": "__v_isRef"
-	};
-	const WatchErrorCodes = {
-		"WATCH_GETTER": 2,
-		"2": "WATCH_GETTER",
-		"WATCH_CALLBACK": 3,
-		"3": "WATCH_CALLBACK",
-		"WATCH_CLEANUP": 4,
-		"4": "WATCH_CLEANUP"
-	};
-	const INITIAL_WATCHER_VALUE = {};
-	const cleanupMap = /* @__PURE__ */ new WeakMap();
-	let activeWatcher = void 0;
-	function getCurrentWatcher() {
-		return activeWatcher;
-	}
-	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 = shared.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$1;
-		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 (shared.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 (shared.isFunction(s)) return call ? call(s, 2) : s();
-			});
-		} else if (shared.isFunction(source)) if (cb) getter = call ? () => call(source, 2) : source;
-		else getter = () => {
-			if (cleanup) {
-				pauseTracking();
-				try {
-					cleanup();
-				} finally {
-					resetTracking();
-				}
-			}
-			const currentEffect = activeWatcher;
-			activeWatcher = effect$1;
-			try {
-				return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
-			} finally {
-				activeWatcher = currentEffect;
-			}
-		};
-		else getter = shared.NOOP;
-		if (cb && deep) {
-			const baseGetter = getter;
-			const depth = deep === true ? Infinity : deep;
-			getter = () => traverse(baseGetter(), depth);
-		}
-		const scope = getCurrentScope();
-		const watchHandle = () => {
-			effect$1.stop();
-			if (scope && scope.active) shared.remove(scope.effects, effect$1);
-		};
-		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$1.flags & 1) || !effect$1.dirty && !immediateFirstRun) return;
-			if (cb) {
-				const newValue = effect$1.run();
-				if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => shared.hasChanged(v, oldValue[i])) : shared.hasChanged(newValue, oldValue))) {
-					if (cleanup) cleanup();
-					const currentWatcher = activeWatcher;
-					activeWatcher = effect$1;
-					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$1.run();
-		};
-		if (augmentJob) augmentJob(job);
-		effect$1 = new ReactiveEffect(getter);
-		effect$1.scheduler = scheduler ? () => scheduler(job, false) : job;
-		boundCleanup = (fn) => onWatcherCleanup(fn, false, effect$1);
-		cleanup = effect$1.onStop = () => {
-			const cleanups = cleanupMap.get(effect$1);
-			if (cleanups) {
-				if (call) call(cleanups, 4);
-				else for (const cleanup2 of cleanups) cleanup2();
-				cleanupMap.delete(effect$1);
-			}
-		};
-		if (cb) if (immediate) job(true);
-		else oldValue = effect$1.run();
-		else if (scheduler) scheduler(job.bind(null, true), true);
-		else effect$1.run();
-		watchHandle.pause = effect$1.pause.bind(effect$1);
-		watchHandle.resume = effect$1.resume.bind(effect$1);
-		watchHandle.stop = watchHandle;
-		return watchHandle;
-	}
-	function traverse(value, depth = Infinity, seen) {
-		if (depth <= 0 || !shared.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 (shared.isArray(value)) for (let i = 0; i < value.length; i++) traverse(value[i], depth, seen);
-		else if (shared.isSet(value) || shared.isMap(value)) value.forEach((v) => {
-			traverse(v, depth, seen);
-		});
-		else if (shared.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;
-	}
-	exports.ARRAY_ITERATE_KEY = ARRAY_ITERATE_KEY;
-	exports.EffectFlags = EffectFlags;
-	exports.EffectScope = EffectScope;
-	exports.ITERATE_KEY = ITERATE_KEY;
-	exports.MAP_KEY_ITERATE_KEY = MAP_KEY_ITERATE_KEY;
-	exports.ReactiveEffect = ReactiveEffect;
-	exports.ReactiveFlags = ReactiveFlags;
-	exports.TrackOpTypes = TrackOpTypes;
-	exports.TriggerOpTypes = TriggerOpTypes;
-	exports.WatchErrorCodes = WatchErrorCodes;
-	exports.computed = computed;
-	exports.customRef = customRef;
-	exports.effect = effect;
-	exports.effectScope = effectScope;
-	exports.enableTracking = enableTracking;
-	exports.getCurrentScope = getCurrentScope;
-	exports.getCurrentWatcher = getCurrentWatcher;
-	exports.isProxy = isProxy;
-	exports.isReactive = isReactive;
-	exports.isReadonly = isReadonly;
-	exports.isRef = isRef;
-	exports.isShallow = isShallow;
-	exports.markRaw = markRaw;
-	exports.onEffectCleanup = onEffectCleanup;
-	exports.onScopeDispose = onScopeDispose;
-	exports.onWatcherCleanup = onWatcherCleanup;
-	exports.pauseTracking = pauseTracking;
-	exports.proxyRefs = proxyRefs;
-	exports.reactive = reactive;
-	exports.reactiveReadArray = reactiveReadArray;
-	exports.readonly = readonly;
-	exports.ref = ref;
-	exports.resetTracking = resetTracking;
-	exports.shallowReactive = shallowReactive;
-	exports.shallowReadArray = shallowReadArray;
-	exports.shallowReadonly = shallowReadonly;
-	exports.shallowRef = shallowRef;
-	exports.stop = stop;
-	exports.toRaw = toRaw;
-	exports.toReactive = toReactive;
-	exports.toReadonly = toReadonly;
-	exports.toRef = toRef;
-	exports.toRefs = toRefs;
-	exports.toValue = toValue;
-	exports.track = track;
-	exports.traverse = traverse;
-	exports.trigger = trigger;
-	exports.triggerRef = triggerRef;
-	exports.unref = unref;
-	exports.watch = watch;
-}) });
-
-//#endregion
-Object.defineProperty(exports, 'default', {
-  enumerable: true,
-  get: function () {
-    return require_reactivity_cjs_prod();
-  }
-});
-//# sourceMappingURL=reactivity.cjs.prod.cjs.map