@zeus-js/signal 0.1.0 → 0.1.1-beta.1

package/dist/signal.esm-bundler.js

@@ -1,1451 +1,7 @@
 /**
-* signal v0.1.0
+* signal v0.1.1-beta.1
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
-import { capitalize, extend, hasChanged, hasOwn, isArray, isFunction, isIntegerKey, isMap, isObject, isSymbol, makeMap, toRawType } from "@zeus-js/shared";
-//#region packages/core/signal/src/warning.ts
-function warn(msg, ...args) {
-	console.warn(`[Zeus warn] ${msg}`, ...args);
-}
-//#endregion
-//#region packages/core/signal/src/effectScope.ts
-let activeEffectScope;
-var EffectScope = class {
-	constructor(detached = false) {
-		this.detached = detached;
-		this._active = true;
-		this._on = 0;
-		this.effects = [];
-		this.cleanups = [];
-		this._isPaused = false;
-		this._warnOnRun = true;
-		this.__v_skip = true;
-		if (!detached && activeEffectScope) if (activeEffectScope.active) {
-			this.parent = activeEffectScope;
-			this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
-		} else {
-			this._active = false;
-			this._warnOnRun = false;
-		}
-	}
-	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 if (this._warnOnRun) 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) {
-			if (activeEffectScope === this) activeEffectScope = this.prevScope;
-			else {
-				let current = activeEffectScope;
-				while (current) {
-					if (current.prevScope === this) {
-						current.prevScope = this.prevScope;
-						break;
-					}
-					current = current.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;
-		}
-	}
-};
-/**
-* Creates an effect scope object which can capture the reactive effects (i.e.
-* computed and watchers) created within it so that these effects can be
-* disposed together. For detailed use cases of this API, please consult its
-* corresponding {@link https://github.com/vuejs/rfcs/blob/master/active-rfcs/0041-reactivity-effect-scope.md | RFC}.
-*
-* @param detached - Can be used to create a "detached" effect scope.
-* @see {@link https://vuejs.org/api/reactivity-advanced.html#effectscope}
-*/
-function effectScope(detached) {
-	return new EffectScope(detached);
-}
-/**
-* Returns the current active effect scope if there is one.
-*
-* @see {@link https://vuejs.org/api/reactivity-advanced.html#getcurrentscope}
-*/
-function getCurrentScope() {
-	return activeEffectScope;
-}
-/**
-* Registers a dispose callback on the current active effect scope. The
-* callback will be invoked when the associated effect scope is stopped.
-*
-* @param fn - The callback function to attach to the scope's cleanup.
-* @see {@link https://vuejs.org/api/reactivity-advanced.html#onscopedispose}
-*/
-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.");
-}
-//#endregion
-//#region packages/core/signal/src/effect.ts
-let activeSub;
-const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
-var ReactiveEffect = class {
-	constructor(fn) {
-		this.fn = fn;
-		this.deps = void 0;
-		this.depsTail = void 0;
-		this.flags = 5;
-		this.next = void 0;
-		this.cleanups = void 0;
-		this.scheduler = void 0;
-		this.scope = activeEffectScope;
-		if (activeEffectScope) if (activeEffectScope.active) activeEffectScope.effects.push(this);
-		else this.flags &= -2;
-	}
-	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)) queueSubscriber(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);
-	}
-};
-/**
-* For debugging
-*/
-let batchDepth = 0;
-let batchedSub;
-let batchedComputed;
-/**
-* @internal
-*/
-function queueSubscriber(sub, isComputed = false) {
-	sub.flags |= 8;
-	if (isComputed) {
-		sub.next = batchedComputed;
-		batchedComputed = sub;
-		return;
-	}
-	sub.next = batchedSub;
-	batchedSub = sub;
-}
-/**
-* @internal
-*/
-function startBatch() {
-	batchDepth++;
-}
-/**
-* Run batched effects when all batches have ended
-* @internal
-*/
-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;
-	return false;
-}
-/**
-* Returning false indicates the refresh failed
-* @internal
-*/
-function refreshComputed(computed) {
-	if (computed.flags & 4 && !(computed.flags & 16)) return;
-	computed.flags &= -17;
-	if (computed.globalVersion === globalVersion) return;
-	computed.globalVersion = globalVersion;
-	if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) return;
-	computed.flags |= 2;
-	const dep = computed.dep;
-	const prevSub = activeSub;
-	const prevShouldTrack = shouldTrack;
-	activeSub = computed;
-	shouldTrack = true;
-	try {
-		prepareDeps(computed);
-		const value = computed.fn(computed._value);
-		if (dep.version === 0 || hasChanged(value, computed._value)) {
-			computed.flags |= 128;
-			computed._value = value;
-			dep.version++;
-		}
-	} catch (err) {
-		dep.version++;
-		throw err;
-	} finally {
-		activeSub = prevSub;
-		shouldTrack = prevShouldTrack;
-		cleanupDeps(computed);
-		computed.flags &= -3;
-	}
-}
-function removeSub(link, soft = false) {
-	const { dep, prevSub, nextSub } = link;
-	if (prevSub) {
-		prevSub.nextSub = nextSub;
-		link.prevSub = void 0;
-	}
-	if (nextSub) {
-		nextSub.prevSub = prevSub;
-		link.nextSub = void 0;
-	}
-	if (dep.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;
-	}
-}
-function effect(fn, options) {
-	if (fn.effect instanceof ReactiveEffect) fn = fn.effect.fn;
-	const e = new ReactiveEffect(fn);
-	if (options) extend(e, options);
-	try {
-		e.run();
-	} catch (err) {
-		e.stop();
-		throw err;
-	}
-	const runner = e.run.bind(e);
-	runner.effect = e;
-	return runner;
-}
-/**
-* @internal
-*/
-let shouldTrack = true;
-const trackStack = [];
-/**
-* Temporarily pauses tracking.
-*/
-function pauseTracking() {
-	trackStack.push(shouldTrack);
-	shouldTrack = false;
-}
-/**
-* Resets the previous global effect tracking state.
-*/
-function resetTracking() {
-	const last = trackStack.pop();
-	shouldTrack = last === void 0 ? true : last;
-}
-/**
-* Registers a cleanup function for the current active effect.
-* The cleanup function is called right before the next effect run, or when the
-* effect is stopped.
-*
-* Throws a warning if there is no current active effect. The warning can be
-* suppressed by passing `true` to the second argument.
-*
-* @param fn - the cleanup function to be registered
-* @param failSilently - if `true`, will not throw warning when called without
-* an active effect.
-*/
-function onEffectCleanup(fn, failSilently = false) {
-	if (activeSub instanceof ReactiveEffect) {
-		var _activeSub, _activeSub$cleanups;
-		((_activeSub$cleanups = (_activeSub = activeSub).cleanups) !== null && _activeSub$cleanups !== void 0 ? _activeSub$cleanups : _activeSub.cleanups = []).push(fn);
-	} else if (!failSilently) warn("onEffectCleanup() was called when there was no active effect to associate with.");
-}
-function cleanupEffect(e) {
-	const cleanups = e.cleanups;
-	e.cleanups = void 0;
-	if (cleanups) {
-		const prevSub = activeSub;
-		activeSub = void 0;
-		try {
-			let error;
-			for (const cleanup of cleanups) try {
-				cleanup();
-			} catch (cleanupError) {
-				var _error;
-				(_error = error) !== null && _error !== void 0 || (error = cleanupError);
-			}
-			if (error) throw error;
-		} finally {
-			activeSub = prevSub;
-		}
-	}
-}
-/**
-* Batches reactive updates synchronously within the given function.
-* All updates triggered inside `fn` are deferred until the function completes,
-* then flushed together in a single batch.
-*/
-function batch(fn) {
-	startBatch();
-	try {
-		return fn();
-	} finally {
-		endBatch();
-	}
-}
-/**
-* Returns the currently executing reactive effect, if any.
-*/
-function getCurrentEffect() {
-	return activeSub instanceof ReactiveEffect ? activeSub : void 0;
-}
-//#endregion
-//#region packages/core/signal/src/dep.ts
-/**
-* Incremented every time a reactive change happens
-* This is used to give computed a fast path to avoid re-compute when nothing
-* has changed.
-*/
-let globalVersion = 0;
-/**
-* Represents a link between a source (Dep) and a subscriber (Effect or Computed).
-* Deps and subs have a many-to-many relationship - each link between a
-* dep and a sub is represented by a Link instance.
-*
-* A Link is also a node in two doubly-linked lists - one for the associated
-* sub to track all its deps, and one for the associated dep to track all its
-* subs.
-*
-* @internal
-*/
-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;
-	}
-};
-/**
-* @internal
-*/
-var Dep = class {
-	constructor(computed) {
-		this.computed = computed;
-		this.version = 0;
-		this.activeLink = void 0;
-		this.subs = void 0;
-		this.map = void 0;
-		this.key = void 0;
-		this.sc = 0;
-		this.__v_skip = true;
-		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 = 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;
-		}
-		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");
-/**
-* Tracks access to a reactive property.
-*
-* This will check which effect is running at the moment and record it as dep
-* which records all effects that depend on the reactive property.
-*
-* @param target - Object holding the reactive property.
-* @param type - Defines the type of access to the reactive property.
-* @param key - Identifier of the reactive property to track.
-*/
-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
-		});
-	}
-}
-/**
-* Finds all deps associated with the target (or a specific property) and
-* triggers the effects stored within.
-*
-* @param target - The reactive object.
-* @param type - Defines the type of the operation that needs to trigger effects.
-* @param key - Can be used to target a specific reactive property in the target object.
-*/
-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, key) => {
-				if (key === "length" || key === ARRAY_ITERATE_KEY || !isSymbol(key) && key >= 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();
-}
-//#endregion
-//#region packages/core/signal/src/computed.ts
-/**
-* @private exported by @vue/reactivity for Vue core use, but not exported from
-* the main vue package
-*/
-var ComputedRefImpl = class {
-	constructor(fn, setter, isSSR) {
-		this.fn = fn;
-		this.setter = setter;
-		this._value = void 0;
-		this.dep = new Dep(this);
-		this.__v_isRef = true;
-		this.deps = void 0;
-		this.depsTail = void 0;
-		this.flags = 16;
-		this.globalVersion = globalVersion - 1;
-		this.next = void 0;
-		this["__v_isReadonly"] = !setter;
-		this.isSSR = isSSR;
-	}
-	/**
-	* @internal
-	*/
-	notify() {
-		this.flags |= 16;
-		if (!(this.flags & 8) && activeSub !== this) {
-			queueSubscriber(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");
-	}
-};
-/*@__NO_SIDE_EFFECTS__*/
-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;
-}
-//#endregion
-//#region packages/core/signal/src/lifecycle.ts
-function onCleanup(fn) {
-	const effect = getCurrentEffect();
-	const scope = getCurrentScope();
-	if (scope && (effect === null || effect === void 0 ? void 0 : effect.scope) !== scope) {
-		onScopeDispose(fn, true);
-		return;
-	}
-	if (effect) {
-		onEffectCleanup(fn, true);
-		return;
-	}
-	if (scope) {
-		onScopeDispose(fn, true);
-		return;
-	}
-	warn("onCleanup() was called without active effect or scope.");
-}
-//#endregion
-//#region packages/core/signal/src/arrayInstrumentations.ts
-/**
-* Track array iteration and return:
-* - if input is reactive: a cloned raw array with reactive values
-* - if input is non-reactive or shallowReactive: the original raw array
-*/
-function reactiveReadArray(array) {
-	const raw = /* @__PURE__ */ toRaw(array);
-	if (raw === array) return raw;
-	track(raw, "iterate", ARRAY_ITERATE_KEY);
-	return /* @__PURE__ */ isShallow(array) ? raw : raw.map(toReactive);
-}
-/**
-* Track array iteration and return raw array
-*/
-function shallowReadArray(arr) {
-	track(arr = /* @__PURE__ */ toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
-	return arr;
-}
-function toWrapped(target, item) {
-	if (/* @__PURE__ */ isReadonly(target)) return /* @__PURE__ */ isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
-	return toReactive(item);
-}
-const arrayInstrumentations = {
-	__proto__: null,
-	[Symbol.iterator]() {
-		return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
-	},
-	concat(...args) {
-		return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
-	},
-	entries() {
-		return iterator(this, "entries", (value) => {
-			value[1] = toWrapped(this, value[1]);
-			return value;
-		});
-	},
-	every(fn, thisArg) {
-		return apply(this, "every", fn, thisArg, void 0, arguments);
-	},
-	filter(fn, thisArg) {
-		return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments);
-	},
-	find(fn, thisArg) {
-		return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments);
-	},
-	findIndex(fn, thisArg) {
-		return apply(this, "findIndex", fn, thisArg, void 0, arguments);
-	},
-	findLast(fn, thisArg) {
-		return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments);
-	},
-	findLastIndex(fn, thisArg) {
-		return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
-	},
-	forEach(fn, thisArg) {
-		return apply(this, "forEach", fn, thisArg, void 0, arguments);
-	},
-	includes(...args) {
-		return searchProxy(this, "includes", args);
-	},
-	indexOf(...args) {
-		return searchProxy(this, "indexOf", args);
-	},
-	join(separator) {
-		return reactiveReadArray(this).join(separator);
-	},
-	lastIndexOf(...args) {
-		return searchProxy(this, "lastIndexOf", args);
-	},
-	map(fn, thisArg) {
-		return apply(this, "map", fn, thisArg, void 0, arguments);
-	},
-	pop() {
-		return noTracking(this, "pop");
-	},
-	push(...args) {
-		return noTracking(this, "push", args);
-	},
-	reduce(fn, ...args) {
-		return reduce(this, "reduce", fn, args);
-	},
-	reduceRight(fn, ...args) {
-		return reduce(this, "reduceRight", fn, args);
-	},
-	shift() {
-		return noTracking(this, "shift");
-	},
-	some(fn, thisArg) {
-		return apply(this, "some", fn, thisArg, void 0, arguments);
-	},
-	splice(...args) {
-		return noTracking(this, "splice", args);
-	},
-	toReversed() {
-		return reactiveReadArray(this).toReversed();
-	},
-	toSorted(comparer) {
-		return reactiveReadArray(this).toSorted(comparer);
-	},
-	toSpliced(...args) {
-		return reactiveReadArray(this).toSpliced(...args);
-	},
-	unshift(...args) {
-		return noTracking(this, "unshift", args);
-	},
-	values() {
-		return iterator(this, "values", (item) => toWrapped(this, item));
-	}
-};
-function iterator(self, method, wrapValue) {
-	const arr = shallowReadArray(self);
-	const iter = arr[method]();
-	if (arr !== self && !/* @__PURE__ */ isShallow(self)) {
-		iter._next = iter.next;
-		iter.next = () => {
-			const result = iter._next();
-			if (!result.done) result.value = wrapValue(result.value);
-			return result;
-		};
-	}
-	return iter;
-}
-const arrayProto = Array.prototype;
-function apply(self, method, fn, thisArg, wrappedRetFn, args) {
-	const arr = shallowReadArray(self);
-	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
-	const methodFn = arr[method];
-	if (methodFn !== arrayProto[method]) {
-		const result = methodFn.apply(self, args);
-		return needsWrap ? toReactive(result) : result;
-	}
-	let wrappedFn = fn;
-	if (arr !== self) {
-		if (needsWrap) wrappedFn = function(item, index) {
-			return fn.call(this, toWrapped(self, item), index, self);
-		};
-		else if (fn.length > 2) wrappedFn = function(item, index) {
-			return fn.call(this, item, index, self);
-		};
-	}
-	const result = methodFn.call(arr, wrappedFn, thisArg);
-	return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
-}
-function reduce(self, method, fn, args) {
-	const arr = shallowReadArray(self);
-	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
-	let wrappedFn = fn;
-	let wrapInitialAccumulator = false;
-	if (arr !== self) {
-		if (needsWrap) {
-			wrapInitialAccumulator = args.length === 0;
-			wrappedFn = function(acc, item, index) {
-				if (wrapInitialAccumulator) {
-					wrapInitialAccumulator = false;
-					acc = toWrapped(self, acc);
-				}
-				return fn.call(this, acc, toWrapped(self, item), index, self);
-			};
-		} else if (fn.length > 3) wrappedFn = function(acc, item, index) {
-			return fn.call(this, acc, item, index, self);
-		};
-	}
-	const result = arr[method](wrappedFn, ...args);
-	return wrapInitialAccumulator ? toWrapped(self, result) : result;
-}
-function searchProxy(self, method, args) {
-	const arr = /* @__PURE__ */ toRaw(self);
-	track(arr, "iterate", ARRAY_ITERATE_KEY);
-	const res = arr[method](...args);
-	if ((res === -1 || res === false) && /* @__PURE__ */ isProxy(args[0])) {
-		args[0] = /* @__PURE__ */ toRaw(args[0]);
-		return arr[method](...args);
-	}
-	return res;
-}
-function noTracking(self, method, args = []) {
-	pauseTracking();
-	startBatch();
-	const res = (/* @__PURE__ */ toRaw(self))[method].apply(self, args);
-	endBatch();
-	resetTracking();
-	return res;
-}
-//#endregion
-//#region packages/core/signal/src/baseHandlers.ts
-const isNonTrackableKeys = /*@__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
-const builtInSymbols = new Set(/*@__PURE__*/ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
-function hasOwnProperty(key) {
-	if (!isSymbol(key)) key = String(key);
-	const obj = /* @__PURE__ */ toRaw(this);
-	track(obj, "has", key);
-	return obj.hasOwnProperty(key);
-}
-var BaseReactiveHandler = class {
-	constructor(_isReadonly = false, _isShallow = false) {
-		this._isReadonly = _isReadonly;
-		this._isShallow = _isShallow;
-	}
-	get(target, key, receiver) {
-		if (key === "__v_skip") return target["__v_skip"];
-		const isReadonly = this._isReadonly, isShallow = this._isShallow;
-		if (key === "__v_isReactive") return !isReadonly;
-		else if (key === "__v_isReadonly") return isReadonly;
-		else if (key === "__v_isShallow") return isShallow;
-		else if (key === "__v_raw") {
-			if (receiver === (isReadonly ? isShallow ? shallowReadonlyMap : readonlyMap : isShallow ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) return target;
-			return;
-		}
-		const targetIsArray = isArray(target);
-		if (!isReadonly) {
-			let fn;
-			if (targetIsArray && (fn = arrayInstrumentations[key])) return fn;
-			if (key === "hasOwnProperty") return hasOwnProperty;
-		}
-		const res = Reflect.get(target, key, /* @__PURE__ */ isRef(target) ? target : receiver);
-		if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) return res;
-		if (!isReadonly) track(target, "get", key);
-		if (isShallow) return res;
-		if (/* @__PURE__ */ isRef(res)) {
-			const value = targetIsArray && isIntegerKey(key) ? res : res.value;
-			return isReadonly && isObject(value) ? /* @__PURE__ */ readonly(value) : value;
-		}
-		if (isObject(res)) return isReadonly ? /* @__PURE__ */ readonly(res) : /* @__PURE__ */ reactive(res);
-		return res;
-	}
-};
-var MutableReactiveHandler = class extends BaseReactiveHandler {
-	constructor(isShallow = false) {
-		super(false, isShallow);
-	}
-	set(target, key, value, receiver) {
-		let oldValue = target[key];
-		const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
-		if (!this._isShallow) {
-			const isOldValueReadonly = /* @__PURE__ */ isReadonly(oldValue);
-			if (!/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) {
-				oldValue = /* @__PURE__ */ toRaw(oldValue);
-				value = /* @__PURE__ */ toRaw(value);
-			}
-			if (!isArrayWithIntegerKey && /* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) if (isOldValueReadonly) {
-				warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target[key]);
-				return true;
-			} else {
-				oldValue.value = value;
-				return true;
-			}
-		}
-		const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
-		const result = Reflect.set(target, key, value, /* @__PURE__ */ isRef(target) ? target : receiver);
-		if (target === /* @__PURE__ */ toRaw(receiver)) {
-			if (!hadKey) trigger(target, "add", key, value);
-			else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
-		}
-		return result;
-	}
-	deleteProperty(target, key) {
-		const hadKey = hasOwn(target, key);
-		const oldValue = target[key];
-		const result = Reflect.deleteProperty(target, key);
-		if (result && hadKey) trigger(target, "delete", key, void 0, oldValue);
-		return result;
-	}
-	has(target, key) {
-		const result = Reflect.has(target, key);
-		if (!isSymbol(key) || !builtInSymbols.has(key)) track(target, "has", key);
-		return result;
-	}
-	ownKeys(target) {
-		track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
-		return Reflect.ownKeys(target);
-	}
-};
-var ReadonlyReactiveHandler = class extends BaseReactiveHandler {
-	constructor(isShallow = false) {
-		super(true, isShallow);
-	}
-	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();
-//#endregion
-//#region packages/core/signal/src/collectionHandlers.ts
-const toShallow = (value) => value;
-const getProto = (v) => Reflect.getPrototypeOf(v);
-function createIterableMethod(method, isReadonly, isShallow) {
-	return function(...args) {
-		const target = this["__v_raw"];
-		const rawTarget = /* @__PURE__ */ toRaw(target);
-		const targetIsMap = isMap(rawTarget);
-		const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
-		const isKeyOnly = method === "keys" && targetIsMap;
-		const innerIterator = target[method](...args);
-		const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
-		!isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
-		return extend(Object.create(innerIterator), { next() {
-			const { value, done } = innerIterator.next();
-			return done ? {
-				value,
-				done
-			} : {
-				value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
-				done
-			};
-		} });
-	};
-}
-function createReadonlyMethod(type) {
-	return function(...args) {
-		{
-			const key = args[0] ? `on key "${args[0]}" ` : ``;
-			warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, /* @__PURE__ */ toRaw(this));
-		}
-		return type === "delete" ? false : type === "clear" ? void 0 : this;
-	};
-}
-function createInstrumentations(readonly, shallow) {
-	const instrumentations = {
-		get(key) {
-			const target = this["__v_raw"];
-			const rawTarget = /* @__PURE__ */ toRaw(target);
-			const rawKey = /* @__PURE__ */ toRaw(key);
-			if (!readonly) {
-				if (hasChanged(key, rawKey)) track(rawTarget, "get", key);
-				track(rawTarget, "get", rawKey);
-			}
-			const { has } = getProto(rawTarget);
-			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
-			if (has.call(rawTarget, key)) return wrap(target.get(key));
-			else if (has.call(rawTarget, rawKey)) return wrap(target.get(rawKey));
-			else if (target !== rawTarget) target.get(key);
-		},
-		get size() {
-			const target = this["__v_raw"];
-			!readonly && track(/* @__PURE__ */ toRaw(target), "iterate", ITERATE_KEY);
-			return target.size;
-		},
-		has(key) {
-			const target = this["__v_raw"];
-			const rawTarget = /* @__PURE__ */ toRaw(target);
-			const rawKey = /* @__PURE__ */ toRaw(key);
-			if (!readonly) {
-				if (hasChanged(key, rawKey)) track(rawTarget, "has", key);
-				track(rawTarget, "has", rawKey);
-			}
-			return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
-		},
-		forEach(callback, thisArg) {
-			const observed = this;
-			const target = observed["__v_raw"];
-			const rawTarget = /* @__PURE__ */ toRaw(target);
-			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
-			!readonly && track(rawTarget, "iterate", ITERATE_KEY);
-			return target.forEach((value, key) => {
-				return callback.call(thisArg, wrap(value), wrap(key), observed);
-			});
-		}
-	};
-	extend(instrumentations, readonly ? {
-		add: createReadonlyMethod("add"),
-		set: createReadonlyMethod("set"),
-		delete: createReadonlyMethod("delete"),
-		clear: createReadonlyMethod("clear")
-	} : {
-		add(value) {
-			const target = /* @__PURE__ */ toRaw(this);
-			const proto = getProto(target);
-			const rawValue = /* @__PURE__ */ toRaw(value);
-			const valueToAdd = !shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value) ? rawValue : value;
-			if (!(proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue))) {
-				target.add(valueToAdd);
-				trigger(target, "add", valueToAdd, valueToAdd);
-			}
-			return this;
-		},
-		set(key, value) {
-			if (!shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) value = /* @__PURE__ */ toRaw(value);
-			const target = /* @__PURE__ */ toRaw(this);
-			const { has, get } = getProto(target);
-			let hadKey = has.call(target, key);
-			if (!hadKey) {
-				key = /* @__PURE__ */ toRaw(key);
-				hadKey = has.call(target, key);
-			} 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 = /* @__PURE__ */ toRaw(this);
-			const { has, get } = getProto(target);
-			let hadKey = has.call(target, key);
-			if (!hadKey) {
-				key = /* @__PURE__ */ toRaw(key);
-				hadKey = has.call(target, key);
-			} 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 = /* @__PURE__ */ 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, shallow);
-	});
-	return instrumentations;
-}
-function createInstrumentationGetter(isReadonly, shallow) {
-	const instrumentations = createInstrumentations(isReadonly, shallow);
-	return (target, key, receiver) => {
-		if (key === "__v_isReactive") return !isReadonly;
-		else if (key === "__v_isReadonly") return isReadonly;
-		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) };
-function checkIdentityKeys(target, has, key) {
-	const rawKey = /* @__PURE__ */ 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.`);
-	}
-}
-//#endregion
-//#region packages/core/signal/src/reactive.ts
-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));
-}
-/*@__NO_SIDE_EFFECTS__*/
-function reactive(target) {
-	if (/* @__PURE__ */ isReadonly(target)) return target;
-	return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
-}
-/**
-* Takes an object (reactive or plain) or a ref and returns a readonly proxy to
-* the original.
-*
-* A readonly proxy is deep: any nested property accessed will be readonly as
-* well. It also has the same ref-unwrapping behavior as {@link reactive},
-* except the unwrapped values will also be made readonly.
-*
-* @example
-* ```js
-* const original = reactive({ count: 0 })
-*
-* const copy = readonly(original)
-*
-* watchEffect(() => {
-*   // works for reactivity tracking
-*   console.log(copy.count)
-* })
-*
-* // mutating original will trigger watchers relying on the copy
-* original.count++
-*
-* // mutating the copy will fail and result in a warning
-* copy.count++ // warning!
-* ```
-*
-* @param target - The source object.
-* @see {@link https://vuejs.org/api/reactivity-core.html#readonly}
-*/
-/*@__NO_SIDE_EFFECTS__*/
-function readonly(target) {
-	return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
-}
-function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
-	if (!isObject(target)) {
-		warn(`value cannot be made ${isReadonly ? "readonly" : "reactive"}: ${String(target)}`);
-		return target;
-	}
-	if (target["__v_raw"] && !(isReadonly && 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;
-}
-/**
-* Checks if an object is a proxy created by {@link reactive} or
-* {@link shallowReactive} (or {@link ref} in some cases).
-*
-* @example
-* ```js
-* isReactive(reactive({}))            // => true
-* isReactive(readonly(reactive({})))  // => true
-* isReactive(ref({}).value)           // => true
-* isReactive(readonly(ref({})).value) // => true
-* isReactive(ref(true))               // => false
-* isReactive(shallowRef({}).value)    // => false
-* isReactive(shallowReactive({}))     // => true
-* ```
-*
-* @param value - The value to check.
-* @see {@link https://vuejs.org/api/reactivity-utilities.html#isreactive}
-*/
-/*@__NO_SIDE_EFFECTS__*/
-function isReactive(value) {
-	if (/* @__PURE__ */ isReadonly(value)) return /* @__PURE__ */ isReactive(value["__v_raw"]);
-	return !!(value && value["__v_isReactive"]);
-}
-/**
-* Checks whether the passed value is a readonly object. The properties of a
-* readonly object can change, but they can't be assigned directly via the
-* passed object.
-*
-* The proxies created by {@link readonly} and {@link shallowReadonly} are
-* both considered readonly, as is a computed ref without a set function.
-*
-* @param value - The value to check.
-* @see {@link https://vuejs.org/api/reactivity-utilities.html#isreadonly}
-*/
-/*@__NO_SIDE_EFFECTS__*/
-function isReadonly(value) {
-	return !!(value && value["__v_isReadonly"]);
-}
-/*@__NO_SIDE_EFFECTS__*/
-function isShallow(value) {
-	return !!(value && value["__v_isShallow"]);
-}
-/**
-* Checks if an object is a proxy created by {@link reactive},
-* {@link readonly}, {@link shallowReactive} or {@link shallowReadonly}.
-*
-* @param value - The value to check.
-* @see {@link https://vuejs.org/api/reactivity-utilities.html#isproxy}
-*/
-/*@__NO_SIDE_EFFECTS__*/
-function isProxy(value) {
-	return value ? !!value["__v_raw"] : false;
-}
-/**
-* Returns the raw, original object of a Vue-created proxy.
-*
-* `toRaw()` can return the original object from proxies created by
-* {@link reactive}, {@link readonly}, {@link shallowReactive} or
-* {@link shallowReadonly}.
-*
-* This is an escape hatch that can be used to temporarily read without
-* incurring proxy access / tracking overhead or write without triggering
-* changes. It is **not** recommended to hold a persistent reference to the
-* original object. Use with caution.
-*
-* @example
-* ```js
-* const foo = {}
-* const reactiveFoo = reactive(foo)
-*
-* console.log(toRaw(reactiveFoo) === foo) // true
-* ```
-*
-* @param observed - The object for which the "raw" value is requested.
-* @see {@link https://vuejs.org/api/reactivity-advanced.html#toraw}
-*/
-/*@__NO_SIDE_EFFECTS__*/
-function toRaw(observed) {
-	const raw = observed && observed["__v_raw"];
-	return raw ? /* @__PURE__ */ toRaw(raw) : observed;
-}
-/**
-* Returns a reactive proxy of the given value (if possible).
-*
-* If the given value is not an object, the original value itself is returned.
-*
-* @param value - The value for which a reactive proxy shall be created.
-*/
-const toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value;
-/**
-* Returns a readonly proxy of the given value (if possible).
-*
-* If the given value is not an object, the original value itself is returned.
-*
-* @param value - The value for which a readonly proxy shall be created.
-*/
-const toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value;
-//#endregion
-//#region packages/core/signal/src/ref.ts
-let _ReactiveFlags$IS_REF, _ReactiveFlags$IS_SHA;
-/*@__NO_SIDE_EFFECTS__*/
-function isRef(r) {
-	return r ? r["__v_isRef"] === true : false;
-}
-/*@__NO_SIDE_EFFECTS__*/
-function shallowRef(value) {
-	return createRef(value, true);
-}
-function createRef(rawValue, shallow) {
-	if (/* @__PURE__ */ isRef(rawValue)) return rawValue;
-	return new RefImpl(rawValue, shallow);
-}
-_ReactiveFlags$IS_REF = "__v_isRef";
-_ReactiveFlags$IS_SHA = "__v_isShallow";
-/**
-* @internal
-*/
-var RefImpl = class {
-	constructor(value, isShallow) {
-		this.dep = new Dep();
-		this[_ReactiveFlags$IS_REF] = true;
-		this[_ReactiveFlags$IS_SHA] = false;
-		this._rawValue = isShallow ? value : /* @__PURE__ */ toRaw(value);
-		this._value = isShallow ? value : toReactive(value);
-		this["__v_isShallow"] = isShallow;
-	}
-	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"] || /* @__PURE__ */ isShallow(newValue) || /* @__PURE__ */ isReadonly(newValue);
-		newValue = useDirectValue ? newValue : /* @__PURE__ */ toRaw(newValue);
-		if (hasChanged(newValue, oldValue)) {
-			this._rawValue = newValue;
-			this._value = useDirectValue ? newValue : toReactive(newValue);
-			this.dep.trigger({
-				target: this,
-				type: "set",
-				key: "value",
-				newValue,
-				oldValue
-			});
-		}
-	}
-};
-//#endregion
-//#region packages/core/signal/src/primitives.ts
-function createSignal(initialValue) {
-	const source = /* @__PURE__ */ shallowRef(initialValue);
-	const read = () => source.value;
-	const write = (value) => {
-		const next = typeof value === "function" ? value(source.value) : value;
-		source.value = next;
-		return next;
-	};
-	return [read, write];
-}
-function createMemo(compute) {
-	const memo = /* @__PURE__ */ computed(compute);
-	return () => memo.value;
-}
-function createEffect(run) {
-	effect(run);
-}
-function createRoot(run) {
-	const root = effectScope(true);
-	let disposed = false;
-	const dispose = () => {
-		if (disposed) return;
-		disposed = true;
-		root.stop();
-	};
-	try {
-		return root.run(() => run(dispose));
-	} catch (error) {
-		dispose();
-		throw error;
-	}
-}
-//#endregion
+import { batch, createEffect, createMemo, createRoot, createSignal, onCleanup } from "@zeus-js/signal/internal";
 export { batch, createEffect, createMemo, createRoot, createSignal, onCleanup };