@calmdown/pyxis 1.0.0-rc.1

package/dist/core-dev.js

@@ -0,0 +1,1828 @@
+//#region src/dev/ComponentRegistry.ts
+var ComponentRegistry = class {
+	components = /* @__PURE__ */ new Map();
+	isPendingUpdate = false;
+	on(id, fn) {
+		const entry = this.components.get(id);
+		if (!entry) throw new Error(`no component was registered under "${id}"`);
+		const listener = {
+			fn,
+			entry
+		};
+		if (entry.lt) {
+			entry.lt.ln = listener;
+			listener.lp = entry.lt;
+		} else entry.lh = listener;
+		entry.lt = listener;
+		fn(entry.component);
+		return listener;
+	}
+	off(listener) {
+		const { entry } = listener;
+		if (listener.lp) listener.lp.ln = listener.ln;
+		else if (entry.lh === listener) entry.lh = listener.ln;
+		if (listener.ln) listener.ln.lp = listener.lp;
+		else if (entry.lt === listener) entry.lt = listener.lp;
+		listener.lp = null;
+		listener.ln = null;
+	}
+	subscribe(id, fn) {
+		const listener = this.on(id, fn);
+		return () => this.off(listener);
+	}
+	upsert(id, component) {
+		const entry = this.components.get(id);
+		if (!entry) {
+			this.components.set(id, {
+				component,
+				dirty: false
+			});
+			return;
+		}
+		entry.component = component;
+		entry.dirty = true;
+		if (!this.isPendingUpdate) {
+			queueMicrotask(this.update);
+			this.isPendingUpdate = true;
+		}
+	}
+	update = () => {
+		this.isPendingUpdate = false;
+		this.components.forEach((entry) => {
+			if (!entry.dirty) return;
+			let current = entry.lh;
+			let next;
+			while (current) {
+				next = current.ln;
+				current.fn(entry.component);
+				current = next;
+			}
+			entry.dirty = false;
+		});
+	};
+};
+
+//#endregion
+//#region src/dev/StateRegistry.ts
+var StateRegistry = class {
+	state = /* @__PURE__ */ new WeakMap();
+	preserve(handle, devId, value) {
+		if (!handle || !devId) return;
+		let map = this.state.get(handle);
+		if (!map) this.state.set(handle, map = {});
+		map[devId] = value;
+	}
+	restore(handle, devId, block) {
+		if (!handle || !devId) return;
+		const map = this.state.get(handle);
+		if (!map || !Object.hasOwn(map, devId)) return;
+		return block ? block(map[devId]) : map[devId];
+	}
+};
+
+//#endregion
+//#region src/dev/PyxisHotReload.ts
+globalThis.__PYXIS_HMR__ = {
+	component: new ComponentRegistry(),
+	state: new StateRegistry()
+};
+
+//#endregion
+//#region src/support/common.ts
+function invoke(callback) {
+	return callback.$fn(callback.$a0, callback.$a1);
+}
+
+//#endregion
+//#region src/data/Lifecycle.ts
+/**
+* Registers a callback to run just after the current Component has mounted.
+*
+* If a teardown callback is returned, it will be run just before the Component unmounts (equivalent
+* to adding a separate `unmounted` block).
+* @see {@link unmounted}
+*/
+function mounted(block, lifecycle = getLifecycle()) {
+	onMounted(lifecycle, {
+		$fn: invokeMountedCallback,
+		$a0: lifecycle,
+		$a1: block
+	});
+}
+/** @internal */
+function onMounted(lifecycle, callback) {
+	(lifecycle.$onMount ??= []).push(callback);
+}
+function invokeMountedCallback(lifecycle, block) {
+	const dispose = block();
+	if (dispose) onUnmounted(lifecycle, { $fn: dispose });
+}
+/**
+* Registers a callback to run once the current Component is just about to unmount.
+* @see {@link mounted}
+*/
+function unmounted(block, lifecycle = getLifecycle()) {
+	onUnmounted(lifecycle, { $fn: block });
+}
+/** @internal */
+function onUnmounted(lifecycle, callback) {
+	(lifecycle.$onUnmount ??= []).push(callback);
+}
+let $currentLifecycle = null;
+/**
+* Gets the Lifecycle of the calling component.
+*/
+function getLifecycle() {
+	if (!$currentLifecycle) throw new Error("Cannot get current lifecycle. Are you creating an Atom outside of a Component?");
+	return $currentLifecycle;
+}
+/** @internal */
+function setLifecycle(lifecycle) {
+	const previous = $currentLifecycle;
+	$currentLifecycle = lifecycle;
+	return previous;
+}
+function withLifecycle(lifecycle, block, arg) {
+	const previousLifecycle = $currentLifecycle;
+	$currentLifecycle = lifecycle;
+	try {
+		return block(arg);
+	} finally {
+		$currentLifecycle = previousLifecycle;
+	}
+}
+
+//#endregion
+//#region src/data/Dependency.ts
+function bind(lifecycle, target, block) {
+	link(lifecycle, target, { $fn: block });
+	block();
+}
+/**
+* Links a Dependency to an Atom and Lifecycle.
+* @internal
+*/
+function link(lifecycle, target, dep) {
+	if (target.$dt) {
+		target.$dt.$an = dep;
+		dep.$ap = target.$dt;
+	} else target.$dh = dep;
+	dep.$target = target;
+	target.$dt = dep;
+	if (lifecycle.$dt) {
+		lifecycle.$dt.$ln = dep;
+		dep.$lp = lifecycle.$dt;
+	} else lifecycle.$dh = dep;
+	dep.$lifecycle = lifecycle;
+	lifecycle.$dt = dep;
+}
+/**
+* Unlinks a Dependency from the Atom and Lifecycle it has been linked to.
+* @internal
+*/
+function unlink(dep) {
+	const target = dep.$target;
+	if (!target) return;
+	if (dep.$ap) dep.$ap.$an = dep.$an;
+	else if (target.$dh === dep) target.$dh = dep.$an;
+	if (dep.$an) dep.$an.$ap = dep.$ap;
+	else if (target.$dt === dep) target.$dt = dep.$ap;
+	dep.$target = null;
+	dep.$ap = null;
+	dep.$an = null;
+	const lifecycle = dep.$lifecycle;
+	if (dep.$lp) dep.$lp.$ln = dep.$ln;
+	else if (lifecycle.$dh === dep) lifecycle.$dh = dep.$ln;
+	if (dep.$ln) dep.$ln.$lp = dep.$lp;
+	else if (lifecycle.$dt === dep) lifecycle.$dt = dep.$lp;
+	dep.$lifecycle = null;
+	dep.$lp = null;
+	dep.$ln = null;
+}
+/**
+* Unlinks all Dependencies managed by the given Lifecycle.
+* @internal
+*/
+function unlinkAll(lifecycle) {
+	let dep = lifecycle.$dh;
+	let atom;
+	let next;
+	while (dep) {
+		atom = dep.$target;
+		if (dep.$ap) dep.$ap.$an = dep.$an;
+		else if (atom.$dh === dep) atom.$dh = dep.$an;
+		if (dep.$an) dep.$an.$ap = dep.$ap;
+		else if (atom.$dt === dep) atom.$dt = dep.$ap;
+		next = dep.$ln;
+		dep.$lifecycle = null;
+		dep.$target = null;
+		dep.$ap = null;
+		dep.$an = null;
+		dep.$lp = null;
+		dep.$ln = null;
+		dep = next;
+	}
+	lifecycle.$dh = null;
+	lifecycle.$dt = null;
+}
+
+//#endregion
+//#region src/data/Scheduler.ts
+/** @internal */
+function createScheduler(tick) {
+	let isPending = false;
+	const ticks = [];
+	const tocks = [];
+	const scheduler = {
+		$epoch: 1,
+		$onTick: ticks,
+		$onTock: tocks,
+		$scheduleTick: () => {
+			if (isPending) return;
+			isPending = true;
+			tick(update);
+		}
+	};
+	const update = () => {
+		try {
+			let index = 0;
+			let callback;
+			for (; index < ticks.length; index += 1) {
+				callback = ticks[index];
+				if (callback.$life === callback.$lifecycle.$life) {
+					callback.$re = scheduler.$epoch;
+					invoke(callback);
+				}
+			}
+			for (index = 0; index < tocks.length; index += 1) {
+				callback = tocks[index];
+				if (callback.$life === callback.$lifecycle.$life) {
+					callback.$re = scheduler.$epoch;
+					invoke(callback);
+				}
+			}
+		} finally {
+			isPending = false;
+			ticks.length = 0;
+			tocks.length = 0;
+			scheduler.$epoch += 1;
+		}
+	};
+	return scheduler;
+}
+function schedule(lifecycle, queue, callback) {
+	const scheduler = lifecycle.$scheduler;
+	if (callback.$se === scheduler.$epoch) {
+		if (callback.$re === scheduler.$epoch) throw new Error("Refusing to re-schedule an update after it already executed, as it may cause an infinite loop. Are you mutating an Atom inside an effect that observes it?");
+		return;
+	}
+	callback.$lifecycle = lifecycle;
+	callback.$life = lifecycle.$life;
+	callback.$se = scheduler.$epoch;
+	queue.push(callback);
+	scheduler.$scheduleTick();
+}
+/** @internal */
+function scheduleTick(lifecycle, callback) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTick, callback);
+}
+/**
+* Runs a block of code on the next tick of the scheduler, synchronized with other updates. If a
+* tick is not currently pending, a new one is scheduled.
+*/
+function tick(block, lifecycle = getLifecycle()) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTick, { $fn: block });
+}
+/** @internal */
+function scheduleTock(lifecycle, callback) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTock, callback);
+}
+/**
+* Runs a block of code after the next tick of the scheduler, once all regular updates finished.
+* If a tick is not currently pending, a new one is scheduled.
+*/
+function tock(block, lifecycle = getLifecycle()) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTock, { $fn: block });
+}
+
+//#endregion
+//#region src/data/Effect.ts
+/**
+* Creates an Effect - a block of logic executed each time any of the Atoms accessed within it
+* change. The block is first synchronously executed when the Effect is created.
+*
+* If a teardown callback is returned, it will be run before the next effect re-run, or on component
+* unmount.
+*/
+function effect(block, lifecycle = getLifecycle()) {
+	runEffect({
+		$lifecycle: lifecycle,
+		$life: lifecycle.$life,
+		$block: block,
+		$react: scheduleEffect,
+		$cycle: 0
+	});
+}
+function scheduleEffect(effect, cycle) {
+	if (effect.$cycle > cycle) {
+		unlink(this);
+		return;
+	}
+	scheduleTick(effect.$lifecycle, effect.$resolve ??= {
+		$fn: runEffect,
+		$a0: effect
+	});
+}
+function runEffect(effect) {
+	if (effect.$life !== effect.$lifecycle.$life) return;
+	effect.$dispose?.();
+	effect.$dispose = resolve(effect);
+	if (!effect.$tracksUnmount && effect.$dispose) {
+		effect.$tracksUnmount = true;
+		onUnmounted(effect.$lifecycle, {
+			$fn: teardownEffect,
+			$a0: effect
+		});
+	}
+}
+function teardownEffect(effect) {
+	effect.$dispose?.();
+	effect.$dispose = null;
+}
+let $currentEffect = null;
+/**
+* Resolves an Effect: runs user logic tracking accessed Atoms and updating dependency links.
+* Returned value is forwarded.
+* @internal
+*/
+function resolve(effect) {
+	effect.$deps ??= /* @__PURE__ */ new WeakMap();
+	effect.$cycle += 1;
+	const previousEffect = $currentEffect;
+	const previousLifecycle = setLifecycle(effect.$lifecycle);
+	$currentEffect = effect;
+	try {
+		return effect.$block();
+	} finally {
+		setLifecycle(previousLifecycle);
+		$currentEffect = previousEffect;
+	}
+}
+/**
+* Reports an Atom has been accessed. Does nothing if not within an Effect.
+* @internal
+*/
+function reportAccess(atom) {
+	if (!$currentEffect || $currentEffect.$life !== $currentEffect.$lifecycle.$life) return;
+	let dep = $currentEffect.$deps.get(atom);
+	if (dep) {
+		dep.$a1 = $currentEffect.$cycle;
+		if (!dep.$lifecycle) link($currentEffect.$lifecycle, atom, dep);
+	} else {
+		link($currentEffect.$lifecycle, atom, dep = {
+			$fn: $currentEffect.$react,
+			$a0: $currentEffect,
+			$a1: $currentEffect.$cycle
+		});
+		$currentEffect.$deps.set(atom, dep);
+	}
+}
+/**
+* Asserts that the current code is not running within an effect block.
+* Only used in development; In production, this function should be removed by the bundler.
+*/
+function __DEV__assertNotEffect() {
+	if ($currentEffect && $currentEffect.$lifecycle === getLifecycle() && $currentEffect.$life === $currentEffect.$lifecycle.$life) throw new Error("Attempt to create an Atom inside an effect block.");
+}
+
+//#endregion
+//#region src/data/Atom.ts
+/**
+* Pyxis Atom type guard marker.
+*/
+const S_ATOM = Symbol.for("pyxis:atom");
+function atomOf(initialValue, lifecycle = getLifecycle()) {
+	__DEV__assertNotEffect();
+	if (isAtom(initialValue)) return initialValue;
+	const atom = {
+		[S_ATOM]: true,
+		$value: initialValue,
+		$tracksValue: true,
+		$lifecycle: lifecycle,
+		$lastValue: initialValue,
+		get: getValue$1,
+		set: setValue$2
+	};
+	{
+		const devId = arguments[2];
+		atom.$devId = devId;
+		globalThis.__PYXIS_HMR__.state.restore(lifecycle, devId, (value) => {
+			atom.$value = value;
+		});
+	}
+	return atom;
+}
+function getValue$1() {
+	return this.$value;
+}
+function setValue$2(value) {
+	if (Object.is(this.$value, value)) return false;
+	this.$value = value;
+	globalThis.__PYXIS_HMR__.state.preserve(this.$lifecycle, this.$devId, value);
+	return true;
+}
+function isAtom(input) {
+	return input !== null && typeof input === "object" && input[S_ATOM] === true;
+}
+function read(input) {
+	if (isAtom(input)) {
+		reportAccess(input);
+		return input.get();
+	}
+	return input;
+}
+function peek(input) {
+	if (isAtom(input)) return input.get();
+	return input;
+}
+function write(input, value, force = false) {
+	if (isAtom(input)) {
+		if (input.set(value) || force) {
+			input.$force ||= force;
+			scheduleTick(input.$lifecycle, input.$notify ??= {
+				$fn: notify$1,
+				$a0: input
+			});
+		}
+		return input.get();
+	}
+	return input;
+}
+function update(input, transform, force = false) {
+	if (isAtom(input)) {
+		if (input.set(transform(input.get())) || force) {
+			input.$force ||= force;
+			scheduleTick(input.$lifecycle, input.$notify ??= {
+				$fn: notify$1,
+				$a0: input
+			});
+		}
+		return input.get();
+	}
+	return input;
+}
+/**
+* Notifies the dependencies of an Atom.
+* @internal
+*/
+function notify$1(input) {
+	if (input.$tracksValue) {
+		const newValue = input.get();
+		if (Object.is(input.$lastValue, newValue) && !input.$force) return;
+		input.$lastValue = newValue;
+	}
+	input.$force = false;
+	let current = input.$dh;
+	let next;
+	while (current) {
+		next = current.$an;
+		invoke(current);
+		current = next;
+	}
+}
+
+//#endregion
+//#region src/component/Text.ts
+function Text(jsx, hParent, nUsedParent, _nRealParent, nBefore, isBatch) {
+	const { adapter } = hParent.$ng;
+	let node = null;
+	if (isAtom(jsx)) bind(hParent.$ng, jsx, () => {
+		node = adapter.text(jsx.get()?.toString() ?? "", node);
+	});
+	else node = adapter.text(jsx.toString(), null);
+	insert(node, null, hParent, nUsedParent, nBefore, isBatch);
+}
+
+//#endregion
+//#region src/data/Context.ts
+function createContext() {
+	let $symbol = Symbol();
+	{
+		const devId = arguments[0];
+		$symbol = globalThis.__PYXIS_HMR__.state.restore(createContext, devId) ?? $symbol;
+		globalThis.__PYXIS_HMR__.state.preserve(createContext, devId, $symbol);
+	}
+	return { $symbol };
+}
+let $currentContainer;
+let $isNewContainer = false;
+/** @internal */
+function getContextContainer() {
+	return $currentContainer;
+}
+/** @internal */
+function setContextContainer(container) {
+	$currentContainer = container;
+	$isNewContainer = false;
+}
+/**
+* Gets a consumer Atom for the given Context. This atom will be read-only.
+* @see {@link host}
+*/
+function consumerOf(context) {
+	__DEV__assertNotEffect();
+	const { $symbol } = context;
+	let ptr = $currentContainer;
+	let atom;
+	while (ptr && !(atom = ptr[$symbol])) ptr = ptr.$parent;
+	return atom ?? null;
+}
+function host(context, defaultValue) {
+	__DEV__assertNotEffect();
+	if (!$isNewContainer || !$currentContainer) {
+		$isNewContainer = true;
+		$currentContainer = { $parent: $currentContainer };
+	}
+	const lifecycle = getLifecycle();
+	{
+		const devId = arguments[2];
+		globalThis.__PYXIS_HMR__.state.restore(lifecycle, devId, (value) => {
+			defaultValue = value;
+		});
+	}
+	const localAtom = {
+		[S_ATOM]: true,
+		$lifecycle: lifecycle,
+		$tracksValue: true,
+		$value: defaultValue,
+		get: getLocalValue,
+		set: setValue$1
+	};
+	if (defaultValue === void 0) {
+		const ancestorAtom = consumerOf(context);
+		if (ancestorAtom) {
+			localAtom.get = getAncestorValue;
+			localAtom.$ancestor = ancestorAtom;
+			link(lifecycle, ancestorAtom, localAtom.$dep = {
+				$fn: notify$1,
+				$a0: localAtom
+			});
+		}
+	}
+	localAtom.$devId = arguments[2];
+	if (Object.hasOwn($currentContainer, context.$symbol)) throw new Error("Component declares multiple hosts of the same Context.");
+	$currentContainer[context.$symbol] = localAtom;
+	return localAtom;
+}
+function getAncestorValue() {
+	return this.$ancestor.get();
+}
+function getLocalValue() {
+	return this.$value;
+}
+function setValue$1(value) {
+	let oldValue;
+	if (this.$ancestor) {
+		oldValue = this.$ancestor.get();
+		unlink(this.$dep);
+		this.$dep = null;
+		this.$ancestor = null;
+		this.get = getLocalValue;
+	} else oldValue = this.$value;
+	this.$value = value;
+	globalThis.__PYXIS_HMR__.state.preserve(this.$lifecycle, this.$devId, value);
+	return !Object.is(oldValue, value);
+}
+
+//#endregion
+//#region src/Renderer.ts
+/** @internal */
+const S_COMPONENT = Symbol.for("pyxis:component");
+/** @internal */
+function createRenderer(adapter, extensions) {
+	const hGroup = {
+		adapter,
+		mounted: false,
+		$isGroup: true,
+		$scheduler: createScheduler(adapter.tick),
+		$extensions: extensions,
+		$life: 1,
+		$pg: null,
+		$ng: null,
+		unmount: () => unmount(hGroup),
+		mount: (nRoot, jsx) => {
+			hGroup.$nn = nRoot;
+			const isBatch = Boolean(adapter.batch);
+			const nParent = isBatch ? adapter.batch() : nRoot;
+			mount(jsx, hGroup, nParent, nRoot, null, isBatch);
+			if (isBatch) adapter.insert(nParent, nRoot, null);
+		}
+	};
+	hGroup.$ng = hGroup;
+	globalThis.__PYXIS_ROOT__ ??= hGroup;
+	return hGroup;
+}
+/**
+* Creates a sub-group within the provided MountingGroup. Needed whenever a subtree needs to mount
+* or unmount dynamically.
+*/
+function fork(hParent, hBefore = null) {
+	const ng = hParent.$ng;
+	const hGroup = {
+		adapter: ng.adapter,
+		mounted: false,
+		$isGroup: true,
+		$scheduler: ng.$scheduler,
+		$extensions: ng.$extensions,
+		$life: 1,
+		$context: getContextContainer(),
+		$pg: ng,
+		$ng: null
+	};
+	hGroup.$ng = hGroup;
+	hGroup.$nn = hParent.$nn;
+	track(hGroup, hParent, hBefore);
+	return hGroup;
+}
+/**
+* Adds a HNode to the hierarchy.
+*/
+function track(hNode, hParent, hBefore = null) {
+	if (hBefore?.$pg === hParent) if (hBefore.$hp) {
+		hNode.$hp = hBefore.$hp;
+		hNode.$hn = hBefore;
+		hBefore.$hp.$hn = hNode;
+		hBefore.$hp = hNode;
+	} else {
+		hNode.$hp = null;
+		hNode.$hn = hParent.$hh;
+		if (hParent.$hh === hBefore) hBefore.$hp = hNode;
+		hParent.$hh = hNode;
+	}
+	else {
+		if (hParent.$ht) {
+			hParent.$ht.$hn = hNode;
+			hNode.$hp = hParent.$ht;
+		} else hParent.$hh = hNode;
+		hParent.$ht = hNode;
+	}
+}
+/**
+* Removes a HNode from the tracking hierarchy.
+*/
+function untrack(hNode) {
+	if (hNode.$hp) hNode.$hp.$hn = hNode.$hn;
+	else if (hNode.$pg?.$hh === hNode) hNode.$pg.$hh = hNode.$hn;
+	if (hNode.$hn) hNode.$hn.$hp = hNode.$hp;
+	else if (hNode.$pg?.$ht === hNode) hNode.$pg.$ht = hNode.$hp;
+	hNode.$hp = null;
+	hNode.$hn = null;
+}
+/**
+* Mounts a MountingGroup to the specified location in the node tree. If the group is already
+* mounted (i.e. its native nodes are already rendered somewhere), it is moved to the new location
+* without re-mounting Pyxis components.
+*
+* Note that for successfully moving a group within the tree, you should first `untrack` the group,
+* then re-`track` it to the new location and only then call `mount` to commit the move.
+* @see {@link track}
+* @see {@link untrack}
+*/
+function mount(jsx, hGroup, nUsedParent, nRealParent, nBefore, isBatch) {
+	if (hGroup.mounted) {
+		reinsertNodes(hGroup, nUsedParent, nBefore);
+		return;
+	}
+	const previousLifecycle = setLifecycle(hGroup);
+	setContextContainer(hGroup.$context);
+	try {
+		mountJsx(jsx, hGroup, nUsedParent, nRealParent, nBefore, isBatch);
+	} finally {
+		setLifecycle(previousLifecycle);
+		hGroup.mounted = true;
+		if (hGroup.$pg?.mounted !== false) notifyMounted(hGroup);
+	}
+}
+/**
+* Only used by `mount`, do not call directly.
+*
+* Recursively (dept-first) runs components' `mounted` callbacks.
+* @see {@link mount}
+* @internal
+*/
+function notifyMounted(hNode) {
+	let current = hNode.$hh;
+	while (current) {
+		notifyMounted(current);
+		current = current.$hn;
+	}
+	let callbacks;
+	if (hNode.$isGroup && hNode.mounted && (callbacks = hNode.$onMount)) {
+		const previousLifecycle = setLifecycle(hNode);
+		try {
+			callbacks.forEach(invoke);
+		} finally {
+			callbacks.length = 0;
+			setLifecycle(previousLifecycle);
+		}
+	}
+}
+/**
+* Only used by `mount`, do not call directly.
+*
+* Re-inserts native nodes of the given group to the specified location in the native tree. Only
+* moves the uppermost nodes - any children should move implicitly with them.
+* @see {@link mount}
+* @internal
+*/
+function reinsertNodes(hGroup, nParent, nBefore) {
+	const { adapter } = hGroup;
+	let current = hGroup.$hh;
+	while (current) {
+		if (current.$isNative) adapter.insert(current.$nn, nParent, nBefore);
+		else reinsertNodes(current, nParent, nBefore);
+		current = current.$hn;
+	}
+}
+function unmount(hNode, top = true) {
+	if (hNode.$isGroup) {
+		if (hNode.mounted) {
+			let callbacks;
+			if (callbacks = hNode.$onUnmount) {
+				const previousLifecycle = setLifecycle(hNode);
+				try {
+					callbacks.forEach(invoke);
+				} finally {
+					callbacks.length = 0;
+					setLifecycle(previousLifecycle);
+				}
+			}
+			hNode.mounted = false;
+			hNode.$life += 1;
+		}
+		unlinkAll(hNode);
+	}
+	const { adapter } = hNode.$ng;
+	let current = hNode.$hh;
+	let next;
+	while (current) {
+		if (current.$isNative && top) {
+			adapter.remove(current.$nn);
+			unmount(current, false);
+		} else unmount(current, top);
+		next = current.$hn;
+		current.$hp = null;
+		current.$hn = null;
+		current = next;
+	}
+	hNode.$hh = null;
+	hNode.$ht = null;
+}
+/**
+* Mounts components described by the JsxResult to the specified location in the node tree.
+*/
+function mountJsx(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) {
+	switch (typeof jsx) {
+		case "object":
+			if (jsx === null) break;
+			if (Array.isArray(jsx)) {
+				const { length } = jsx;
+				let index = 0;
+				for (; index < length; index += 1) mountJsx(jsx[index], hParent, nUsedParent, nRealParent, nBefore, isBatch);
+				break;
+			}
+			if (!isAtom(jsx)) {
+				jsx[S_COMPONENT]?.(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch);
+				break;
+			}
+		case "string":
+		case "number":
+		case "boolean":
+		case "bigint":
+			Text(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch);
+			break;
+	}
+}
+/**
+* Inserts a native node and adds it to the tracking hierarchy. Necessary to preserve render order.
+* Should only be called by component handlers!
+*/
+function insert(nNode, children, hParent, nUsedParent, nBefore, isBatch) {
+	let hNative = hParent;
+	if (hNative.$isGroup) {
+		let hBefore = null;
+		if (nBefore) {
+			let current = hParent.$ht;
+			while (current) {
+				if (current.$isNative && current.$nn === nBefore) {
+					hBefore = current;
+					break;
+				}
+				current = current.$hp;
+			}
+		}
+		track(hNative = {
+			$isNative: true,
+			$pg: hNative,
+			$ng: hNative,
+			$nn: nNode
+		}, hParent, hBefore);
+	}
+	mountJsx(children, hNative, nNode, nNode, null, isBatch);
+	hParent.$ng.adapter.insert(nNode, nUsedParent, nBefore);
+}
+
+//#endregion
+//#region src/component/Fragment.ts
+function Fragment(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) {
+	mountJsx(jsx.children, hParent, nUsedParent, nRealParent, nBefore, isBatch);
+}
+
+//#endregion
+//#region src/data/ListDelta.ts
+/** @internal */
+const LC_CHANGE = 1;
+/** @internal */
+const LC_INSERT = 2;
+/** @internal */
+const LC_REMOVE = 3;
+/** @internal */
+const LC_CLEAR = 4;
+let ChangeKind = /* @__PURE__ */ function(ChangeKind) {
+	ChangeKind[ChangeKind["Change"] = 1] = "Change";
+	ChangeKind[ChangeKind["Insert"] = 2] = "Insert";
+	ChangeKind[ChangeKind["Remove"] = 3] = "Remove";
+	ChangeKind[ChangeKind["Clear"] = 4] = "Clear";
+	return ChangeKind;
+}({});
+/** @internal */
+function createDelta() {
+	return {
+		changes: [],
+		lengthChange: 0
+	};
+}
+/** @internal */
+function itemChanged({ changes: $changes }, at, oldItem, newItem) {
+	const ci = binarySearch($changes, at, latest);
+	if (ci < 0) $changes.splice(~ci, 0, {
+		kind: 1,
+		index: at,
+		oldItem,
+		newItem
+	});
+	else {
+		const current = $changes[ci];
+		switch (current.kind) {
+			case 1:
+			case 2:
+				current.newItem = newItem;
+				break;
+			case 3:
+				$changes.splice(ci + 1, 0, {
+					kind: 1,
+					index: at,
+					oldItem,
+					newItem
+				});
+				break;
+		}
+	}
+}
+/** @internal */
+function itemInserted(delta, at, item) {
+	const { changes: $changes } = delta;
+	let ci = binarySearch($changes, at, earliest);
+	if (ci < 0) {
+		ci = ~ci;
+		$changes.splice(ci, 0, {
+			kind: 2,
+			index: at,
+			newItem: item
+		});
+	} else {
+		const current = $changes[ci];
+		switch (current.kind) {
+			case 1:
+			case 2:
+				$changes.splice(ci, 0, {
+					kind: 2,
+					index: at,
+					newItem: item
+				});
+				break;
+			case 3:
+				current.kind = 1;
+				current.newItem = item;
+				break;
+		}
+	}
+	const { length } = $changes;
+	while (++ci < length) $changes[ci].index += 1;
+	delta.lengthChange += 1;
+}
+/** @internal */
+function itemRemoved(delta, at, item) {
+	const { changes: $changes } = delta;
+	let ci = binarySearch($changes, at, latest);
+	if (ci < 0) {
+		ci = ~ci;
+		$changes.splice(ci, 0, {
+			kind: 3,
+			index: at,
+			oldItem: item
+		});
+	} else {
+		const current = $changes[ci];
+		switch (current.kind) {
+			case 1:
+				current.kind = 3;
+				current.newItem = void 0;
+				break;
+			case 2:
+				$changes.splice(ci--, 1);
+				break;
+			case 3:
+				$changes.splice(++ci, 0, {
+					kind: 3,
+					index: at,
+					oldItem: item
+				});
+				break;
+		}
+	}
+	const { length } = $changes;
+	while (++ci < length) $changes[ci].index -= 1;
+	delta.lengthChange -= 1;
+}
+/** @internal */
+function listCleared(delta, count) {
+	const { changes: $changes } = delta;
+	$changes.length = 0;
+	$changes.push({
+		kind: 4,
+		index: -1
+	});
+	delta.lengthChange -= count;
+}
+/** @internal */
+function listSynced(delta, oldState, newState, eq) {
+	let index = 0;
+	let N = oldState.length;
+	let M = newState.length;
+	while (index < N && index < M && eq(oldState[index], newState[index])) index += 1;
+	if (index === N && index === M) return;
+	while (N > index && M > index && eq(oldState[N - 1], newState[M - 1])) {
+		N -= 1;
+		M -= 1;
+	}
+	const Z = (Math.min(N, M) + 1) * 2;
+	const L = N + M;
+	const state = {
+		$eq: eq,
+		$list0: oldState,
+		$list1: newState,
+		$index0: index,
+		$index1: index,
+		$N: N,
+		$M: M,
+		$Z: Z,
+		$c: 0,
+		$buffer: new (L <= 255 ? Uint8Array : L <= 65535 ? Uint16Array : Uint32Array)(Z + Z),
+		$stack: [],
+		$stackTop: 0,
+		$pxs: -1,
+		$pxe: -1,
+		$pys: -1,
+		$pye: -1,
+		$oxs: -1,
+		$oxe: -1,
+		$oys: -1,
+		$oye: -1
+	};
+	let offset = 0;
+	let rs, re, is, ie, r, i;
+	do {
+		myersDiff(state);
+		if (state.$c === 1) {
+			rs = state.$oxs;
+			re = state.$oxe;
+			is = state.$oys;
+			ie = state.$oye;
+		} else if (state.$pxs >= 0) {
+			rs = state.$pxs;
+			re = state.$pxe;
+			is = state.$pys;
+			ie = state.$pye;
+		} else break;
+		for (r = rs; r < re; r += 1) itemRemoved(delta, rs + offset, oldState[r]);
+		for (i = is; i < ie; i += 1) {
+			itemInserted(delta, rs + offset, newState[i]);
+			offset += 1;
+		}
+		offset -= re - rs;
+	} while (state.$c < 2);
+}
+const latest = (changes, index, mid, _min, max) => {
+	let i = mid;
+	while (++i < max && changes[i].index === index);
+	return i - 1;
+};
+const earliest = (changes, index, mid, min, _max) => {
+	let i = mid;
+	while (--i >= min && changes[i].index === index);
+	return i + 1;
+};
+function binarySearch(changes, index, bias) {
+	let min = 0;
+	let max = changes.length;
+	let mid;
+	let tmp;
+	while (min < max) {
+		mid = min + max >>> 1;
+		tmp = changes[mid].index;
+		if (index < tmp) max = mid;
+		else if (index > tmp) min = mid + 1;
+		else return bias(changes, index, mid, min, max);
+	}
+	return ~min;
+}
+function myersDiff(state) {
+	const { $list0, $list1, $buffer, $stack, $eq } = state;
+	let { $index0, $index1, $N, $M, $Z, $c, $stackTop } = state;
+	let W, L, parity, offsetX, offsetY, z, h, hMax, k, kMin, kMax, gkm, gkp, u, v, x, y, pkm, pkp, sx;
+	while (true) switch ($c) {
+		case 0:
+			Z_block: while ($N > 0 && $M > 0) {
+				W = $N - $M;
+				L = $N + $M;
+				parity = L & 1;
+				offsetX = $index0 + $N - 1;
+				offsetY = $index1 + $M - 1;
+				hMax = (L + parity) / 2;
+				$buffer.fill(0, 0, $Z + $Z);
+				h_loop: for (h = 0; h <= hMax; h += 1) {
+					kMin = 2 * Math.max(0, h - $M) - h;
+					kMax = h - 2 * Math.max(0, h - $N);
+					for (k = kMin; k <= kMax; k += 2) {
+						gkm = $buffer[k - 1 - $Z * Math.floor((k - 1) / $Z)];
+						gkp = $buffer[k + 1 - $Z * Math.floor((k + 1) / $Z)];
+						u = k === -h || k !== h && gkm < gkp ? gkp : gkm + 1;
+						v = u - k;
+						x = u;
+						y = v;
+						while (x < $N && y < $M && $eq($list0[$index0 + x], $list1[$index1 + y])) {
+							x += 1;
+							y += 1;
+						}
+						$buffer[k - $Z * Math.floor(k / $Z)] = x;
+						if (parity === 1 && (z = W - k) >= 1 - h && z < h && x + $buffer[$Z + z - $Z * Math.floor(z / $Z)] >= $N) if (h > 1 || x !== u) {
+							$stack[$stackTop++] = $index0 + x;
+							$stack[$stackTop++] = $index1 + y;
+							$stack[$stackTop++] = $N - x;
+							$stack[$stackTop++] = $M - y;
+							$N = u;
+							$M = v;
+							$Z = 2 * (Math.min($N, $M) + 1);
+							continue Z_block;
+						} else break h_loop;
+					}
+					for (k = kMin; k <= kMax; k += 2) {
+						pkm = $buffer[$Z + k - 1 - $Z * Math.floor((k - 1) / $Z)];
+						pkp = $buffer[$Z + k + 1 - $Z * Math.floor((k + 1) / $Z)];
+						u = k === -h || k !== h && pkm < pkp ? pkp : pkm + 1;
+						v = u - k;
+						x = u;
+						y = v;
+						while (x < $N && y < $M && $eq($list0[offsetX - x], $list1[offsetY - y])) {
+							x += 1;
+							y += 1;
+						}
+						$buffer[$Z + k - $Z * Math.floor(k / $Z)] = x;
+						if (parity === 0 && (z = W - k) >= -h && z <= h && x + $buffer[z - $Z * Math.floor(z / $Z)] >= $N) if (h > 0 || x !== u) {
+							$stack[$stackTop++] = $index0 + $N - u;
+							$stack[$stackTop++] = $index1 + $M - v;
+							$stack[$stackTop++] = u;
+							$stack[$stackTop++] = v;
+							$N = $N - x;
+							$M = $M - y;
+							$Z = 2 * (Math.min($N, $M) + 1);
+							continue Z_block;
+						} else break h_loop;
+					}
+				}
+				if ($N === $M) continue;
+				if ($M > $N) {
+					$index0 += $N;
+					$index1 += $N;
+					$M -= $N;
+					$N = 0;
+				} else {
+					$index0 += $M;
+					$index1 += $M;
+					$N -= $M;
+					$M = 0;
+				}
+				break;
+			}
+			if ($N + $M !== 0) if (state.$pxe === $index0 || state.$pye === $index1) {
+				state.$pxe = $index0 + $N;
+				state.$pye = $index1 + $M;
+			} else {
+				sx = state.$pxs;
+				state.$oxs = state.$pxs;
+				state.$oxe = state.$pxe;
+				state.$oys = state.$pys;
+				state.$oye = state.$pye;
+				state.$pxs = $index0;
+				state.$pxe = $index0 + $N;
+				state.$pys = $index1;
+				state.$pye = $index1 + $M;
+				if (sx >= 0) {
+					state.$index0 = $index0;
+					state.$index1 = $index1;
+					state.$N = $N;
+					state.$M = $M;
+					state.$Z = $Z;
+					state.$stackTop = $stackTop;
+					state.$c = 1;
+					return;
+				}
+			}
+		case 1:
+			if ($stackTop === 0) {
+				state.$c = 2;
+				return;
+			}
+			$M = $stack[--$stackTop];
+			$N = $stack[--$stackTop];
+			$index1 = $stack[--$stackTop];
+			$index0 = $stack[--$stackTop];
+			$Z = 2 * (Math.min($N, $M) + 1);
+			$c = 0;
+	}
+}
+
+//#endregion
+//#region src/data/ProxyAtom.ts
+/**
+* Creates a ProxyAtom bound to the provided initial value. If it is an Atom, the proxy will mirror
+* it, otherwise it will be a read-only atom with a static value until rebound.
+*/
+function proxyOf(initialValue, lifecycle = getLifecycle()) {
+	__DEV__assertNotEffect();
+	const self = {
+		[S_ATOM]: true,
+		$lifecycle: lifecycle,
+		use,
+		get: getStaticValue
+	};
+	self.use(initialValue, false);
+	return self;
+}
+function use(value, canNotify = true) {
+	if (this.$dep) unlink(this.$dep);
+	const oldValue = this.get();
+	if (isAtom(value)) {
+		this.$bound = value;
+		this.$value = null;
+		this.get = getBoundValue;
+		this.set = setBoundValue;
+		link(this.$lifecycle, value, this.$dep ??= {
+			$fn: notify$1,
+			$a0: this
+		});
+	} else {
+		this.$bound = null;
+		this.$value = value;
+		this.get = getStaticValue;
+		this.set = setStaticValue;
+	}
+	if (canNotify && !Object.is(oldValue, this.get())) scheduleTick(this.$lifecycle, this.$notify ??= {
+		$fn: notify$1,
+		$a0: this
+	});
+}
+function getBoundValue() {
+	return this.$bound.get();
+}
+function setBoundValue(value) {
+	const atom = this.$bound;
+	if (atom.set(value)) scheduleTick(atom.$lifecycle, atom.$notify ??= {
+		$fn: notify$1,
+		$a0: atom
+	});
+	return false;
+}
+function getStaticValue() {
+	return this.$value;
+}
+function setStaticValue() {
+	return false;
+}
+const EMPTY_SOURCE = {};
+/**
+* Copies select keys from a data object into a new object where values are all wrapped in
+* ProxyAtoms and can be updated later.
+* @see {@link updateProxy}
+* @internal
+**/
+function createProxy(lifecycle, data, keys) {
+	const source = isObject(data) ? data : EMPTY_SOURCE;
+	const proxy = {};
+	const { length } = keys;
+	let index = 0;
+	let key;
+	for (; index < length; index += 1) {
+		key = keys[index];
+		proxy[key] = proxyOf(source[key], lifecycle);
+	}
+	proxy.proxied = data;
+	return proxy;
+}
+/**
+* Updates the values proxied by a previously created proxy object. The keys array must be the same
+* as was used during creation (or a subset).
+* @see {@link createProxy}
+* @internal
+**/
+function updateProxy(proxy, data, keys) {
+	const source = isObject(data) ? data : EMPTY_SOURCE;
+	const { length } = keys;
+	proxy.proxied = data;
+	let index = 0;
+	let key;
+	for (; index < length; index += 1) {
+		key = keys[index];
+		proxy[key].use(source[key]);
+	}
+}
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+
+//#endregion
+//#region src/component/Iterator.ts
+function Iterator(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) {
+	const source = jsx.source;
+	const proxyKeys = jsx.proxy;
+	const isProxy = proxyKeys !== void 0;
+	const template = jsx.children[0];
+	const hGroup = fork(hParent);
+	const { adapter } = hGroup;
+	const shouldBatch = Boolean(adapter.batch);
+	const nListEndMarker = adapter.marker("/Iterator");
+	let items;
+	let skipDelta = Boolean(source.$delta);
+	const onDelta = () => {
+		if (skipDelta) {
+			skipDelta = false;
+			return;
+		}
+		const { changes, lengthChange } = source.$delta;
+		const cMax = changes.length;
+		const iMax = items.length + lengthChange;
+		const newItems = new Array(iMax);
+		const pending = [];
+		let recycled = [];
+		let item;
+		let inserted = 0;
+		let ci = 0;
+		let oi = 0;
+		let ni = 0;
+		let change;
+		let ref;
+		let tmp;
+		let isLocalBatch = false;
+		let nBatchParent = nRealParent;
+		let nBatchBefore = null;
+		for (; ci < cMax; ci += 1) {
+			change = changes[ci];
+			while (ni < change.index) newItems[ni++] = items[oi++];
+			switch (change.kind) {
+				case 1:
+					item = newItems[ni++] = items[oi++];
+					if (isProxy) updateProxy(item.$data, change.newItem, proxyKeys);
+					else {
+						unmount(item);
+						ref = items[oi]?.$marker ?? nListEndMarker;
+						insert(item.$marker, null, item, nRealParent, ref, false);
+						mount(withLifecycle(item, template, item.$data = change.newItem), item, nRealParent, nRealParent, ref, false);
+					}
+					break;
+				case 2:
+					if (!isProxy || inserted < lengthChange) {
+						item = newItems[ni++] = fork(hGroup, items[oi]);
+						item.$marker = adapter.marker("IteratorItem");
+						item.$data = isProxy ? createProxy(item, change.newItem, proxyKeys) : change.newItem;
+						inserted += 1;
+						ref = items[oi]?.$marker ?? nListEndMarker;
+						if (!isLocalBatch) if (shouldBatch) {
+							isLocalBatch = true;
+							nBatchParent = adapter.batch();
+							nBatchBefore = null;
+						} else nBatchBefore = ref;
+						insert(item.$marker, null, item, nBatchParent, nBatchBefore, isLocalBatch);
+						mount(withLifecycle(item, template, item.$data), item, nBatchParent, nRealParent, nBatchBefore, isLocalBatch);
+						if (isLocalBatch && (inserted >= lengthChange || !(tmp = changes[ci + 1]) || tmp.kind !== 2 || tmp.index !== ni)) {
+							adapter.insert(nBatchParent, nRealParent, ref);
+							nBatchParent = nRealParent;
+							isLocalBatch = false;
+						}
+					} else pending.push({
+						$index: ni++,
+						$item: change.newItem
+					});
+					break;
+				case 3:
+					item = items[oi++];
+					if (isProxy) recycled.push(item);
+					else unmount(item);
+					untrack(item);
+					break;
+				case 4:
+					if (isProxy) {
+						recycled = items;
+						recycled.forEach(untrack);
+						oi = items.length;
+					} else while (oi < items.length) {
+						item = items[oi++];
+						unmount(item);
+						untrack(item);
+					}
+					break;
+			}
+		}
+		while (ni < iMax) newItems[ni++] = items[oi++];
+		let pi = pending.length - 1;
+		let ri = recycled.length - 1;
+		while (pi >= 0) {
+			tmp = pending[pi--];
+			item = newItems[tmp.$index] = recycled[ri--];
+			updateProxy(item.$data, tmp.$item, proxyKeys);
+			track(item, hGroup, ref = newItems[tmp.$index + 1]);
+			mount(withLifecycle(item, template, item.$data), item, nRealParent, nRealParent, ref?.$marker ?? nListEndMarker, false);
+		}
+		while (ri >= 0) {
+			item = recycled[ri--];
+			unmount(item);
+			untrack(item);
+		}
+		items = newItems;
+	};
+	link(hGroup, source, { $fn: onDelta });
+	{
+		let nBatchParent = nUsedParent;
+		let nBatchBefore = nBefore;
+		const isLocalBatch = shouldBatch && !isBatch && source.$items.length > 0;
+		if (isLocalBatch) {
+			nBatchParent = adapter.batch();
+			nBatchBefore = null;
+		}
+		const isAnyBatch = isLocalBatch || isBatch;
+		items = source.$items.map((data) => {
+			const item = fork(hGroup);
+			item.$marker = adapter.marker("IteratorItem");
+			item.$data = isProxy ? createProxy(item, data, proxyKeys) : data;
+			insert(item.$marker, null, item, nBatchParent, nBatchBefore, isAnyBatch);
+			mount(withLifecycle(item, template, item.$data), item, nBatchParent, nRealParent, nBatchBefore, isAnyBatch);
+			return item;
+		});
+		insert(nListEndMarker, null, hGroup, nBatchParent, nBatchBefore, isAnyBatch);
+		if (isLocalBatch) adapter.insert(nBatchParent, nUsedParent, nBefore);
+	}
+	mount(null, hGroup, nUsedParent, nRealParent, nBefore, isBatch);
+}
+
+//#endregion
+//#region src/component/Native.ts
+const RE_EXT = /^([^:]+?):(.+)$/;
+/** @internal */
+const S_TAG_NAME = Symbol.for("pyxis:tagName");
+function Native(jsx, hParent, nUsedParent, _nRealParent, nBefore, isBatch) {
+	const hGroup = hParent.$ng;
+	const { adapter, $extensions } = hGroup;
+	const nNode = adapter.element(jsx[S_TAG_NAME]);
+	let name;
+	let match;
+	let value;
+	for (name in jsx) {
+		match = RE_EXT.exec(name);
+		value = jsx[name];
+		if (match) $extensions[match[1]]?.set(nNode, match[2], value, hGroup);
+		else if (name !== "children") if (isAtom(value)) {
+			const prop = name;
+			const atom = value;
+			bind(hGroup, atom, () => {
+				adapter.set(nNode, prop, atom.get());
+			});
+		} else adapter.set(nNode, name, value);
+	}
+	insert(nNode, jsx.children, hParent, nUsedParent, nBefore, isBatch);
+}
+
+//#endregion
+//#region src/component/Show.ts
+function Show(jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) {
+	const when = jsx.when;
+	if (!isAtom(when) && when === false) return;
+	const { children, data } = jsx;
+	const proxyKeys = jsx.proxy;
+	const template = Object.hasOwn(jsx, "data") ? children[0] : () => children;
+	let dataOrProxy = data;
+	if (proxyKeys) if (isAtom(data)) {
+		dataOrProxy = createProxy(hParent.$ng, data.get(), proxyKeys);
+		link(hParent.$ng, data, { $fn: () => {
+			updateProxy(dataOrProxy, data.get(), proxyKeys);
+		} });
+	} else dataOrProxy = createProxy(hParent.$ng, data, proxyKeys);
+	const adapter = hParent.$ng.adapter;
+	const shouldBatch = Boolean(adapter.batch);
+	if (!(isAtom(when) || isAtom(template) || !proxyKeys && isAtom(data))) {
+		const isLocalBatch = shouldBatch && !isBatch;
+		let nBatchParent = nUsedParent;
+		let nBatchBefore = nBefore;
+		if (isLocalBatch) {
+			nBatchParent = adapter.batch();
+			nBatchBefore = null;
+		}
+		mountJsx(template(dataOrProxy), hParent, nBatchParent, nRealParent, nBatchBefore, isLocalBatch || isBatch);
+		if (isLocalBatch) adapter.insert(nBatchParent, nUsedParent, nBefore);
+		return;
+	}
+	const hGroup = fork(hParent);
+	let nMarker = nBefore;
+	effect(() => {
+		if (read(when) === false) return;
+		const isLocalBatch = shouldBatch && !isBatch;
+		let nBatchParent = nUsedParent;
+		let nBatchBefore = nMarker;
+		if (isLocalBatch) {
+			nBatchParent = adapter.batch();
+			nBatchBefore = null;
+		}
+		mount(withLifecycle(hGroup, read(template), read(dataOrProxy)), hGroup, nBatchParent, nRealParent, nBatchBefore, isLocalBatch || isBatch);
+		if (isLocalBatch) adapter.insert(nBatchParent, nUsedParent, nMarker);
+		return () => unmount(hGroup);
+	}, hParent.$ng);
+	nMarker = adapter.marker("/Show");
+	insert(nMarker, null, hParent, nUsedParent, nBefore, isBatch);
+	isBatch = false;
+	nUsedParent = nRealParent;
+}
+
+//#endregion
+//#region src/data/Derivation.ts
+/**
+* Creates a Derivation - an Atom with its value computed from other Atoms. The block runs once
+* eagerly to compute the initial value, then re-runs within scheduler ticks whenever its source
+* Atoms change. Observers are only notified if the new value differs from the previous.
+*/
+function derived(block, lifecycle = getLifecycle()) {
+	__DEV__assertNotEffect();
+	const atom = {
+		[S_ATOM]: true,
+		$dirty: false,
+		$value: null,
+		$tracksValue: true,
+		$lifecycle: lifecycle,
+		$life: lifecycle.$life,
+		$lastValue: null,
+		$cycle: 0,
+		$block: block,
+		$react: scheduleNotify,
+		get: getValue,
+		set: setValue
+	};
+	const value = resolve(atom);
+	atom.$value = value;
+	atom.$lastValue = value;
+	return atom;
+}
+function scheduleNotify(derivation, cycle) {
+	if (derivation.$life !== derivation.$lifecycle.$life || derivation.$cycle > cycle) {
+		unlink(this);
+		return;
+	}
+	derivation.$dirty = true;
+	scheduleTick(derivation.$lifecycle, derivation.$notify ??= {
+		$fn: notify$1,
+		$a0: derivation
+	});
+}
+function getValue() {
+	if (this.$dirty && this.$life === this.$lifecycle.$life) {
+		this.$value = resolve(this);
+		this.$dirty = false;
+	}
+	return this.$value;
+}
+function setValue() {
+	return false;
+}
+
+//#endregion
+//#region src/data/List.ts
+function listOf(source, lifecycle = getLifecycle()) {
+	{
+		__DEV__assertNotEffect();
+		const devId = arguments[2];
+		globalThis.__PYXIS_HMR__.state.restore(lifecycle, devId, (value) => {
+			if (Array.isArray(value)) source = value;
+		});
+	}
+	const list = {
+		$lifecycle: lifecycle,
+		$items: source ? Array.from(source) : [],
+		$delta: null,
+		[Symbol.iterator]: getIterator,
+		size,
+		get,
+		delta,
+		raw,
+		forEach,
+		set,
+		clear,
+		insertAt,
+		insertFirst,
+		insertLast,
+		remove,
+		removeAt,
+		removeFirst,
+		removeLast
+	};
+	list.$devId = arguments[2];
+	return list;
+}
+/**
+* Synchronizes the provided List with the given data source. After this operation, the list will
+* contain an exact copy of the source.
+*
+* Note: This function is separated instead of being a List method since the underlying diff
+* algorithm (Myers) is a relatively large chunk of code which would otherwise always get included
+* into bundled builds. This way, tools like Terser can eliminate the extra code when unused.
+*/
+function sync(list, source, eq = defaultEquals) {
+	const oldState = list.$items;
+	list.$items = source.slice();
+	listSynced(list.$delta ??= createDelta(), oldState, source, eq);
+	listMutated(list);
+}
+function size() {
+	reportAccess(this);
+	return this.$items.length;
+}
+function get(index) {
+	reportAccess(this);
+	return this.$items[index];
+}
+function delta() {
+	reportAccess(this);
+	return this.$delta;
+}
+function raw() {
+	reportAccess(this);
+	return this.$items;
+}
+function forEach(callback, thisArg) {
+	reportAccess(this);
+	this.$items.forEach(callback, thisArg);
+}
+function getIterator() {
+	reportAccess(this);
+	return this.$items[Symbol.iterator]();
+}
+function set(index, newItem) {
+	assertIndex(this, index);
+	const oldItem = this.$items[index];
+	if (Object.is(newItem, oldItem)) return;
+	this.$items[index] = newItem;
+	if (this.$dh) {
+		itemChanged(this.$delta ??= createDelta(), index, oldItem, newItem);
+		listMutated(this);
+	}
+}
+function clear() {
+	const count = this.$items.length;
+	this.$items.length = 0;
+	if (this.$dh) {
+		listCleared(this.$delta ??= createDelta(), count);
+		listMutated(this);
+	}
+}
+function insertAt(index, item) {
+	const { $items } = this;
+	if (index === $items.length) $items.push(item);
+	else {
+		assertIndex(this, index);
+		this.$items.splice(index, 0, item);
+	}
+	if (this.$dh) {
+		itemInserted(this.$delta ??= createDelta(), index, item);
+		listMutated(this);
+	}
+}
+function insertFirst(item) {
+	this.insertAt(0, item);
+}
+function insertLast(item) {
+	this.insertAt(this.$items.length, item);
+}
+function remove(item) {
+	const index = this.$items.indexOf(item);
+	if (index === -1) return false;
+	this.removeAt(index);
+	return true;
+}
+function removeAt(index) {
+	assertIndex(this, index);
+	const item = this.$items.splice(index, 1)[0];
+	if (this.$dh) {
+		itemRemoved(this.$delta ??= createDelta(), index, item);
+		listMutated(this);
+	}
+	return item;
+}
+function removeFirst() {
+	return this.$items.length > 0 ? this.removeAt(0) : void 0;
+}
+function removeLast() {
+	const { length } = this.$items;
+	return length > 0 ? this.removeAt(length - 1) : void 0;
+}
+function assertIndex(list, index) {
+	if (index >= list.$items.length || index < 0) throw new RangeError("list index out of bounds");
+}
+function defaultEquals(item0, item1) {
+	return Object.is(item0, item1);
+}
+function listMutated(list) {
+	globalThis.__PYXIS_HMR__.state.preserve(list.$lifecycle, list.$devId, list.$items);
+	scheduleTick(list.$lifecycle, list.$notify ??= {
+		$fn: notify,
+		$a0: list
+	});
+	scheduleTock(list.$lifecycle, list.$cleanup ??= {
+		$fn: cleanup,
+		$a0: list
+	});
+}
+function notify(list) {
+	let current = list.$dh;
+	let next;
+	while (current) {
+		next = current.$an;
+		invoke(current);
+		current = next;
+	}
+}
+function cleanup(list) {
+	list.$delta = null;
+}
+
+//#endregion
+//#region src/extension/RefExtension.ts
+/**
+* Extension adding direct reference access to any element. Recommended prefix:
+* `"ref"`
+*
+* References can be stored into atoms:
+* ```tsx
+* const wrapperRef = atomOf<HTMLDivElement>();
+* <div ref:atom={wrapperRef} />
+* ```
+* or handled with a custom callback:
+* ```tsx
+* const onWrapperRef = (node: HTMLDivElement) => { ... };
+* <div ref:call={onWrapperRef} />
+* ```
+*/
+const RefExtension = { set: (node, kind, value) => {
+	let method;
+	switch (kind) {
+		case "atom":
+			if (!isAtom(value)) return;
+			method = refAtom;
+			break;
+		case "call":
+			if (typeof value !== "function") return;
+			method = refCall;
+			break;
+		default: return;
+	}
+	const lifecycle = getLifecycle();
+	onMounted(lifecycle, {
+		$fn: method,
+		$a0: value,
+		$a1: node
+	});
+	onUnmounted(lifecycle, {
+		$fn: method,
+		$a0: value,
+		$a1: null
+	});
+} };
+function refAtom(atom, node) {
+	atom.set(node);
+}
+function refCall(setter, node) {
+	setter(node);
+}
+
+//#endregion
+//#region src/support/text.ts
+function tag(access, strings, values) {
+	const { length } = values;
+	let index = 0;
+	let text = strings[0];
+	while (index < length) text += access(values[index]) + strings[++index];
+	return text;
+}
+/**
+* A template literal tag that automatically wraps each substitution in a `read` call.
+* @see {@link read}
+*/
+function reads(strings, ...values) {
+	return tag(read, strings, values);
+}
+/**
+* A template literal tag that automatically wraps each substitution in a `peek` call.
+* @see {@link peek}
+*/
+function peeks(strings, ...values) {
+	return tag(peek, strings, values);
+}
+
+//#endregion
+//#region src/Builder.ts
+function pyxis(adapter) {
+	const extensions = {};
+	const builder = {
+		build: () => createRenderer(adapter, extensions),
+		extend: (extensionKey, extension) => {
+			extensions[extensionKey] = extension;
+			return builder;
+		}
+	};
+	return builder;
+}
+
+//#endregion
+//#region src/Component.ts
+function component(block) {
+	let devId;
+	devId = arguments[1];
+	devId && globalThis.__PYXIS_HMR__.component.upsert(devId, block);
+	return (jsx, hParent, nUsedParent, nRealParent, nBefore, isBatch) => {
+		const context = getContextContainer();
+		try {
+			{
+				if (!import.meta.hot || !devId) {
+					setContextContainer(context);
+					mountJsx(block(jsx), hParent, nUsedParent, nRealParent, nBefore, isBatch);
+					return;
+				}
+				const hGroup = fork(hParent);
+				const nMarker = hGroup.adapter.marker(`/${devId}`);
+				insert(nMarker, null, hParent, nUsedParent, nBefore, isBatch);
+				unmounted(globalThis.__PYXIS_HMR__.component.subscribe(devId, (impl) => {
+					unmount(hGroup);
+					mount({
+						...jsx,
+						[S_COMPONENT]: (() => mountJsx(impl(jsx), hGroup, nUsedParent, nRealParent, nMarker, isBatch))
+					}, hGroup, nUsedParent, nRealParent, nMarker, isBatch);
+				}));
+				nUsedParent = nRealParent;
+				isBatch = false;
+			}
+		} finally {
+			setContextContainer(context);
+		}
+	};
+}
+
+//#endregion
+//#region src/jsx.ts
+const EMPTY_ARRAY = Object.freeze([]);
+function jsx(componentOrTagName, props, key) {
+	const { children } = props;
+	props.children = children === void 0 ? EMPTY_ARRAY : Array.isArray(children) ? children : [children];
+	props.key ??= key;
+	if (typeof componentOrTagName === "string") {
+		props[S_COMPONENT] = Native;
+		props[S_TAG_NAME] = componentOrTagName;
+	} else props[S_COMPONENT] = componentOrTagName;
+	return props;
+}
+function jsxs(componentOrTagName, props, key) {
+	props.key ??= key;
+	if (typeof componentOrTagName === "string") {
+		props[S_COMPONENT] = Native;
+		props[S_TAG_NAME] = componentOrTagName;
+	} else props[S_COMPONENT] = componentOrTagName;
+	return props;
+}
+
+//#endregion
+export { ChangeKind, Fragment, Iterator, Native, RefExtension, Show, atomOf, bind, component, consumerOf, createContext, derived, effect, fork, getLifecycle, host, insert, isAtom, jsx, jsxs, listOf, mount, mountJsx, mounted, peek, peeks, proxyOf, pyxis, read, reads, sync, tick, tock, track, unmount, unmounted, untrack, update, withLifecycle, write };
+//# sourceMappingURL=core-dev.js.map