@zeus-js/zeus 0.0.2

package/dist/zeus.global.js

@@ -0,0 +1,2216 @@
+/**
+* zeus v0.0.2
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+var Zeus = (function(exports) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region packages/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;
+	}
+	//#endregion
+	//#region packages/shared/src/general.ts
+	const EMPTY_OBJ = Object.freeze({});
+	Object.freeze([]);
+	const NOOP = () => {};
+	const extend = Object.assign;
+	const remove = (arr, el) => {
+		const i = arr.indexOf(el);
+		if (i > -1) arr.splice(i, 1);
+	};
+	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 isSet = (val) => toTypeString(val) === "[object Set]";
+	const isFunction = (val) => typeof val === "function";
+	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 isPlainObject$1 = (val) => toTypeString(val) === "[object Object]";
+	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/signal/src/warning.ts
+	function warn(msg, ...args) {
+		console.warn(`[Zeus warn] ${msg}`, ...args);
+	}
+	//#endregion
+	//#region packages/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/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.cleanup = void 0;
+			this.scheduler = void 0;
+			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;
+		if (sub._dirty) 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) activeSub.cleanup = fn;
+		else if (!failSilently) warn("onEffectCleanup() was called when there was no active effect to associate with.");
+	}
+	function cleanupEffect(e) {
+		const { cleanup } = e;
+		e.cleanup = void 0;
+		if (cleanup) {
+			const prevSub = activeSub;
+			activeSub = void 0;
+			try {
+				cleanup();
+			} 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();
+		}
+	}
+	/**
+	* Executes the given function without tracking reactive dependencies.
+	* Any reactive reads inside `fn` will not trigger effect re-runs.
+	*/
+	function untrack(fn) {
+		pauseTracking();
+		try {
+			return fn();
+		} finally {
+			resetTracking();
+		}
+	}
+	/**
+	* Returns the currently executing reactive effect, if any.
+	*/
+	function getCurrentEffect() {
+		return activeSub instanceof ReactiveEffect ? activeSub : void 0;
+	}
+	//#endregion
+	//#region packages/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/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/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/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/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/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/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;
+	}
+	//#endregion
+	//#region packages/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.effect = this;
+			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/signal/src/scheduler.ts
+	function nextTick() {
+		return Promise.resolve();
+	}
+	//#endregion
+	//#region packages/signal/src/watch.ts
+	const INITIAL_WATCHER_VALUE = {};
+	const cleanupMap = /* @__PURE__ */ new WeakMap();
+	let activeWatcher = void 0;
+	/**
+	* Registers a cleanup callback on the current active effect. This
+	* registered cleanup callback will be invoked right before the
+	* associated effect re-runs.
+	*
+	* @param cleanupFn - The callback function to attach to the effect's cleanup.
+	* @param failSilently - if `true`, will not throw warning when called without
+	* an active effect.
+	* @param owner - The effect that this cleanup function should be attached to.
+	* By default, the current active effect.
+	*/
+	function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
+		if (owner) {
+			let cleanups = cleanupMap.get(owner);
+			if (!cleanups) cleanupMap.set(owner, cleanups = []);
+			cleanups.push(cleanupFn);
+		} else if (!failSilently) warn("onWatcherCleanup() was called when there was no active watcher to associate with.");
+	}
+	function watch(source, cb, options = EMPTY_OBJ) {
+		const { immediate, deep, once, scheduler, augmentJob, call } = options;
+		const warnInvalidSource = (s) => {
+			(options.onWarn || warn)(`Invalid watch source: `, s, "A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.");
+		};
+		const reactiveGetter = (source) => {
+			if (deep) return source;
+			if (/* @__PURE__ */ isShallow(source) || deep === false || deep === 0) return traverse(source, 1);
+			return traverse(source);
+		};
+		let effect;
+		let getter;
+		let cleanup;
+		let boundCleanup;
+		let forceTrigger = false;
+		let isMultiSource = false;
+		if (/* @__PURE__ */ isRef(source)) {
+			getter = () => source.value;
+			forceTrigger = /* @__PURE__ */ isShallow(source);
+		} else if (/* @__PURE__ */ isReactive(source)) {
+			getter = () => reactiveGetter(source);
+			forceTrigger = true;
+		} else if (isArray(source)) {
+			isMultiSource = true;
+			forceTrigger = source.some((s) => /* @__PURE__ */ isReactive(s) || /* @__PURE__ */ isShallow(s));
+			getter = () => source.map((s) => {
+				if (/* @__PURE__ */ isRef(s)) return s.value;
+				else if (/* @__PURE__ */ isReactive(s)) return reactiveGetter(s);
+				else if (isFunction(s)) return call ? call(s, 2) : s();
+				else warnInvalidSource(s);
+			});
+		} else if (isFunction(source)) if (cb) getter = call ? () => call(source, 2) : source;
+		else getter = () => {
+			if (cleanup) {
+				pauseTracking();
+				try {
+					cleanup();
+				} finally {
+					resetTracking();
+				}
+			}
+			const currentEffect = activeWatcher;
+			activeWatcher = effect;
+			try {
+				return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
+			} finally {
+				activeWatcher = currentEffect;
+			}
+		};
+		else {
+			getter = NOOP;
+			warnInvalidSource(source);
+		}
+		if (cb && deep) {
+			const baseGetter = getter;
+			const depth = deep === true ? Infinity : deep;
+			getter = () => traverse(baseGetter(), depth);
+		}
+		const scope = getCurrentScope();
+		const watchHandle = () => {
+			effect.stop();
+			if (scope && scope.active) remove(scope.effects, effect);
+		};
+		if (once && cb) {
+			const _cb = cb;
+			cb = (...args) => {
+				_cb(...args);
+				watchHandle();
+			};
+		}
+		let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+		const job = (immediateFirstRun) => {
+			if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) return;
+			if (cb) {
+				const newValue = effect.run();
+				if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
+					if (cleanup) cleanup();
+					const currentWatcher = activeWatcher;
+					activeWatcher = effect;
+					try {
+						const args = [
+							newValue,
+							oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+							boundCleanup
+						];
+						oldValue = newValue;
+						call ? call(cb, 3, args) : cb(...args);
+					} finally {
+						activeWatcher = currentWatcher;
+					}
+				}
+			} else effect.run();
+		};
+		if (augmentJob) augmentJob(job);
+		effect = new ReactiveEffect(getter);
+		effect.scheduler = scheduler ? () => scheduler(job, false) : job;
+		boundCleanup = (fn) => onWatcherCleanup(fn, false, effect);
+		cleanup = effect.onStop = () => {
+			const cleanups = cleanupMap.get(effect);
+			if (cleanups) {
+				if (call) call(cleanups, 4);
+				else for (const cleanup of cleanups) cleanup();
+				cleanupMap.delete(effect);
+			}
+		};
+		effect.onTrack = options.onTrack;
+		effect.onTrigger = options.onTrigger;
+		if (cb) if (immediate) job(true);
+		else oldValue = effect.run();
+		else if (scheduler) scheduler(job.bind(null, true), true);
+		else effect.run();
+		watchHandle.pause = effect.pause.bind(effect);
+		watchHandle.resume = effect.resume.bind(effect);
+		watchHandle.stop = watchHandle;
+		return watchHandle;
+	}
+	function traverse(value, depth = Infinity, seen) {
+		if (depth <= 0 || !isObject(value) || value["__v_skip"]) return value;
+		seen = seen || /* @__PURE__ */ new Map();
+		if ((seen.get(value) || 0) >= depth) return value;
+		seen.set(value, depth);
+		depth--;
+		if (/* @__PURE__ */ isRef(value)) traverse(value.value, depth, seen);
+		else if (isArray(value)) for (let i = 0; i < value.length; i++) traverse(value[i], depth, seen);
+		else if (isSet(value) || isMap(value)) value.forEach((v) => {
+			traverse(v, depth, seen);
+		});
+		else if (isPlainObject$1(value)) {
+			for (const key in value) traverse(value[key], depth, seen);
+			for (const key of Object.getOwnPropertySymbols(value)) if (Object.prototype.propertyIsEnumerable.call(value, key)) traverse(value[key], depth, seen);
+		}
+		return value;
+	}
+	//#endregion
+	//#region packages/signal/src/lifecycle.ts
+	function onCleanup(fn) {
+		if (getCurrentEffect()) {
+			onEffectCleanup(fn, true);
+			return;
+		}
+		if (getCurrentScope()) {
+			onScopeDispose(fn, true);
+			return;
+		}
+		warn("onCleanup() was called without active effect or scope.");
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/hostContext.ts
+	let currentHostContext;
+	function getCurrentHostContext() {
+		return currentHostContext;
+	}
+	function withHostContext(context, fn) {
+		const previous = currentHostContext;
+		currentHostContext = context;
+		try {
+			return fn();
+		} finally {
+			currentHostContext = previous;
+		}
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/range.ts
+	function insertTracked(parent, value, marker) {
+		if (value === void 0 || value == null || value === false || value === true) return [];
+		if (Array.isArray(value)) {
+			const nodes = [];
+			for (const item of value) nodes.push(...insertTracked(parent, item, marker));
+			return nodes;
+		}
+		const node = value instanceof Node ? value : document.createTextNode(String(value));
+		parent.insertBefore(node, marker);
+		return [node];
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/insert.ts
+	function insert(parent, value, marker = null) {
+		if (value === void 0) {
+			console.warn("[Zeus runtime] insert received `undefined`, which is ignored. Use `null` or a fallback value explicitly if you want to suppress this warning.");
+			return;
+		}
+		insertTracked(parent, value, marker);
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/context.ts
+	let currentOwner;
+	function createOwner(parent = currentOwner) {
+		return {
+			parent,
+			provides: /* @__PURE__ */ new Map()
+		};
+	}
+	function runWithOwner(owner, fn) {
+		const previous = currentOwner;
+		currentOwner = owner;
+		try {
+			return fn();
+		} finally {
+			currentOwner = previous;
+		}
+	}
+	function createContext(defaultValue) {
+		const hasDefaultValue = arguments.length > 0;
+		const context = {
+			id: Symbol("ZeusContext"),
+			defaultValue,
+			hasDefaultValue,
+			Provider(props) {
+				const owner = createOwner(currentOwner);
+				owner.provides.set(context.id, props.value);
+				return runWithOwner(owner, () => {
+					const children = resolveValue$3(props.children);
+					if (props.bridge) return createDOMContextBoundary(context, props.value, children);
+					return children;
+				});
+			},
+			Bridge(props) {
+				return createDOMContextBoundary(context, props.value, resolveValue$3(props.children));
+			}
+		};
+		return context;
+	}
+	function provide(context, value) {
+		const owner = currentOwner;
+		if (!owner) {
+			console.warn("[Zeus context] provide() was called without an active component owner.");
+			return;
+		}
+		owner.provides.set(context.id, value);
+	}
+	function inject(context, fallback) {
+		let owner = currentOwner;
+		while (owner) {
+			if (owner.provides.has(context.id)) return owner.provides.get(context.id);
+			owner = owner.parent;
+		}
+		if (arguments.length >= 2) return fallback;
+		if (context.hasDefaultValue) return context.defaultValue;
+		throw new Error(`[Zeus context] No provider found for context.`);
+	}
+	function useContext(context, fallback) {
+		if (arguments.length >= 2) return inject(context, fallback);
+		return inject(context);
+	}
+	const ZEUS_CONTEXT_REQUEST = "zeus:context-request";
+	/**
+	* Creates a transparent DOM element that acts as a context boundary.
+	* Native custom elements inside it can use `requestDOMContext` to receive
+	* context values via the DOM event protocol.
+	*/
+	function createDOMContextBoundary(context, value, children) {
+		const boundary = document.createElement("zeus-context");
+		boundary.style.cssText = "display:contents;position:unset;width:0;height:0;overflow:hidden";
+		provideDOMContext(boundary, context, value);
+		insert(boundary, children);
+		return boundary;
+	}
+	/**
+	* Registers a context value on a DOM target so that any descendant custom
+	* element can pick it up via `requestDOMContext`.
+	*/
+	function provideDOMContext(target, context, value) {
+		const handler = (event) => {
+			const request = event;
+			if (request.type !== "zeus:context-request") return;
+			if (request.detail.id !== context.id) return;
+			request.stopPropagation();
+			request.detail.resolve(value);
+		};
+		target.addEventListener(ZEUS_CONTEXT_REQUEST, handler);
+		onScopeDispose(() => {
+			target.removeEventListener(ZEUS_CONTEXT_REQUEST, handler);
+		}, true);
+	}
+	/**
+	* Internal precise DOM context resolver.
+	*
+	* Unlike requestDOMContext(), this can distinguish:
+	* - found: false, value: undefined
+	* - found: true, value: undefined
+	*/
+	function resolveDOMContext(host, context) {
+		let found = false;
+		let value;
+		const event = new CustomEvent(ZEUS_CONTEXT_REQUEST, {
+			bubbles: true,
+			composed: true,
+			cancelable: true,
+			detail: {
+				id: context.id,
+				resolved: false,
+				value: void 0,
+				resolve(nextValue) {
+					found = true;
+					value = nextValue;
+					this.resolved = true;
+					this.value = nextValue;
+				}
+			}
+		});
+		host.dispatchEvent(event);
+		return {
+			found,
+			value
+		};
+	}
+	function resolveValue$3(value) {
+		return typeof value === "function" ? value() : value !== null && value !== void 0 ? value : null;
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/devtools.ts
+	function emitDevtoolsEvent(event) {
+		var _window$__ZEUS_DEVTOO;
+		if (typeof window === "undefined") return;
+		(_window$__ZEUS_DEVTOO = window.__ZEUS_DEVTOOLS_HOOK__) === null || _window$__ZEUS_DEVTOO === void 0 || _window$__ZEUS_DEVTOO.emit(event);
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/render.ts
+	function render(value, container, options = {}) {
+		var _options$owner;
+		const renderScope = effectScope();
+		const owner = (_options$owner = options.owner) !== null && _options$owner !== void 0 ? _options$owner : createOwner();
+		renderScope.run(() => {
+			container.textContent = "";
+			runWithOwner(owner, () => {
+				insert(container, resolveValue$2(value));
+			});
+		});
+		emitDevtoolsEvent({
+			type: "render",
+			target: container
+		});
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			renderScope.stop();
+			container.textContent = "";
+		};
+	}
+	function resolveValue$2(value) {
+		return typeof value === "function" ? value() : value !== null && value !== void 0 ? value : null;
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/component.ts
+	function createComponent(component, props) {
+		return runWithOwner(createOwner(), () => component(props));
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/controlFlow.ts
+	function Show(props) {
+		return resolveValue$1(props.when ? props.children : props.fallback);
+	}
+	function resolveValue$1(value) {
+		if (typeof value === "function") return value();
+		return value !== null && value !== void 0 ? value : null;
+	}
+	function For(props) {
+		var _props$each$map, _props$each;
+		return (_props$each$map = (_props$each = props.each) === null || _props$each === void 0 ? void 0 : _props$each.map((item, index) => props.children(item, index))) !== null && _props$each$map !== void 0 ? _props$each$map : null;
+	}
+	//#endregion
+	//#region \0@oxc-project+runtime@0.133.0/helpers/esm/typeof.js
+	function _typeof(o) {
+		"@babel/helpers - typeof";
+		return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+			return typeof o;
+		} : function(o) {
+			return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+		}, _typeof(o);
+	}
+	//#endregion
+	//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPrimitive.js
+	function toPrimitive(t, r) {
+		if ("object" != _typeof(t) || !t) return t;
+		var e = t[Symbol.toPrimitive];
+		if (void 0 !== e) {
+			var i = e.call(t, r || "default");
+			if ("object" != _typeof(i)) return i;
+			throw new TypeError("@@toPrimitive must return a primitive value.");
+		}
+		return ("string" === r ? String : Number)(t);
+	}
+	//#endregion
+	//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPropertyKey.js
+	function toPropertyKey(t) {
+		var i = toPrimitive(t, "string");
+		return "symbol" == _typeof(i) ? i : i + "";
+	}
+	//#endregion
+	//#region \0@oxc-project+runtime@0.133.0/helpers/esm/defineProperty.js
+	function _defineProperty(e, r, t) {
+		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+			value: t,
+			enumerable: !0,
+			configurable: !0,
+			writable: !0
+		}) : e[r] = t, e;
+	}
+	//#endregion
+	//#region \0@oxc-project+runtime@0.133.0/helpers/esm/objectSpread2.js
+	function ownKeys(e, r) {
+		var t = Object.keys(e);
+		if (Object.getOwnPropertySymbols) {
+			var o = Object.getOwnPropertySymbols(e);
+			r && (o = o.filter(function(r) {
+				return Object.getOwnPropertyDescriptor(e, r).enumerable;
+			})), t.push.apply(t, o);
+		}
+		return t;
+	}
+	function _objectSpread2(e) {
+		for (var r = 1; r < arguments.length; r++) {
+			var t = null != arguments[r] ? arguments[r] : {};
+			r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+				_defineProperty(e, r, t[r]);
+			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+				Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+			});
+		}
+		return e;
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/defineElement.ts
+	function defineElement(tagName, options, setup) {
+		var _options$props;
+		const propDefs = normalizePropDefinitions((_options$props = options.props) !== null && _options$props !== void 0 ? _options$props : {});
+		const observedAttributes = propDefs.filter((def) => def.attr !== false).map((def) => def.attr);
+		class ZeusElement extends HTMLElement {
+			static get observedAttributes() {
+				return observedAttributes;
+			}
+			constructor() {
+				super();
+				this.props = state({});
+				this.lightChildren = [];
+				this.capturedLightChildren = false;
+				this.reflecting = false;
+				applyPropDefaults(this.props, propDefs);
+				definePropAccessors(this, this.props, propDefs);
+			}
+			connectedCallback() {
+				var _options$shadow, _options$consumes;
+				if (this.dispose) return;
+				const shadow = (_options$shadow = options.shadow) !== null && _options$shadow !== void 0 ? _options$shadow : false;
+				const mode = shadow ? "shadow" : "light";
+				if (mode === "light" && !this.capturedLightChildren) {
+					this.lightChildren = Array.from(this.childNodes);
+					this.capturedLightChildren = true;
+				}
+				this.syncAttributesToProps(propDefs);
+				const owner = createOwner();
+				for (const context of (_options$consumes = options.consumes) !== null && _options$consumes !== void 0 ? _options$consumes : []) {
+					const resolved = resolveDOMContext(this, context);
+					if (resolved.found) owner.provides.set(context.id, resolved.value);
+					else if (context.hasDefaultValue) owner.provides.set(context.id, context.defaultValue);
+				}
+				const target = this.resolveRenderTarget(shadow);
+				const hostContext = {
+					host: this,
+					mode,
+					lightChildren: this.lightChildren
+				};
+				const setupContext = {
+					host: this,
+					emit: (name, detail, eventOptions) => {
+						return this.dispatchEvent(new CustomEvent(name, _objectSpread2(_objectSpread2({
+							bubbles: true,
+							composed: true,
+							cancelable: true
+						}, eventOptions), {}, { detail })));
+					}
+				};
+				this.dispose = render(() => runWithOwner(owner, () => withHostContext(hostContext, () => setup(this.props, setupContext))), target, { owner });
+				mountStyles(target, options.styles);
+				onScopeDispose(() => {
+					var _this$dispose;
+					(_this$dispose = this.dispose) === null || _this$dispose === void 0 || _this$dispose.call(this);
+					this.dispose = void 0;
+				}, true);
+			}
+			disconnectedCallback() {
+				var _this$dispose2;
+				(_this$dispose2 = this.dispose) === null || _this$dispose2 === void 0 || _this$dispose2.call(this);
+				this.dispose = void 0;
+			}
+			attributeChangedCallback(name, oldValue, newValue) {
+				if (oldValue === newValue || this.reflecting) return;
+				const def = propDefs.find((item) => item.attr === name);
+				if (!def) return;
+				this.props[def.key] = castAttributeValue(newValue, def);
+			}
+			resolveRenderTarget(shadow) {
+				if (this.target) return this.target;
+				if (!shadow) {
+					this.target = this;
+					return this.target;
+				}
+				this.target = this.attachShadow(typeof shadow === "object" ? shadow : { mode: "open" });
+				return this.target;
+			}
+			syncAttributesToProps(defs) {
+				for (const def of defs) {
+					if (def.attr === false) continue;
+					const value = this.getAttribute(def.attr);
+					if (value !== null || def.type === Boolean) this.props[def.key] = castAttributeValue(value, def);
+				}
+			}
+			_writePropFromProperty(key, value) {
+				const def = propDefs.find((item) => item.key === key);
+				this.props[key] = value;
+				if ((def === null || def === void 0 ? void 0 : def.reflect) && def.attr !== false) {
+					this.reflecting = true;
+					try {
+						reflectPropToAttribute(this, def, value);
+					} finally {
+						this.reflecting = false;
+					}
+				}
+			}
+		}
+		if (!customElements.get(tagName)) customElements.define(tagName, ZeusElement);
+		return ZeusElement;
+	}
+	function normalizePropDefinitions(props) {
+		return Object.keys(props).map((key) => {
+			const input = props[key];
+			if (typeof input === "function") return {
+				key,
+				attr: toKebabCase(key),
+				type: input,
+				reflect: false
+			};
+			return {
+				key,
+				attr: (input === null || input === void 0 ? void 0 : input.attr) === void 0 ? toKebabCase(key) : input.attr,
+				type: input === null || input === void 0 ? void 0 : input.type,
+				reflect: Boolean(input === null || input === void 0 ? void 0 : input.reflect),
+				default: input === null || input === void 0 ? void 0 : input.default
+			};
+		});
+	}
+	function applyPropDefaults(props, defs) {
+		for (const def of defs) {
+			if (!("default" in def)) continue;
+			const value = typeof def.default === "function" ? def.default() : def.default;
+			props[def.key] = value;
+		}
+	}
+	function definePropAccessors(element, props, defs) {
+		for (const def of defs) {
+			if (def.key in element) continue;
+			Object.defineProperty(element, def.key, {
+				configurable: true,
+				enumerable: true,
+				get() {
+					return props[def.key];
+				},
+				set(value) {
+					element._writePropFromProperty(def.key, value);
+				}
+			});
+		}
+	}
+	function castAttributeValue(value, def) {
+		if (def.type === Boolean) return value !== null;
+		if (value === null) return;
+		if (def.type === Number) return Number(value);
+		if (def.type === Object || def.type === Array) try {
+			return JSON.parse(value);
+		} catch (_unused) {
+			console.warn(`[Zeus custom-element] Failed to parse JSON attribute "${def.attr}".`);
+			return def.type === Array ? [] : {};
+		}
+		return value;
+	}
+	function reflectPropToAttribute(element, def, value) {
+		if (def.attr === false) return;
+		if (def.type === Boolean) {
+			if (value) element.setAttribute(def.attr, "");
+			else element.removeAttribute(def.attr);
+			return;
+		}
+		if (value == null) {
+			element.removeAttribute(def.attr);
+			return;
+		}
+		if (def.type === Object || def.type === Array) {
+			element.setAttribute(def.attr, JSON.stringify(value));
+			return;
+		}
+		element.setAttribute(def.attr, String(value));
+	}
+	function mountStyles(target, styles) {
+		if (!styles) return;
+		const list = Array.isArray(styles) ? styles : [styles];
+		for (const css of list) {
+			const style = document.createElement("style");
+			style.textContent = css;
+			target.appendChild(style);
+		}
+	}
+	function toKebabCase(value) {
+		return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/slot.ts
+	function createSlot(name, fallback) {
+		const context = getCurrentHostContext();
+		if (!context) return createNativeSlot(name, fallback);
+		if (context.mode === "shadow") return createNativeSlot(name, fallback);
+		const assigned = findLightSlotNodes(context.lightChildren, name);
+		if (assigned.length > 0) return Array.from(assigned);
+		return fallback ? fallback() : null;
+	}
+	function createNativeSlot(name, fallback) {
+		const slot = document.createElement("slot");
+		if (name) slot.setAttribute("name", name);
+		const fallbackValue = fallback === null || fallback === void 0 ? void 0 : fallback();
+		if (fallbackValue != null) insert(slot, fallbackValue);
+		return slot;
+	}
+	function findLightSlotNodes(nodes, name) {
+		if (name) return nodes.filter((node) => {
+			if (node.nodeType !== Node.ELEMENT_NODE) return false;
+			return node.getAttribute("slot") === name;
+		});
+		return nodes.filter((node) => {
+			if (node.nodeType === Node.ELEMENT_NODE) return !node.hasAttribute("slot");
+			return isMeaningfulTextNode(node);
+		});
+	}
+	function isMeaningfulTextNode(node) {
+		var _node$textContent;
+		if (node.nodeType !== Node.TEXT_NODE) return false;
+		return Boolean((_node$textContent = node.textContent) === null || _node$textContent === void 0 ? void 0 : _node$textContent.trim());
+	}
+	//#endregion
+	//#region packages/runtime-dom/src/webComponents.ts
+	function Host(props) {
+		return resolveValue(props.children);
+	}
+	function Slot(props) {
+		return createSlot(props.name, () => resolveValue(props.children));
+	}
+	function resolveValue(value) {
+		return typeof value === "function" ? value() : value;
+	}
+	//#endregion
+	//#region packages/zeus/src/jsx-runtime.ts
+	const Fragment = Symbol.for("zeus.fragment");
+	function jsx(type, props) {
+		return createJSXNode(type, props);
+	}
+	function jsxs(type, props) {
+		return createJSXNode(type, props);
+	}
+	function jsxDEV(type, props) {
+		return createJSXNode(type, props);
+	}
+	function createJSXNode(type, props) {
+		if (typeof type === "function") return createComponent(type, props !== null && props !== void 0 ? props : {});
+		if (typeof type !== "string") return null;
+		const el = document.createElement(type);
+		if (props) {
+			const children = props.children;
+			for (const key of Object.keys(props)) {
+				if (key === "children") continue;
+				const value = props[key];
+				if (key.startsWith("on") && typeof value === "function") el.addEventListener(key.slice(2).toLowerCase(), value);
+				else if (key === "ref") setFallbackRef(value, el);
+				else if (value != null && value !== false) el.setAttribute(key === "className" ? "class" : key, String(value));
+			}
+			if (children !== void 0) insert(el, children);
+		}
+		return el;
+	}
+	function setFallbackRef(target, el) {
+		if (target == null) return;
+		if (typeof target === "function") {
+			target(el);
+			return;
+		}
+		if (typeof target === "object") {
+			if ("value" in target) {
+				target.value = el;
+				return;
+			}
+			if ("current" in target) target.current = el;
+		}
+	}
+	//#endregion
+	exports.For = For;
+	exports.Fragment = Fragment;
+	exports.Host = Host;
+	exports.Show = Show;
+	exports.Slot = Slot;
+	exports.batch = batch;
+	exports.computed = computed;
+	exports.createContext = createContext;
+	exports.defineElement = defineElement;
+	exports.effect = effect;
+	exports.inject = inject;
+	exports.jsx = jsx;
+	exports.jsxDEV = jsxDEV;
+	exports.jsxs = jsxs;
+	exports.nextTick = nextTick;
+	exports.onCleanup = onCleanup;
+	exports.provide = provide;
+	exports.render = render;
+	exports.scope = effectScope;
+	exports.state = state;
+	exports.untrack = untrack;
+	exports.useContext = useContext;
+	exports.watch = watch;
+	return exports;
+})({});