@zeus-js/runtime-dom 0.1.0 → 0.1.1-beta.1

package/dist/runtime-dom.esm-bundler.js

@@ -1,1375 +1,53 @@
 /**
-* runtime-dom v0.1.0
+* runtime-dom v0.1.1-beta.1
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
+import { batch, createSignal, effect, effectScope, getCurrentScope, onScopeDispose, scope, shallowState, state, stop, untrack } from "@zeus-js/signal/internal";
 //#region packages/core/runtime-dom/src/template.ts
-function template(html, _isImportNode = false, _isSVG = false, _isMathML = false) {
-	const t = document.createElement("template");
-	t.innerHTML = html;
+function template(html, _isImportNode = false, isSVG = false, _isMathML = false) {
+	const content = isSVG ? createSvgContent(html) : createHtmlContent(html);
 	return function clone() {
-		return t.content.cloneNode(true);
+		return content.cloneNode(true);
 	};
 }
-//#endregion
-//#region packages/core/shared/src/makeMap.ts
-/**
-* Make a map and return a function for checking if a key
-* is in that map.
-* IMPORTANT: all calls of this function must be prefixed with
-* \/\*#\_\_PURE\_\_\*\/
-* So that rollup can tree-shake them if necessary.
-*/
-/*@__NO_SIDE_EFFECTS__*/
-function makeMap(str) {
-	const map = Object.create(null);
-	for (const key of str.split(",")) map[key] = 1;
-	return (val) => val in map;
-}
-Object.freeze({});
-Object.freeze([]);
-const extend = Object.assign;
-const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
-const isArray = Array.isArray;
-const isMap = (val) => toTypeString(val) === "[object Map]";
-const isString = (val) => typeof val === "string";
-const isSymbol = (val) => typeof val === "symbol";
-const isObject = (val) => val !== null && typeof val === "object";
-const objectToString = Object.prototype.toString;
-const toTypeString = (value) => objectToString.call(value);
-const toRawType = (value) => {
-	return toTypeString(value).slice(8, -1);
-};
-const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
-const cacheStringFunction = (fn) => {
-	const cache = Object.create(null);
-	return ((str) => {
-		return cache[str] || (cache[str] = fn(str));
-	});
-};
-/**
-* @private
-*/
-const capitalize = cacheStringFunction((str) => {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-});
-const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
-//#endregion
-//#region packages/core/signal/src/warning.ts
-function warn(msg, ...args) {
-	console.warn(`[Zeus warn] ${msg}`, ...args);
+function createHtmlContent(html) {
+	const template = document.createElement("template");
+	template.innerHTML = html;
+	return template.content;
 }
-//#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.");
+function createSvgContent(html) {
+	const wrapper = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+	wrapper.innerHTML = html;
+	const content = document.createDocumentFragment();
+	while (wrapper.firstChild) content.appendChild(wrapper.firstChild);
+	return content;
 }
 //#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;
+//#region packages/core/runtime-dom/src/domMove.ts
+const activeMoveRoots = /* @__PURE__ */ new Set();
+function moveNodeBefore(parent, node, marker) {
+	activeMoveRoots.add(node);
 	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;
+		const moveBefore = parent.moveBefore;
+		if (typeof moveBefore === "function") moveBefore.call(parent, node, marker);
+		else parent.insertBefore(node, marker);
 	} 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;
-}
-/**
-* Stops the effect associated with the given runner.
-*
-* @param runner - Association with the effect to stop tracking.
-*/
-function stop(runner) {
-	runner.effect.stop();
-}
-/**
-* @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;
-}
-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;
-		}
+		activeMoveRoots.delete(node);
 	}
 }
-//#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/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/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 ref(value) {
-	return createRef(value, false);
-}
-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/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);
+function isWithinRuntimeDomMove(node) {
+	let current = node;
+	while (current) {
+		if (activeMoveRoots.has(current)) return true;
+		if (current.parentNode) {
+			current = current.parentNode;
+			continue;
 		}
-		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);
+		const root = current.getRootNode();
+		current = "host" in root ? root.host : null;
 	}
-};
-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/state.ts
-function state(value) {
-	if (arguments.length === 0) return /* @__PURE__ */ ref();
-	return isProxyable(value) ? /* @__PURE__ */ reactive(value) : /* @__PURE__ */ ref(value);
-}
-function isProxyable(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Array.isArray(value)) return true;
-	if (value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet) return true;
-	return isPlainObject(value);
-}
-function isPlainObject(value) {
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
+	return false;
 }
 //#endregion
 //#region packages/core/runtime-dom/src/domOwnership.ts
@@ -1406,6 +84,14 @@ function insertTracked(parent, value, marker = null) {
 		for (const item of value) nodes.push(...insertTracked(parent, item, marker));
 		return nodes;
 	}
+	if (value instanceof Node && value.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+		const nodes = Array.from(value.childNodes);
+		for (const node of nodes) {
+			trackRuntimeDomInsertion(parent, node);
+			parent.insertBefore(node, marker);
+		}
+		return nodes;
+	}
 	const node = value instanceof Node ? value : document.createTextNode(String(value));
 	trackRuntimeDomInsertion(parent, node);
 	parent.insertBefore(node, marker);
@@ -1420,7 +106,7 @@ function removeNodes$1(nodes) {
 function moveRangeBefore(nodes, parent, marker = null) {
 	for (const node of nodes) {
 		trackRuntimeDomInsertion(parent, node);
-		parent.insertBefore(node, marker);
+		moveNodeBefore(parent, node, marker);
 	}
 }
 //#endregion
@@ -1465,10 +151,11 @@ var ScopedSubtree = class {
 	replace(render) {
 		this.dispose();
 		const scope = effectScope(true);
+		const parent = this.resolveParent(this.marker);
 		let nodes = [];
 		try {
 			scope.run(() => {
-				nodes = runWithOwner(this.context.owner, () => withHostContext(this.context.host, () => insertTracked(this.parent, render(), this.marker)));
+				nodes = runWithOwner(this.context.owner, () => withHostContext(this.context.host, () => insertTracked(parent, render(), this.marker)));
 			});
 		} catch (error) {
 			scope.stop();
@@ -1486,11 +173,15 @@ var ScopedSubtree = class {
 		this.nodes = [];
 	}
 	moveBefore(marker) {
-		moveRangeBefore(this.nodes, this.parent, marker);
+		moveRangeBefore(this.nodes, this.resolveParent(marker), marker);
 	}
 	current() {
 		return this.nodes;
 	}
+	resolveParent(marker) {
+		var _ref, _marker$parentNode, _this$marker;
+		return (_ref = (_marker$parentNode = marker === null || marker === void 0 ? void 0 : marker.parentNode) !== null && _marker$parentNode !== void 0 ? _marker$parentNode : (_this$marker = this.marker) === null || _this$marker === void 0 ? void 0 : _this$marker.parentNode) !== null && _ref !== void 0 ? _ref : this.parent;
+	}
 };
 //#endregion
 //#region packages/core/runtime-dom/src/insert.ts
@@ -1651,7 +342,7 @@ function emitDevtoolsEvent(event) {
 //#region packages/core/runtime-dom/src/render.ts
 function render(value, container, options = {}) {
 	var _options$owner;
-	const renderScope = effectScope();
+	const renderScope = scope();
 	const owner = (_options$owner = options.owner) !== null && _options$owner !== void 0 ? _options$owner : createOwner();
 	renderScope.run(() => {
 		container.textContent = "";
@@ -1700,14 +391,23 @@ function removeNodes(nodes) {
 }
 //#endregion
 //#region packages/core/runtime-dom/src/bindings.ts
-function bindText(node, value) {
-	effect(() => {
-		node.data = stringifyText(value());
+function bindText(node, value, once = false) {
+	applyBinding(value, once, (next) => {
+		node.data = stringifyText(next);
+	});
+}
+function bindTextContent(el, value, once = false) {
+	applyBinding(value, once, (next) => {
+		el.textContent = stringifyText(next);
 	});
 }
-function bindTextContent(el, value) {
+function applyBinding(value, once, apply) {
+	if (once) {
+		untrack(() => apply(value()));
+		return;
+	}
 	effect(() => {
-		el.textContent = stringifyText(value());
+		apply(value());
 	});
 }
 function stringifyText(value) {
@@ -1760,19 +460,19 @@ const BOOLEAN_DOM_PROPERTY_NAME = {
 function normalizeAttrName(name) {
 	return name === "className" ? "class" : name;
 }
-function bindAttr(el, name, value) {
-	effect(() => {
-		setAttr(el, name, value());
+function bindAttr(el, name, value, once = false) {
+	applyBinding(value, once, (next) => {
+		setAttr(el, name, next);
 	});
 }
-function bindProp(el, name, value) {
-	effect(() => {
-		el[name] = value();
+function bindProp(el, name, value, once = false) {
+	applyBinding(value, once, (next) => {
+		el[name] = next;
 	});
 }
-function bindClass(el, value) {
-	effect(() => {
-		const next = normalizeClass(value());
+function bindClass(el, value, once = false) {
+	applyBinding(value, once, (value) => {
+		const next = normalizeClass(value);
 		if (next) el.setAttribute("class", next);
 		else el.removeAttribute("class");
 	});
@@ -1784,10 +484,9 @@ function normalizeClass(value) {
 	if (typeof value === "object") return Object.keys(value).filter((key) => value[key]).join(" ");
 	return "";
 }
-function bindStyle(el, value) {
+function bindStyle(el, value, once = false) {
 	let prev;
-	effect(() => {
-		const next = value();
+	applyBinding(value, once, (next) => {
 		if (next == null) {
 			el.removeAttribute("style");
 			prev = void 0;
@@ -1943,6 +642,30 @@ function createComponent(component, props) {
 function disposeListRecord(record) {
 	record.subtree.dispose();
 }
+function isImmediatelyBefore(record, anchor) {
+	const nodes = record.subtree.current();
+	const last = nodes[nodes.length - 1];
+	return last === void 0 || last.nextSibling === anchor;
+}
+function containsNode(record, node) {
+	let current = node;
+	while (current) {
+		if (record.subtree.current().some((root) => root === current || root.contains(current))) return true;
+		const treeRoot = current.getRootNode();
+		current = "host" in treeRoot ? treeRoot.host : null;
+	}
+	return false;
+}
+function getDeepestActiveElement(parent) {
+	var _parent$ownerDocument, _parent$ownerDocument2, _active$shadowRoot;
+	const treeRoot = parent.getRootNode();
+	let active = "activeElement" in treeRoot ? treeRoot.activeElement : (_parent$ownerDocument = (_parent$ownerDocument2 = parent.ownerDocument) === null || _parent$ownerDocument2 === void 0 ? void 0 : _parent$ownerDocument2.activeElement) !== null && _parent$ownerDocument !== void 0 ? _parent$ownerDocument : null;
+	while (active === null || active === void 0 || (_active$shadowRoot = active.shadowRoot) === null || _active$shadowRoot === void 0 ? void 0 : _active$shadowRoot.activeElement) active = active.shadowRoot.activeElement;
+	return active;
+}
+function duplicateKeyError(key, index) {
+	return /* @__PURE__ */ new Error(`[Zeus runtime] <For> received duplicate key ${String(key)} at index ${index}.`);
+}
 function mountFor$1(parent, marker, each, key, render) {
 	if (!key) {
 		mountIndexFor(parent, marker, each, render);
@@ -1952,63 +675,210 @@ function mountFor$1(parent, marker, each, key, render) {
 }
 function mountIndexFor(parent, marker, each, render) {
 	const subtree = new ScopedSubtree(parent, marker, captureScopedSubtreeContext());
-	const runner = effect(() => {
-		var _each;
-		const list = (_each = each()) !== null && _each !== void 0 ? _each : [];
-		subtree.replace(() => list.map((item, index) => render(item, index)));
-	});
-	onScopeDispose(() => {
+	let latestItems = [];
+	let reconcileRequested = false;
+	let reconciling = false;
+	let disposed = false;
+	let runner;
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		if (runner) stop(runner);
+		subtree.dispose();
+	};
+	onScopeDispose(dispose, true);
+	const drainReconciliations = () => {
+		if (disposed || reconciling) return;
+		reconciling = true;
+		try {
+			while (reconcileRequested && !disposed) {
+				reconcileRequested = false;
+				untrack(() => {
+					subtree.replace(() => latestItems.map((item, index) => render(() => item, () => index)));
+				});
+			}
+		} finally {
+			reconciling = false;
+			if (disposed) subtree.dispose();
+		}
+	};
+	const scheduleReconciliation = () => {
+		if (disposed || !runner) return;
+		runner();
+		if (disposed) return;
+		reconcileRequested = true;
+		drainReconciliations();
+	};
+	try {
+		runner = effect(() => {
+			var _each;
+			const nextItems = (_each = each()) !== null && _each !== void 0 ? _each : [];
+			for (let i = 0; i < nextItems.length; i++) nextItems[i];
+			latestItems = nextItems;
+		}, { scheduler: scheduleReconciliation });
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+	if (disposed) {
 		stop(runner);
 		subtree.dispose();
-	}, true);
+		return;
+	}
+	reconcileRequested = true;
+	try {
+		drainReconciliations();
+	} catch (error) {
+		dispose();
+		throw error;
+	}
 }
 function mountKeyedFor(parent, marker, each, key, render) {
 	let records = [];
 	const subtreeContext = captureScopedSubtreeContext();
-	const runner = effect(() => {
-		var _each2;
-		const nextItems = (_each2 = each()) !== null && _each2 !== void 0 ? _each2 : [];
+	let latestEntries = [];
+	let reconcileRequested = false;
+	let reconciling = false;
+	let disposed = false;
+	let runner;
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		if (runner) stop(runner);
+		const currentRecords = records;
+		records = [];
+		for (const record of currentRecords) disposeListRecord(record);
+	};
+	onScopeDispose(dispose, true);
+	const reconcile = (nextEntries) => {
+		if (disposed) return;
 		const oldMap = /* @__PURE__ */ new Map();
 		for (const record of records) oldMap.set(record.key, record);
 		const nextRecords = [];
-		for (let i = 0; i < nextItems.length; i++) {
-			const item = nextItems[i];
-			const itemKey = key(item, i);
-			const oldRecord = oldMap.get(itemKey);
-			if (oldRecord) {
-				oldMap.delete(itemKey);
-				oldRecord.item = item;
-				oldRecord.index = i;
-				nextRecords.push(oldRecord);
-			} else {
-				const subtree = new ScopedSubtree(parent, marker, subtreeContext);
-				subtree.replace(() => render(item, i));
-				nextRecords.push({
-					key: itemKey,
-					item,
-					index: i,
-					subtree
-				});
+		const createdRecords = [];
+		try {
+			batch(() => {
+				for (let i = 0; i < nextEntries.length; i++) {
+					const { item, key: itemKey } = nextEntries[i];
+					const oldRecord = oldMap.get(itemKey);
+					if (oldRecord) {
+						oldMap.delete(itemKey);
+						oldRecord.setItem(() => item);
+						oldRecord.setIndex(i);
+						nextRecords.push(oldRecord);
+					} else {
+						const [readItem, setItem] = createSignal(item);
+						const [readIndex, setIndex] = createSignal(i);
+						const subtree = new ScopedSubtree(parent, marker, subtreeContext);
+						const record = {
+							key: itemKey,
+							setItem,
+							setIndex,
+							subtree
+						};
+						createdRecords.push(record);
+						subtree.replace(() => render(readItem, readIndex));
+						nextRecords.push(record);
+					}
+					if (disposed) break;
+				}
+			});
+		} catch (error) {
+			for (const record of createdRecords) disposeListRecord(record);
+			throw error;
+		}
+		if (disposed) {
+			for (const record of createdRecords) disposeListRecord(record);
+			return;
+		}
+		const activeElement = getDeepestActiveElement(parent);
+		const shouldRestoreFocus = Boolean(activeElement && nextRecords.some((record) => containsNode(record, activeElement)));
+		let committed = false;
+		try {
+			for (const record of oldMap.values()) disposeListRecord(record);
+			if (disposed) {
+				for (const record of createdRecords) disposeListRecord(record);
+				return;
+			}
+			records = nextRecords;
+			committed = true;
+			let moved = false;
+			let anchor = marker;
+			for (let i = nextRecords.length - 1; i >= 0; i--) {
+				var _record$subtree$curre;
+				const record = nextRecords[i];
+				if (!isImmediatelyBefore(record, anchor)) {
+					record.subtree.moveBefore(anchor);
+					moved = true;
+				}
+				anchor = (_record$subtree$curre = record.subtree.current()[0]) !== null && _record$subtree$curre !== void 0 ? _record$subtree$curre : anchor;
+			}
+			if (disposed) return;
+			if (moved && shouldRestoreFocus) {
+				var _focus;
+				(_focus = activeElement.focus) === null || _focus === void 0 || _focus.call(activeElement, { preventScroll: true });
 			}
+			if (!disposed) emitDevtoolsEvent({
+				type: "mount-for",
+				length: nextRecords.length
+			});
+		} catch (error) {
+			if (!committed) for (const record of createdRecords) disposeListRecord(record);
+			throw error;
 		}
-		for (const record of oldMap.values()) disposeListRecord(record);
-		for (let i = nextRecords.length - 1; i >= 0; i--) {
-			var _nextRecords$subtree$;
-			const record = nextRecords[i];
-			const anchor = i === nextRecords.length - 1 ? marker : (_nextRecords$subtree$ = nextRecords[i + 1].subtree.current()[0]) !== null && _nextRecords$subtree$ !== void 0 ? _nextRecords$subtree$ : marker;
-			record.subtree.moveBefore(anchor);
+	};
+	const drainReconciliations = () => {
+		if (reconciling) return;
+		reconciling = true;
+		try {
+			while (reconcileRequested) {
+				reconcileRequested = false;
+				untrack(() => reconcile(latestEntries));
+			}
+		} finally {
+			reconciling = false;
 		}
-		emitDevtoolsEvent({
-			type: "mount-for",
-			length: nextRecords.length
-		});
-		records = nextRecords;
-	});
-	onScopeDispose(() => {
+	};
+	const scheduleReconciliation = () => {
+		if (disposed || !runner) return;
+		runner();
+		if (disposed) return;
+		reconcileRequested = true;
+		drainReconciliations();
+	};
+	try {
+		runner = effect(() => {
+			var _each2;
+			const nextItems = (_each2 = each()) !== null && _each2 !== void 0 ? _each2 : [];
+			const nextEntries = [];
+			const nextKeys = /* @__PURE__ */ new Set();
+			for (let i = 0; i < nextItems.length; i++) {
+				const item = nextItems[i];
+				const itemKey = key(item, i);
+				if (nextKeys.has(itemKey)) throw duplicateKeyError(itemKey, i);
+				nextKeys.add(itemKey);
+				nextEntries.push({
+					item,
+					key: itemKey
+				});
+			}
+			latestEntries = nextEntries;
+		}, { scheduler: scheduleReconciliation });
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+	if (disposed) {
 		stop(runner);
-		for (const record of records) disposeListRecord(record);
-		records = [];
-	}, true);
+		return;
+	}
+	reconcileRequested = true;
+	try {
+		drainReconciliations();
+	} catch (error) {
+		dispose();
+		throw error;
+	}
 }
 //#endregion
 //#region packages/core/runtime-dom/src/controlFlow.ts
@@ -2233,7 +1103,14 @@ function createLightDomProjection(host, lightChildren) {
 function replaceOutletNodes(outlet, nextNodes) {
 	const parent = outlet.end.parentNode;
 	if (!parent || parent !== outlet.start.parentNode) return;
+	const currentNodes = [];
 	let current = outlet.start.nextSibling;
+	while (current && current !== outlet.end) {
+		currentNodes.push(current);
+		current = current.nextSibling;
+	}
+	if (currentNodes.length === nextNodes.length && currentNodes.every((node, index) => node === nextNodes[index])) return;
+	current = outlet.start.nextSibling;
 	while (current && current !== outlet.end) {
 		const next = current.nextSibling;
 		parent.removeChild(current);
@@ -2287,6 +1164,7 @@ function prop(input, options = {}) {
 		values: input,
 		attr: options.attr,
 		reflect: options.reflect,
+		reactivity: options.reactivity,
 		default: options.default,
 		serialize: options.serialize,
 		deserialize: options.deserialize
@@ -2296,6 +1174,7 @@ function prop(input, options = {}) {
 		type,
 		attr: options.attr,
 		reflect: type === Boolean ? (_options$reflect = options.reflect) !== null && _options$reflect !== void 0 ? _options$reflect : true : options.reflect,
+		reactivity: options.reactivity,
 		default: type === Boolean ? (_options$default = options.default) !== null && _options$default !== void 0 ? _options$default : false : options.default,
 		serialize: options.serialize,
 		deserialize: options.deserialize
@@ -2318,7 +1197,7 @@ function createPropStore(defs) {
 	const slots = /* @__PURE__ */ new Map();
 	const props = {};
 	for (const def of defs) {
-		const slot = state();
+		const slot = def.reactivity === "shallow" ? shallowState() : state();
 		slots.set(def.name, slot);
 		Object.defineProperty(props, def.name, {
 			configurable: false,
@@ -2387,6 +1266,7 @@ function defineElement(tagName, options, setup) {
 			this.mountLifecycle.connect();
 		}
 		disconnectedCallback() {
+			if (isWithinRuntimeDomMove(this)) return;
 			this.mountLifecycle.disconnect();
 		}
 		mountElement() {
@@ -2577,7 +1457,8 @@ function normalizePropDefinitions(props) {
 				name: propKey,
 				attrName: isAttributeBackedConstructor(type) ? toKebabCase(propKey) : false,
 				type: normalizePropType(type),
-				reflect: false
+				reflect: false,
+				reactivity: "deep"
 			};
 		}
 		const type = input === null || input === void 0 ? void 0 : input.type;
@@ -2587,6 +1468,7 @@ function normalizePropDefinitions(props) {
 			attrName: (input === null || input === void 0 ? void 0 : input.attr) === void 0 ? defaultAttr : input.attr,
 			type: normalizePropType(type),
 			reflect: Boolean(input === null || input === void 0 ? void 0 : input.reflect),
+			reactivity: (input === null || input === void 0 ? void 0 : input.reactivity) === "shallow" ? "shallow" : "deep",
 			default: input === null || input === void 0 ? void 0 : input.default,
 			serialize: input === null || input === void 0 ? void 0 : input.serialize,
 			deserialize: input === null || input === void 0 ? void 0 : input.deserialize