snapse 0.0.0-stage → 0.9.0

package/dist/snapseCore-DpadpXgD.js

@@ -0,0 +1,3002 @@
+//#region src/state/transforms/transforms.ts
+var transforms = {};
+//#endregion
+//#region src/state/common/refCountAndType.ts
+var STATE_TYPE_BITS = 3;
+var STATE_TYPE_MASK = 2 ** STATE_TYPE_BITS - 1;
+var PROMOTED_ELEMENT_FLAG = 2 ** STATE_TYPE_BITS;
+var REFCOUNT_SHIFT = 4;
+var NON_REFCOUNT_MASK = 15;
+var getStateType = (s) => s.rct & STATE_TYPE_MASK;
+var setStateType = (s, stateType) => s.rct = s.rct & -8 | stateType;
+var getRefCount = (s) => s.rct >>> REFCOUNT_SHIFT;
+var setRefCount = (s, refCount) => s.rct = s.rct & NON_REFCOUNT_MASK | refCount << REFCOUNT_SHIFT;
+var isPromotedElement = (s) => !!(s.rct & PROMOTED_ELEMENT_FLAG);
+var markPromotedElement = (s) => s.rct |= PROMOTED_ELEMENT_FLAG;
+//#endregion
+//#region src/common/shorthands.ts
+var isArray = Array.isArray;
+//#endregion
+//#region src/state/stateInternals/notify.ts
+var flushTimeout;
+var flushPendingWork;
+var registerFlushPendingWork = (fn) => {
+	flushPendingWork = fn;
+};
+var queueFlush = () => flushTimeout ??= setTimeout(flush, 0);
+var fastFlush = (f, e) => {
+	flushTimeout = true;
+	try {
+		f(e);
+		transforms.Transform.flush();
+	} finally {
+		flushTimeout = void 0;
+	}
+	transforms.CallbackTransform.flush();
+	flushPendingWork();
+};
+var flush = (s) => {
+	clearTimeout(flushTimeout);
+	flushTimeout = void 0;
+	const ls = getLightState(s);
+	if (ls) refresh(ls);
+	else {
+		transforms.Transform.flush();
+		transforms.CallbackTransform.flush();
+		flushPendingWork();
+	}
+};
+var notify = (target) => {
+	const store = target.subs;
+	if (!store) return;
+	if (store instanceof Transform) store.queue(target);
+	else if (isArray(store)) for (let i = 0; i < store.length; i++) store[i].queue(target);
+	else for (const s of store) s.queue(target);
+};
+//#endregion
+//#region src/state/stateInternals/internalFunctions.ts
+var setFn = (target) => (value) => {
+	assertWritable(target);
+	return updateValue(target, value);
+};
+var commonInternalFunctions_symbol = /* @__PURE__ */ new Map([[Symbol.toPrimitive, (target) => {
+	connectTouchedState(target);
+	return target.v[Symbol.toPrimitive];
+}], [Symbol.iterator, (target) => target.v[Symbol.iterator]]]);
+var orFunction = (source, value) => {
+	const v = source.v;
+	return !v || v instanceof Array && v.length === 0 ? value : delightstate(source);
+};
+var notFunction = (source) => !source.v;
+var valueMethod = (name) => (target) => {
+	connectTouchedState(target);
+	return target.v?.[name]?.bind(target.v);
+};
+var commonInternalFunctions_string = /* @__PURE__ */ new Map([
+	["toString", valueMethod("toString")],
+	["valueOf", valueMethod("valueOf")],
+	["set", setFn],
+	["then", (target) => (onFulfilled) => {
+		const resolve = (v) => {
+			s.uns(target);
+			onFulfilled(v);
+		};
+		const s = new transforms.CallbackTransform(target, resolve);
+		const verBeforeSub = target.ver;
+		s.subTo(target);
+		if (target.ver !== verBeforeSub) resolve(target.v);
+	}],
+	["is", (target) => (cmp) => {
+		return transforms.IsTransform.for(target).new(cmp);
+	}],
+	["opt", (target) => (options, def) => new transforms.OptTransform(target, options, def).execute()],
+	["or", (target) => (value) => new transforms.FunctionTransform(target, orFunction, [target, value]).execute()],
+	["not", (target) => () => new transforms.FunctionTransform(target, notFunction, [target]).execute()],
+	["toJSON", (target) => {
+		const is = target.v;
+		return is?.toJSON instanceof Function ? is.toJSON.bind(is) : () => is;
+	}]
+]);
+var commonInternalFunctions = new Map([...commonInternalFunctions_symbol, ...commonInternalFunctions_string]);
+var pojoInternalFunctions = new Map([
+	...commonInternalFunctions_symbol,
+	["toJSON", commonInternalFunctions_string.get("toJSON")],
+	["toString", commonInternalFunctions_string.get("toString")],
+	["valueOf", commonInternalFunctions_string.get("valueOf")]
+]);
+var updateArray = (target, fn) => {
+	return (...args) => {
+		assertWritable(target);
+		target.ver = createVersion();
+		const r = target.v[fn](...args);
+		notify(target);
+		return r;
+	};
+};
+var arrayOnlyInternalFunctions = new Map([
+	"copyWithin",
+	"fill",
+	"pop",
+	"push",
+	"reverse",
+	"shift",
+	"sort",
+	"splice",
+	"unshift"
+].map((fn) => [fn, (t) => updateArray(t, fn)]));
+arrayOnlyInternalFunctions.set("map", (target) => (f) => new transforms.MapArrayTransform(target, f).execute());
+arrayOnlyInternalFunctions.set("length", (target) => {
+	connectTouchedState(target);
+	return target.v?.length;
+});
+var booleanPredicateArrayFunction = (fn) => (target) => (...args) => {
+	const predicate = args[0];
+	args[0] = (...predicateArgs) => peek(predicate(...predicateArgs));
+	return new transforms.ChainFunctionTransform(target, args, fn).execute();
+};
+for (const fn of [
+	"filter",
+	"some",
+	"every",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex"
+]) arrayOnlyInternalFunctions.set(fn, booleanPredicateArrayFunction(fn));
+var arraySearchFunction = (fn) => {
+	const hook = (t, ...hookArgs) => {
+		return Array.from(t.prx, peek)[fn](...peek(hookArgs).map(peek));
+	};
+	return (target) => (...args) => new transforms.FunctionTransform(target, hook, [target, ...args]).execute();
+};
+for (const fn of [
+	"includes",
+	"indexOf",
+	"lastIndexOf"
+]) arrayOnlyInternalFunctions.set(fn, arraySearchFunction(fn));
+var primitiveOnlyInternalFunctions = /* @__PURE__ */ new Map([]);
+primitiveOnlyInternalFunctions.set(Symbol.toPrimitive, (target) => () => {
+	connectTouchedState(target);
+	return target.v;
+});
+var arrayInternalFunctions = new Map([...commonInternalFunctions, ...arrayOnlyInternalFunctions]);
+var internalFunctions = [
+	new Map([...commonInternalFunctions, ...primitiveOnlyInternalFunctions]),
+	arrayInternalFunctions,
+	pojoInternalFunctions,
+	new Map([
+		...commonInternalFunctions_symbol,
+		["set", setFn],
+		["opt", commonInternalFunctions_string.get("opt")],
+		["or", commonInternalFunctions_string.get("or")]
+	]),
+	commonInternalFunctions_symbol,
+	new Map([
+		...commonInternalFunctions_symbol,
+		["set", setFn],
+		["opt", commonInternalFunctions_string.get("opt")],
+		["or", (target) => {
+			return typeof target.v?.or === "function" ? (...args) => new transforms.ChainFunctionTransform(target, args, "or").execute() : (value) => new transforms.FunctionTransform(target, orFunction, [target, value]).execute();
+		}]
+	])
+];
+//#endregion
+//#region src/DOM/util/util.ts
+var isNode = (v) => destate(v) != null;
+//#endregion
+//#region src/DOM/util/domNode.ts
+var isDOMNode = (v) => typeof v?.nodeType === "number";
+var isElementNode = (v) => v?.nodeType === 1;
+//#endregion
+//#region src/DOM/util/RenderError.ts
+var RenderError = class extends Error {
+	resetFn;
+	cause;
+	fallbackRendered = false;
+	halted = false;
+	constructor(cause, resetFn) {
+		super("Component render failed");
+		this.resetFn = resetFn;
+		this.cause = cause;
+	}
+	reset() {
+		this.resetFn();
+	}
+	stopPropagation() {
+		this.halted = true;
+	}
+	get propagationStopped() {
+		return this.halted;
+	}
+};
+var HYDRATE_MARKER_TEXT = "𝒮";
+var nonemptyShape = (shapes, index) => {
+	while (index < shapes.length && shapes[index] === 3) index++;
+	return shapes[index];
+};
+var computeUnsafeJunctions = (shapes) => {
+	const unsafe = [];
+	let left = shapes[0] === 3 ? void 0 : shapes[0];
+	for (let i = 1; i < shapes.length; i++) {
+		const current = shapes[i];
+		const right = nonemptyShape(shapes, i);
+		unsafe[i] = !(left === void 0 || right === void 0 || left === 0 || right === 0 || left === 1 && right === 1);
+		left = current === 3 ? left : current;
+	}
+	return unsafe;
+};
+//#endregion
+//#region src/DOM/util/nodeCount.ts
+var getNodeCount = (node) => node instanceof NodeController ? node.nc : 1;
+//#endregion
+//#region src/DOM/util/deferredNodes.ts
+var deferred = /* @__PURE__ */ new Set();
+var draining = /* @__PURE__ */ new Set();
+var deferNode = (n) => void deferred.add(n);
+var adoptDeferredNode = (n) => {
+	deferred.delete(n);
+	draining.delete(n);
+};
+var hasDeferredNodes = () => deferred.size > 0 || draining.size > 0;
+var isDeferred = (n) => deferred.has(n) || draining.has(n);
+var swapDeferredNodes = () => {
+	const t = deferred;
+	deferred = draining;
+	draining = t;
+};
+var clearDrainedDeferredNodes = () => draining.clear();
+var liveChildNodeAt = (parent, atIndex, startNode, startNodeIndex = 0) => {
+	if (!hasDeferredNodes()) return parent.childNodes[atIndex] ?? null;
+	let n = startNode === void 0 ? parent.firstChild : startNode;
+	let liveNodeIndex = startNode === void 0 ? 0 : startNodeIndex;
+	while (n) {
+		if (!isDeferred(n)) {
+			if (liveNodeIndex === atIndex) return n;
+			liveNodeIndex++;
+		}
+		n = n.nextSibling;
+	}
+	return null;
+};
+var liveChildNodeCount = (parent) => {
+	if (!hasDeferredNodes()) return parent.childNodes.length;
+	let count = 0;
+	for (let n = parent.firstChild; n; n = n.nextSibling) if (!isDeferred(n)) count++;
+	return count;
+};
+var holdsPOJO = (ls) => {
+	refresh(ls);
+	return isPOJO(ls.v);
+};
+var isNodeController = (c) => c instanceof NodeController;
+var isBlankText = (n) => n?.nodeType === Node.TEXT_NODE && !n.data.trim();
+var resolveCallableFallback = (fallback) => {
+	if (fallback instanceof Function) return fallback;
+	const ls = getLightState(fallback);
+	if (ls) {
+		refresh(ls);
+		if (typeof ls.v === "function") return ls.v;
+	}
+};
+var notifyAncestors = (start, renderError) => {
+	for (let c = start; c && !renderError.propagationStopped; c = c.par) if (c.catchParams) c.triggerCatch(renderError);
+};
+var NodeController = class NodeController {
+	ctx;
+	el;
+	par;
+	nc = 0;
+	cid;
+	args;
+	c;
+	subs;
+	def;
+	catchParams;
+	static StateController;
+	static setStateController(stateController) {
+		NodeController.StateController = stateController;
+	}
+	static ComponentController;
+	static setComponentController(componentController) {
+		NodeController.ComponentController = componentController;
+	}
+	static mightBeReplayedFromArgs(node) {
+		const p = node.par;
+		if (p instanceof NodeController.StateController) return NodeController.mightBeReplayedFromArgs(p);
+		return !!(p.flg & 20) && p.args !== void 0;
+	}
+	static stateMightReuseArgs(sc, child) {
+		if (isPromotedElement(sc.def)) return NodeController.stateMightReuseArgs(sc.par, child);
+		const tfm = sc.tfm;
+		return !((tfm?.flg ?? 0) & 2) || child.cid !== tfm.runId || NodeController.mightBeReplayedFromArgs(sc);
+	}
+	static invokeDetached(fallback, namedStates, level, ctx) {
+		/* v8 ignore next */
+		const noop = () => null;
+		const dummyParent = new NodeController.ComponentController(noop);
+		const isRender = ctx?.md === 2;
+		dummyParent.ctx = isRender ? ctx : {};
+		const detachedDOMContext = {
+			p: (isRender ? ctx.doc : document).createElement("div"),
+			n: null,
+			i: 0,
+			s: 0
+		};
+		fallback.build(dummyParent, detachedDOMContext, dummyParent, namedStates, void 0, level);
+		fallback.remove();
+		dummyParent.remove();
+	}
+	constructor(definition, args) {
+		this.def = definition;
+		if (args) this.args = args;
+		this.cid = currentRunId();
+	}
+	parseArgsRecursive(args, children, previousStateControllers) {
+		let properties;
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			if (typeof arg === "string" || typeof arg === "number") {
+				children.push(this.createTextChild(arg));
+				continue;
+			}
+			if (typeof arg === "object" && arg instanceof NodeController) {
+				children.push(arg);
+				continue;
+			}
+			const ls = getLightState(arg);
+			if (i === 0 && (ls ? holdsPOJO(ls) : isPOJO(arg))) properties = arg;
+			else if (ls) children.push(previousStateControllers?.lookup(ls) ?? new NodeController.StateController(ls));
+			else if (isDOMNode(arg)) children.push(arg);
+			else if (isArray(arg)) this.parseArgsRecursive(arg, children, previousStateControllers);
+			else if (arg instanceof Promise) children.push(new NodeController.StateController(new transforms.PromiseTransform(arg).execute()));
+			else if (arg instanceof Function) children.push(new NodeController.ComponentController(arg));
+			else if (isNode(arg)) children.push(this.createTextChild(arg));
+		}
+		return properties;
+	}
+	createTextChild(value) {
+		return this.ctx?.md === 1 ? 42 : this.ctx?.md === 2 ? this.ctx.doc.createTextNode(String(value)) : document.createTextNode(String(value));
+	}
+	parseArgs(args, previousStateControllers) {
+		this.c = [];
+		return args ? this.parseArgsRecursive(args, this.c, previousStateControllers) : void 0;
+	}
+	catch(v) {
+		this.catchParams = {
+			fbValue: v,
+			lvl: 1
+		};
+		return this;
+	}
+	build(parentController, DOMContext, stateContext, namedStates, hydrationContext, level = 1) {
+		const originalArgs = this.args;
+		const catchParams = this.catchParams;
+		if (catchParams) {
+			catchParams.lvl = level;
+			const fallback = catchParams.fbValue;
+			if (fallback instanceof NodeController.ComponentController || isState(fallback)) {
+				catchParams.stateContext = stateContext;
+				catchParams.namedStates = namedStates;
+			}
+		}
+		try {
+			this.par = parentController;
+			if (parentController) this.ctx = this.inheritContext(parentController.ctx);
+			const properties = this.parseArgs(this.args);
+			if (!(parentController instanceof NodeController.StateController ? NodeController.stateMightReuseArgs(parentController, this) : !!((parentController?.flg ?? 0) & 20) && parentController.args !== void 0)) this.args = void 0;
+			namedStates = this.buildNode(properties, namedStates, stateContext, hydrationContext, level) ?? namedStates;
+			this.createChildren(parentController, DOMContext, stateContext, namedStates, hydrationContext, level);
+		} catch (e) {
+			if (!catchParams) throw e;
+			const renderError = this.renderFallback(e, originalArgs, parentController, DOMContext, stateContext, namedStates, hydrationContext, level);
+			if (!renderError.propagationStopped) notifyAncestors(this.par, renderError);
+		}
+	}
+	triggerCatch(cause) {
+		const { stateContext, namedStates, lvl: level } = this.catchParams;
+		return this.renderFallback(cause, this.args, this.par, void 0, stateContext, namedStates, void 0, level);
+	}
+	renderFallback(cause, originalArgs, parentController, DOMContext, stateContext, namedStates, hydrationContext, level) {
+		const renderError = cause instanceof RenderError ? cause : new RenderError(cause, () => {
+			this.remove();
+			this.args = originalArgs;
+			const newDOMContext = this.getMountElement() ? void 0 : this.par.findNode(this);
+			const prevCount = this.nc;
+			this.build(parentController, newDOMContext, stateContext, namedStates, hydrationContext, level);
+			const newCount = this.nc;
+			this.nc = prevCount;
+			this.updateNodeCount(newCount);
+		});
+		const fallback = this.catchParams.fbValue;
+		const callable = resolveCallableFallback(fallback);
+		if (renderError.fallbackRendered) {
+			if (callable) callable(renderError);
+			else if (fallback instanceof NodeController.ComponentController) {
+				fallback.renderError = renderError;
+				NodeController.invokeDetached(fallback, this.catchParams.namedStates, level, this.ctx);
+			}
+			return renderError;
+		}
+		this.remove();
+		if (DOMContext === void 0 && !this.getMountElement()) DOMContext = this.par.findNode(this);
+		if (callable) this.parseArgs([callable(renderError)]);
+		else {
+			if (fallback instanceof NodeController.ComponentController) fallback.renderError = renderError;
+			this.parseArgs([fallback]);
+		}
+		this.createChildren(parentController, DOMContext, stateContext, namedStates, hydrationContext, level);
+		renderError.fallbackRendered = !!this.c?.length;
+		return renderError;
+	}
+	createChildren(parentController, DOMContext, stateContext, namedStates, hydrationContext, level = 1) {
+		const mountElement = this.getMountElement();
+		if (mountElement) {
+			DOMContext = {
+				p: mountElement,
+				n: null,
+				i: 0,
+				s: 0
+			};
+			if (this.ctx?.md === 1) hydrationContext = { nxt: mountElement.firstChild };
+		}
+		const childStateContext = this.flg & 1 ? stateContext ?? this : this;
+		this.nc = this.addChildren(DOMContext, hydrationContext, childStateContext, namedStates, level);
+		if (this.ctx?.md === 1 && mountElement) this.removeExcessNodes(hydrationContext);
+		if (!parentController && this.ctx?.md === 1) this.ctx.md = 0;
+	}
+	getMountElement() {
+		return this.el;
+	}
+	inheritContext(ctx) {
+		return ctx;
+	}
+	getNodes(p) {
+		if (isDOMNode(p)) return [p];
+		return p.el ? [p.el] : p.c.flatMap((c) => this.getNodes(c));
+	}
+	isSoleChild(child) {
+		return this.c?.length === 1 && this.c[0] === child;
+	}
+	isSpent() {
+		return this.par !== void 0 && this.args === void 0;
+	}
+	isMounted() {
+		return this.el !== void 0 || this.c !== void 0;
+	}
+	heldForm() {
+		if (this.flg & 8 || this.catchParams !== void 0) return this;
+		if (this.el) return this.c ? this : this.el;
+		const only = !this.subs && this.c?.length === 1 ? this.c[0] : void 0;
+		if (!only) return this;
+		return only instanceof NodeController ? only.heldForm() : only;
+	}
+	getFirstNode(node) {
+		if (isDOMNode(node)) return node;
+		if (node.el) return node.el;
+		for (const c of node.c) {
+			const nc = this.getFirstNode(c);
+			if (nc) return nc;
+		}
+	}
+	classifyChild(child) {
+		if (child === 42) return 1;
+		if (isDOMNode(child)) return isElementNode(child) ? 0 : 1;
+		if (child.flg & 2) {
+			const ls = child.def;
+			if (ls.v == null) return 3;
+			return ls.v instanceof NodeController && ls.v.flg & 4 ? 0 : 2;
+		}
+		return child.flg & 4 ? 0 : 2;
+	}
+	dropNode(hydrationContext) {
+		const skip = hydrationContext.nxt;
+		hydrationContext.nxt = skip.nextSibling;
+		skip.parentNode?.removeChild(skip);
+	}
+	removeExcessNodes(hydrationContext) {
+		while (hydrationContext.nxt?.nodeType === Node.COMMENT_NODE || isBlankText(hydrationContext.nxt)) this.dropNode(hydrationContext);
+	}
+	crossJunction(hydrationContext) {
+		while (isBlankText(hydrationContext.nxt)) this.dropNode(hydrationContext);
+		const marker = hydrationContext.nxt;
+		if (marker?.nodeType === Node.COMMENT_NODE && marker.textContent === "𝒮") this.dropNode(hydrationContext);
+	}
+	resolveChild(child, isStateController) {
+		if (child.flg & 8 || child.catchParams !== void 0) return child;
+		if (child.el) {
+			if (!child.subs) {
+				if (!child.c?.some(isNodeController)) {
+					child.c = void 0;
+					return child.el;
+				}
+				const only = child.c;
+				if (this.el && only.length === 1 && only[0] instanceof NodeController && only[0].el) {
+					only[0].par = this;
+					child.c = void 0;
+					return only[0];
+				}
+			}
+			return child;
+		}
+		if (isStateController) {
+			if (!child.subs && child.c?.length === 1) {
+				const only = child.c[0];
+				if (only instanceof NodeController) {
+					only.par = this;
+					return this.resolveChild(only, isStateController);
+				}
+				return only;
+			}
+			return child;
+		}
+		const spliced = child.c;
+		for (const c of spliced) if (c instanceof NodeController) c.par = this;
+		return spliced;
+	}
+	addChildren(DOMContext, hydrationContext, stateContext, namedStates, level = 1) {
+		const children = this.c;
+		if (!children.length) return this.getParallelNodeCount(0);
+		const isStateController = !!(this.flg & 2);
+		const unsafeJunctions = children.length > 1 && this.ctx?.md !== 0 ? computeUnsafeJunctions(children.map(this.classifyChild, this)) : void 0;
+		let nodeCount = 0;
+		let junctionIndex = 0;
+		for (let i = 0; i < children.length; i++) {
+			let child = children[i];
+			const controllerChild = child instanceof NodeController ? child : void 0;
+			if (unsafeJunctions?.[junctionIndex++]) {
+				if (this.ctx.md === 2) DOMContext.p.insertBefore(this.ctx.doc.createComment(HYDRATE_MARKER_TEXT), DOMContext.n);
+				else if (hydrationContext) this.crossJunction(hydrationContext);
+			}
+			if (controllerChild) {
+				const childStateContext = isStateController ? controllerChild : stateContext;
+				controllerChild.build(this, DOMContext, childStateContext, namedStates, hydrationContext, level + 1);
+			}
+			if (!controllerChild || controllerChild.el) {
+				if (this.ctx?.md === 1) {
+					if (child === 42) {
+						if (hydrationContext.nxt?.nodeType === Node.TEXT_NODE) {
+							child = hydrationContext.nxt;
+							hydrationContext.nxt = hydrationContext.nxt.nextSibling;
+						} else {
+							const emptyText = document.createTextNode("");
+							DOMContext.p.insertBefore(emptyText, hydrationContext.nxt ?? null);
+							child = emptyText;
+						}
+					}
+				} else DOMContext.p.insertBefore(controllerChild?.el ?? child, DOMContext.n);
+			}
+			if (controllerChild) {
+				const resolved = this.resolveChild(controllerChild, isStateController);
+				if (isArray(resolved)) {
+					children.splice(i, 1, ...resolved);
+					i += resolved.length - 1;
+					for (const r of resolved) nodeCount += getNodeCount(r);
+				} else {
+					nodeCount += getNodeCount(resolved);
+					children[i] = resolved;
+				}
+			} else {
+				nodeCount++;
+				children[i] = child;
+			}
+		}
+		return this.getParallelNodeCount(nodeCount);
+	}
+	getParallelNodeCount(childrenNodeCount) {
+		return this.el ? 1 : childrenNodeCount;
+	}
+	updateNodeCount(newCount) {
+		const diff = newCount - this.nc;
+		this.nc = newCount;
+		if (!diff) return;
+		for (let c = this.par; c && !c.getMountElement(); c = c.par) c.nc += diff;
+	}
+	enclosingMountElement() {
+		let c = this.par;
+		while (c && !c.getMountElement()) c = c.par;
+		return c?.getMountElement();
+	}
+	handleReactiveError(e) {
+		let current = e;
+		if (this.catchParams) {
+			current = this.triggerCatch(current);
+			if (current.propagationStopped) return;
+		}
+		for (let c = this.par; c; c = c.par) if (c.catchParams) {
+			current = c.triggerCatch(current);
+			if (current.propagationStopped) return;
+		}
+		if (!(current instanceof RenderError)) throw current;
+	}
+	addCleanup(fn) {
+		if (this.subs) this.subs.push(fn);
+		else this.subs = [fn];
+	}
+	addSub(transform, target = this) {
+		if (this.ctx?.md === 2) return;
+		transform.subTo(transform.srcLs);
+		if (target.subs) target.subs.push(transform);
+		else target.subs = [transform];
+	}
+	unsubscribeAll() {
+		if (!this.subs) return;
+		for (const sub of this.subs) typeof sub === "function" ? sub() : sub.uns(sub.srcLs);
+		this.subs = void 0;
+	}
+	remove(removeNode = true) {
+		this.unsubscribeAll();
+		this.removeChildren(removeNode && !this.el);
+		if (removeNode) {
+			if (this.el?.parentNode) this.el.remove();
+			this.el = void 0;
+		}
+	}
+	removeChildren(removeNodes = true) {
+		for (const child of this.c ?? []) if (child instanceof NodeController) child.remove(removeNodes);
+		else if (removeNodes && isDOMNode(child)) child.parentNode?.removeChild(child);
+		if (removeNodes) this.c = void 0;
+	}
+	findNode(referenceNode, nodeIndex = 0, startChildIndex = 0, startNode, startNodeIndex = 0) {
+		for (let childIndex = startChildIndex; childIndex < this.c.length; childIndex++) {
+			const child = this.c[childIndex];
+			if (child === referenceNode) {
+				const mountElement = this.getMountElement();
+				if (mountElement) {
+					nodeIndex += this.pnc;
+					return {
+						p: mountElement,
+						n: liveChildNodeAt(mountElement, nodeIndex, startNode, startNodeIndex),
+						i: nodeIndex,
+						s: childIndex
+					};
+				}
+				const result = this.par.findNode(this, nodeIndex, 0, startNode, startNodeIndex);
+				result.s = childIndex;
+				return result;
+			}
+			nodeIndex += getNodeCount(child);
+		}
+		/* v8 ignore next */
+		throw Error("Internal unexpected error.");
+	}
+};
+NodeController.prototype.flg = 0;
+NodeController.prototype.pnc = 0;
+//#endregion
+//#region src/common/util.ts
+var isPOJO = (v) => {
+	return typeof v === "object" && v !== null && Object.getPrototypeOf(v) === Object.prototype;
+};
+var classifyStateType = (v) => {
+	if (isArray(v)) return 1;
+	if (v) {
+		if (typeof v === "object") {
+			if (v instanceof NodeController) return 5;
+			return isPOJO(v) ? 2 : 4;
+		}
+		if (typeof v === "function") return 3;
+	}
+	return 0;
+};
+var camelToKebab = (s) => {
+	return s.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+};
+//#endregion
+//#region src/state/stateInternals/poison.ts
+var poisonCauses = /* @__PURE__ */ new WeakMap();
+var createPoisonedValue = (cause) => {
+	const marker = new Proxy(Object.create(null), {
+		getPrototypeOf: () => null,
+		get(_target, prop) {
+			if (prop === Symbol.toPrimitive) return () => {
+				throw cause;
+			};
+			throw cause;
+		},
+		has: () => {
+			throw cause;
+		}
+	});
+	poisonCauses.set(marker, cause);
+	return marker;
+};
+var isPoisoned = (v) => poisonCauses.has(v);
+var throwIfPoisoned = (v) => {
+	const cause = poisonCauses.get(v);
+	if (cause) throw cause;
+};
+//#endregion
+//#region src/state/stateInternals/stateUpdate.ts
+var latestVersion = 0;
+var createVersion = () => ++latestVersion;
+var peekVersion = () => latestVersion;
+var assertWritable = (ls) => {
+	if (!ls.tf) return;
+	throw TypeError("Chained state is read-only");
+};
+var promoteMemberToStateLightState = (owner, container, prop) => {
+	const ls = createStateLightState(container[prop]);
+	if (owner.tf) ls.tf ??= DERIVED_MEMBER;
+	container[prop] = ls.prx;
+	return ls;
+};
+var upsertProperty = (container, key, subValue, version, byOwner = false) => {
+	if (!(key in container)) {
+		container[key] = subValue;
+		return;
+	}
+	const old = container[key];
+	const lss = getLightState(old);
+	if (byOwner && (isState(subValue) || lss && lss.tf !== DERIVED_MEMBER)) {
+		if (getLightState(subValue) !== lss) container[key] = subValue;
+		return;
+	}
+	if (lss) {
+		if (!byOwner) assertWritable(lss);
+		return updateValue(lss, subValue, version, byOwner);
+	}
+	const dSubValue = destate(subValue);
+	if (isPOJO(old) && isPOJO(dSubValue)) upsertPojo(old, dSubValue, version, byOwner);
+	else container[key] = dSubValue;
+};
+var upsertPojo = (oldPojo, newValue, version, byOwner) => {
+	for (const [key, sv] of Object.entries(newValue)) upsertProperty(oldPojo, key, byOwner ? sv : destate(sv), version, byOwner);
+};
+var updateValue = (ls, v, version, byOwner = !!ls.tf) => {
+	version = version ?? ++latestVersion;
+	ls.tf?.dequeue();
+	const newValue = destate(v);
+	const oldValue = ls.v;
+	ls.ver = version;
+	ls.drt = version;
+	if (newValue === oldValue) return true;
+	if (isPOJO(oldValue) && isPOJO(newValue) && !isPoisoned(newValue)) upsertPojo(oldValue, newValue, version, byOwner);
+	else ls.v = newValue;
+	setStateType(ls, classifyStateType(newValue));
+	notify(ls);
+	return true;
+};
+var refresh = (ls) => ls.tf?.rfr();
+//#endregion
+//#region src/state/transforms/Transform.ts
+var touchedStatesStack = [];
+var touchedStatesCaptureActive;
+var transformQueue = /* @__PURE__ */ new Set();
+var rootQueue = [];
+var queueRoot = (transform) => {
+	rootQueue.push(transform);
+	queueFlush();
+};
+var setPool = [];
+var acquireSet = () => setPool.pop() ?? /* @__PURE__ */ new Set();
+var releaseSet = (s) => {
+	s.clear();
+	setPool.push(s);
+};
+var capturePool = [];
+var acquireCapture = (transform, sources) => {
+	const c = capturePool.pop();
+	if (!c) return {
+		tfm: transform,
+		touchedStates: sources
+	};
+	c.tfm = transform;
+	c.touchedStates = sources;
+	return c;
+};
+var releaseCapture = (c) => capturePool.push(c);
+var PENDING_VERSION = -1;
+var runSeq = 0;
+var nextRunId = () => ++runSeq;
+var currentRunId = () => touchedStatesCaptureActive?.tfm.runId ?? 0;
+var Transform = class Transform {
+	tgt;
+	srcLs;
+	hookFunction;
+	hookArgs;
+	constructor(source, hook) {
+		this.srcLs = source;
+		this.hookFunction = hook;
+	}
+	static isDirty(target) {
+		const epoch = peekVersion();
+		if (target.drt === epoch) return false;
+		if (target.drt === -epoch) return true;
+		const store = target.srcs;
+		let dirty = false;
+		if (store) {
+			if (store instanceof LightState) dirty = Transform.sourceIsDirty(store, target);
+			else for (const s of store) if (Transform.sourceIsDirty(s, target)) {
+				dirty = true;
+				break;
+			}
+		}
+		target.drt = dirty ? -epoch : epoch;
+		return dirty;
+	}
+	static sourceIsDirty(s, target) {
+		return s !== target && (s.ver > target.ver || Transform.isDirty(s));
+	}
+	static throwDelayed(e) {
+		queueMicrotask(() => {
+			throw e;
+		});
+	}
+	static flush() {
+		do {
+			for (const transform of transformQueue) try {
+				transform.execute();
+			} catch (e) {
+				Transform.throwDelayed(e);
+			}
+			transformQueue.clear();
+			while (rootQueue.length) rootQueue.pop().execute();
+		} while (transformQueue.size);
+	}
+	queue(_target) {
+		transformQueue.add(this);
+		queueFlush();
+	}
+	dequeue() {
+		transformQueue.delete(this);
+	}
+	subTo(state) {
+		const store = state.subs;
+		const rc = getRefCount(state);
+		setRefCount(state, rc + 1);
+		if (rc === 0) state.tf?.subscribeSources(state);
+		if (store) {
+			if (store instanceof Transform) state.subs = [store, this];
+			else if (isArray(store)) {
+				if (store.length < 8) store.push(this);
+				else {
+					const set = new Set(store);
+					set.add(this);
+					state.subs = set;
+				}
+			} else store.add(this);
+		} else state.subs = this;
+	}
+	subscribeSources(state) {
+		const store = state.srcs;
+		if (store) {
+			if (store instanceof LightState) this.subTo(store);
+			else for (const source of store) this.subTo(source);
+		}
+		refresh(state);
+	}
+	uns(state) {
+		this.dequeue();
+		const subscriptions = state.subs;
+		if (subscriptions === this) state.subs = void 0;
+		else if (isArray(subscriptions)) subscriptions.splice(subscriptions.indexOf(this), 1);
+		else subscriptions.delete(this);
+		const rc = getRefCount(state) - 1;
+		setRefCount(state, rc);
+		if (rc === 0) state.tf?.unsubscribeSources(state);
+	}
+	unsubscribeSources(state) {
+		const store = state.srcs;
+		if (!store) return;
+		if (store instanceof LightState) this.uns(store);
+		else for (const source of store) this.uns(source);
+	}
+	rfr() {
+		if (this.tgt && this.tgt.ver !== PENDING_VERSION && Transform.isDirty(this.tgt)) this.execute();
+	}
+	execute() {
+		if (this.tgt || !this.runId) this.runId = nextRunId();
+		touchedStatesCaptureActive && touchedStatesStack.push(touchedStatesCaptureActive);
+		const sources = acquireSet();
+		if (this.srcLs) sources.add(this.srcLs);
+		const capture = acquireCapture(this, sources);
+		touchedStatesCaptureActive = capture;
+		if (this.tgt) this.tgt.ver = PENDING_VERSION;
+		let value;
+		const hf = destate(this.hookFunction);
+		try {
+			value = this.hookArgs ? hf(...this.hookArgs) : hf();
+		} catch (e) {
+			value = createPoisonedValue(e);
+		} finally {
+			touchedStatesCaptureActive = touchedStatesStack.pop();
+			releaseCapture(capture);
+		}
+		if (!sources.size && !this.tgt && !isPoisoned(value)) {
+			releaseSet(sources);
+			return value;
+		}
+		const ls = getLightState(value);
+		if (ls && !sources.has(ls)) {
+			if (ls.ver === PENDING_VERSION) value = createPoisonedValue(new CircularDependencyError());
+			else if (!this.tgt && this instanceof transforms.MapValueTransform && this.hasOnlyPassthroughSource(sources)) {
+				refresh(ls);
+				releaseSet(sources);
+				return value;
+			} else {
+				refresh(ls);
+				sources.add(ls);
+			}
+		}
+		const result = this.updateTarget(value, sources);
+		releaseSet(sources);
+		return result;
+	}
+	hasOnlyPassthroughSource(sources) {
+		return !!(sources.size === 1 && this.hookArgs && sources.has(getLightState(this.hookArgs[0])));
+	}
+	updateTarget(newValue, newSources) {
+		if (this.tgt) updateValue(this.tgt, newValue, peekVersion());
+		else {
+			this.tgt = new LightState(destate(newValue));
+			this.tgt.tf = this;
+		}
+		const store = this.tgt.srcs;
+		if (!(newSources.size === 1 && store instanceof LightState && newSources.has(store))) {
+			if (getRefCount(this.tgt)) {
+				for (const source of newSources) if (!(isArray(store) ? store.includes(source) : store instanceof Set ? store.has(source) : store === source)) this.subTo(source);
+				if (store instanceof LightState) {
+					if (!newSources.has(store)) this.uns(store);
+				} else for (const source of store) if (!newSources.has(source)) this.uns(source);
+			}
+			const target = this.tgt;
+			if (newSources.size === 0) target.srcs = void 0;
+			else if (newSources.size === 1) [target.srcs] = newSources;
+			else if (newSources.size <= 8) target.srcs = [...newSources];
+			else target.srcs = new Set(newSources);
+		}
+		return this.flg & 1 ? this.tgt : state(this.tgt);
+	}
+	static connect(target) {
+		if (touchedStatesCaptureActive) {
+			if (target.ver === PENDING_VERSION) throw new CircularDependencyError();
+			touchedStatesCaptureActive.touchedStates.add(target);
+			if (touchedStatesCaptureActive.tfm.tgt) {
+				const c = touchedStatesCaptureActive;
+				touchedStatesCaptureActive = void 0;
+				refresh(target);
+				touchedStatesCaptureActive = c;
+			}
+		}
+	}
+};
+var connectTouchedState = (target) => Transform.connect(target);
+Transform.prototype.flg = 0;
+Transform.prototype.runId = 0;
+var DERIVED_MEMBER = new Transform();
+transforms.Transform = Transform;
+//#endregion
+//#region src/state/state.ts
+var CircularDependencyError = class extends Error {
+	constructor() {
+		super("circular dependency");
+	}
+};
+var stateRegistry = /* @__PURE__ */ new WeakMap();
+var isState = (value) => {
+	return typeof value === "function" && stateRegistry.has(value);
+};
+var isLightState = (value) => {
+	return typeof value !== "function" && value instanceof LightState;
+};
+var isAnyState = (value) => {
+	return typeof value === "function" ? stateRegistry.has(value) : value instanceof LightState;
+};
+var subscribeWith = (state, createSubscription) => {
+	if (activeSubscriptions === null) throw Error("Cannot call subscribe after await in async function");
+	const [target, transform] = createSubscription(stateRegistry.get(state));
+	transform.subTo(target);
+	let subscribed = target;
+	const unsubscribe = () => {
+		subscribed && transform.uns(subscribed);
+		subscribed = void 0;
+	};
+	activeSubscriptions?.add(unsubscribe);
+	return unsubscribe;
+};
+var subscribe = (state, callback = () => 0, options) => subscribeWith(state, (ls) => [options?.["deep"] ? transforms.SubscribeTransform.for(ls) : ls, new transforms.CallbackTransform(ls, callback)]);
+function findState(name, def) {
+	if (!activeExistingNamedStates || !(name in activeExistingNamedStates)) {
+		if (arguments.length > 1) return def;
+		throw Error("State not found");
+	}
+	return activeExistingNamedStates[name];
+}
+var lightState = (value) => new LightState(value);
+/* v8 ignore next */
+var staticTarget = () => {};
+var state = (value, name) => {
+	if (name && !activeNewNamedStates) throw Error("Cannot define named state after await in async function");
+	const newState = createStateLightState(value).prx;
+	if (name) activeNewNamedStates.set(name, newState);
+	return newState;
+};
+var createStateLightState = (value) => {
+	const ls = isLightState(value) ? value : value instanceof Promise ? new transforms.PromiseTransform(value).execute() : new LightState(getLightState(value)?.v ?? value);
+	if (ls.prx) return ls;
+	const newState = new Proxy(staticTarget, ls);
+	ls.prx = newState;
+	stateRegistry.set(newState, ls);
+	return ls;
+};
+var peek = (value) => {
+	const ls = getLightState(value);
+	if (!ls) return value;
+	connectTouchedState(ls);
+	return ls.v;
+};
+var getLightState = (value) => {
+	return typeof value === "function" ? stateRegistry.get(value) : value instanceof LightState ? value : void 0;
+};
+var delightstate = (value) => value.v;
+var destate = (value) => {
+	const ls = getLightState(value);
+	return ls ? ls.v : value;
+};
+var subscriptionsCache = /* @__PURE__ */ new Set();
+var namedStatesCache = /* @__PURE__ */ new Map();
+var activeSubscriptions;
+var activeExistingNamedStates;
+var activeNewNamedStates;
+var isInComponent = () => activeSubscriptions != null;
+var startCapturingStateCalls = (namedStates) => {
+	activeExistingNamedStates = namedStates;
+	activeSubscriptions = subscriptionsCache;
+	activeNewNamedStates = namedStatesCache;
+};
+var stopCapturingStateCalls = () => {
+	let namedStates;
+	if (activeExistingNamedStates) {
+		namedStates = activeNewNamedStates.size ? Object.assign({}, activeExistingNamedStates, Object.fromEntries(activeNewNamedStates)) : activeExistingNamedStates;
+		namedStatesCache.clear();
+	} else if (activeNewNamedStates.size) namedStates = Object.fromEntries(activeNewNamedStates);
+	namedStatesCache.clear();
+	const subscriptions = activeSubscriptions.size ? [...activeSubscriptions.values()] : void 0;
+	subscriptionsCache.clear();
+	activeSubscriptions = null;
+	activeExistingNamedStates = void 0;
+	activeNewNamedStates = void 0;
+	return {
+		namedStates,
+		subscriptions
+	};
+};
+//#endregion
+//#region src/state/stateInternals/LightState.ts
+var LightState = class {
+	v;
+	rct;
+	ver;
+	subs;
+	srcs;
+	tf;
+	prx;
+	drt;
+	constructor(value) {
+		this.v = value;
+		this.rct = classifyStateType(value);
+		this.subs = void 0;
+		this.srcs = void 0;
+		this.tf = void 0;
+		this.prx = void 0;
+		this.ver = createVersion();
+		this.drt = 0;
+	}
+	get(_target, prop, receiver) {
+		const stateType = getStateType(this);
+		const fn = internalFunctions[stateType].get(prop);
+		if (fn) return fn(this, receiver);
+		const s = this.v;
+		if (s == null) return void 0;
+		if (typeof prop === "symbol") return s[prop];
+		const sp = s[prop];
+		const spLs = getLightState(sp);
+		if (stateType !== 2 && typeof (spLs ? spLs.v : sp) === "function") return (...args) => new transforms.ChainFunctionTransform(this, args, prop).execute();
+		connectTouchedState(this);
+		if (spLs?.prx || stateType !== 1 && stateType !== 2) return sp;
+		if (!(prop in s)) return;
+		return promoteMemberToStateLightState(this, s, prop).prx;
+	}
+	set(_target, prop, value) {
+		assertWritable(this);
+		const is = this.v;
+		const ls = getLightState(is[prop]);
+		if (ls) {
+			assertWritable(ls);
+			return updateValue(ls, value);
+		}
+		const version = createVersion();
+		upsertProperty(is, prop, value, version);
+		this.ver = version;
+		notify(this);
+		return true;
+	}
+	getPrototypeOf() {
+		const is = this.v;
+		return is == null ? null : Object.getPrototypeOf(is);
+	}
+	apply(_target, thisArg, argumentsList) {
+		return new transforms.FunctionTransform(this, this.prx, argumentsList).execute();
+	}
+	getOwnPropertyDescriptor(_target, key) {
+		const is = this.v;
+		return is && typeof is === "object" || typeof is === "function" ? Reflect.getOwnPropertyDescriptor(is, key) : void 0;
+	}
+	deleteProperty(_target, prop) {
+		assertWritable(this);
+		if (getStateType(this) !== 2) throw TypeError("Cannot delete state properties");
+		const is = this.v;
+		if (!(prop in is)) return true;
+		delete is[prop];
+		this.ver = createVersion();
+		notify(this);
+		return true;
+	}
+	ownKeys() {
+		if (this.v == null) return [];
+		return Reflect.ownKeys(this.v);
+	}
+};
+var reflect = Reflect;
+var proto = LightState.prototype;
+for (const key of Object.getOwnPropertyNames(Reflect)) proto[key] ??= function(_target, ...args) {
+	return reflect[key](this.v, ...args);
+};
+//#endregion
+//#region src/state/transforms/ChainFunctionTransform.ts
+var ChainFunctionTransform = class extends Transform {
+	hookName;
+	constructor(source, args, name) {
+		super(source);
+		this.hookArgs = args;
+		this.hookName = name;
+	}
+	execute() {
+		const is = this.srcLs.v;
+		const boundThis = isArray(is) ? this.srcLs.prx : is;
+		this.hookFunction = is[this.hookName].bind(boundThis);
+		return super.execute();
+	}
+};
+ChainFunctionTransform.prototype.flg = 2;
+transforms.ChainFunctionTransform = ChainFunctionTransform;
+//#endregion
+//#region src/state/transforms/MapArrayTransform.ts
+var MAX_LINEAR_LOOKUPS = 2;
+var MapArrayTransform = class extends Transform {
+	previousElements;
+	previousIndexStates;
+	execute() {
+		this.runId = nextRunId();
+		refresh(this.srcLs);
+		const is = this.srcLs.v;
+		if (!isArray(is)) throw TypeError("Cannot apply map function to non-array value");
+		const sourceProxy = this.srcLs.prx;
+		const previousResults = this.tgt ? this.tgt.v : [];
+		const previousElements = this.previousElements ?? [];
+		const previousIndexStates = this.previousIndexStates;
+		const srcFunction = getLightState(this.hookFunction);
+		const passesIndex = this.hookFunction.length > 1;
+		const indexStates = passesIndex ? [] : void 0;
+		const sameLength = previousElements.length === is.length;
+		const r = sameLength ? previousResults.slice() : [];
+		let previousPositionsByElement;
+		let lookupCount = 0;
+		let expectedPreviousPosition = 0;
+		for (let i = 0; i < is.length; i++) {
+			const element = is[i];
+			let previousPosition;
+			if (typeof element !== "function") previousPosition = -1;
+			else if (element === previousElements[expectedPreviousPosition]) previousPosition = expectedPreviousPosition++;
+			else if (element === previousElements[expectedPreviousPosition + 1]) {
+				previousPosition = expectedPreviousPosition + 1;
+				expectedPreviousPosition += 2;
+			} else {
+				previousPosition = lookupCount++ < MAX_LINEAR_LOOKUPS ? previousElements.indexOf(element) : (previousPositionsByElement ??= new Map(previousElements.map((e, position) => [e, position]))).get(element) ?? -1;
+				if (previousPosition >= expectedPreviousPosition && is[i + 1] === previousElements[previousPosition + 1]) expectedPreviousPosition = previousPosition + 1;
+			}
+			if (previousPosition < 0) {
+				r[i] = this.mapElement(i, element, srcFunction, passesIndex ? sourceProxy : void 0, indexStates);
+				continue;
+			}
+			if (!sameLength || previousPosition !== i) r[i] = previousResults[previousPosition];
+			if (indexStates) {
+				const indexState = previousIndexStates[previousPosition];
+				if (previousPosition !== i) indexState.set(i);
+				indexStates[i] = indexState;
+			}
+		}
+		this.previousElements = is.slice();
+		this.previousIndexStates = indexStates;
+		if (this.tgt) updateValue(this.tgt, r);
+		else this.tgt = getLightState(state(r));
+		this.tgt.srcs = this.srcLs;
+		this.tgt.tf = this;
+		return this.tgt.prx;
+	}
+	mapElement(i, element, srcFunction, sourceProxy, indexStates) {
+		const is = this.srcLs.v;
+		const v = typeof element === "function" ? element : promoteMemberToStateLightState(this.srcLs, is, i).prx;
+		let args;
+		if (indexStates) {
+			const indexState = state(i);
+			indexStates[i] = indexState;
+			args = [
+				v,
+				indexState,
+				sourceProxy
+			];
+		} else args = [v];
+		const row = new transforms.MapValueTransform(srcFunction, this.hookFunction, args);
+		row.runId = this.runId;
+		return row.execute();
+	}
+};
+MapArrayTransform.prototype.flg = 2;
+transforms.MapArrayTransform = MapArrayTransform;
+//#endregion
+//#region src/state/transforms/FunctionTransform.ts
+var FunctionTransform = class extends Transform {
+	constructor(source, hookFunction, args) {
+		super(source, hookFunction);
+		this.hookArgs = args;
+	}
+};
+transforms.FunctionTransform = FunctionTransform;
+//#endregion
+//#region src/state/transforms/LightStateFunctionTransform.ts
+var LightStateFunctionTransform = class extends FunctionTransform {};
+LightStateFunctionTransform.prototype.flg = 3;
+transforms.LightStateFunctionTransform = LightStateFunctionTransform;
+//#endregion
+//#region src/state/transforms/MapValueTransform.ts
+var MapValueTransform = class extends LightStateFunctionTransform {};
+transforms.MapValueTransform = MapValueTransform;
+//#endregion
+//#region src/state/transforms/CallbackTransform.ts
+var callbackQueue = /* @__PURE__ */ new Set();
+var queuedInPriorityOrder = true;
+var lastQueuedPriority = -Infinity;
+var CallbackTransform = class extends Transform {
+	prio;
+	payload;
+	constructor(source, callback, data, priority) {
+		super(source, callback);
+		this.payload = data;
+		this.prio = priority ?? 2 ** 29;
+	}
+	static flush() {
+		const queue = callbackQueue.size > 1 ? Array.from(callbackQueue) : callbackQueue;
+		if (!queuedInPriorityOrder && queue !== callbackQueue) queue.sort((a, b) => a.prio - b.prio);
+		queuedInPriorityOrder = true;
+		lastQueuedPriority = -Infinity;
+		for (const transform of queue) if (callbackQueue.delete(transform)) try {
+			transform.execute();
+		} catch (e) {
+			Transform.throwDelayed(e);
+		}
+	}
+	queue() {
+		const sizeBefore = callbackQueue.size;
+		callbackQueue.add(this);
+		if (callbackQueue.size !== sizeBefore) {
+			if (this.prio < lastQueuedPriority) queuedInPriorityOrder = false;
+			else lastQueuedPriority = this.prio;
+		}
+		queueFlush();
+	}
+	dequeue() {
+		callbackQueue.delete(this);
+	}
+	execute() {
+		return this.hookFunction(destate(this.srcLs), this.payload);
+	}
+};
+transforms.CallbackTransform = CallbackTransform;
+//#endregion
+//#region src/state/transforms/OptTransform.ts
+var OptTransform = class extends Transform {
+	opt;
+	def;
+	constructor(selector, options, def) {
+		super(selector);
+		this.opt = options;
+		this.def = def;
+	}
+	execute() {
+		refresh(this.srcLs);
+		const dselector = this.srcLs.v;
+		let value;
+		if (typeof dselector === "number" && isArray(destate(this.opt)) || isPOJO(destate(this.opt))) value = dselector in this.opt ? this.opt[dselector] : this.def;
+		else if (isArray(dselector) ? dselector.length > 0 : dselector) value = this.opt;
+		else value = this.def;
+		const sources = acquireSet();
+		sources.add(this.srcLs);
+		const ls = getLightState(value);
+		if (ls) {
+			sources.add(ls);
+			refresh(ls);
+		}
+		const result = this.updateTarget(value, sources);
+		releaseSet(sources);
+		return result;
+	}
+};
+transforms.OptTransform = OptTransform;
+//#endregion
+//#region src/state/transforms/IsTransform.ts
+var IsTargetTransform = class extends Transform {
+	owner;
+	targetLs;
+	keyVal;
+	cmpLs;
+	constructor(owner, targetLs, keyVal, cmpLs) {
+		super();
+		this.owner = owner;
+		this.targetLs = targetLs;
+		this.keyVal = keyVal;
+		this.cmpLs = cmpLs;
+	}
+	subTo(ls) {
+		this.owner.subTo(ls);
+	}
+	uns(ls) {
+		this.owner.uns(ls);
+	}
+	rfr() {
+		this.owner.refreshTarget(this.targetLs);
+	}
+};
+var targetTransform = (target) => target.tf;
+var includes = (targets, target) => targets === target || isArray(targets) && targets.includes(target);
+transforms.IsTransform = class IsTransform extends Transform {
+	compared = /* @__PURE__ */ new Map();
+	sourceToKey = /* @__PURE__ */ new Map();
+	oldReference;
+	sourceRefCount = 0;
+	queued = [];
+	static instances = /* @__PURE__ */ new WeakMap();
+	static for(reference) {
+		return IsTransform.instances.get(reference) ?? new IsTransform(reference);
+	}
+	constructor(reference) {
+		super(reference);
+		this.oldReference = reference.v;
+		IsTransform.instances.set(reference, this);
+	}
+	refreshTarget(target) {
+		refresh(this.srcLs);
+		const tf = targetTransform(target);
+		if (tf.cmpLs) refresh(tf.cmpLs);
+		if (target.ver >= this.srcLs.ver && (!tf.cmpLs || target.ver >= tf.cmpLs.ver)) return;
+		if (tf.cmpLs && !Object.is(tf.keyVal, tf.cmpLs.v)) this.rekeyCompared(target, tf.cmpLs.v);
+		updateValue(target, Object.is(tf.keyVal, this.srcLs.v));
+	}
+	rekeyCompared(target, key) {
+		const tf = targetTransform(target);
+		const targets = this.compared.get(tf.keyVal);
+		const registered = includes(targets, target);
+		if (isArray(targets) && registered) this.removeCompared(tf.keyVal, targets, targets.indexOf(target));
+		else if (registered) this.compared.delete(tf.keyVal);
+		if (registered) this.addCompared(key, target, tf.cmpLs);
+		else {
+			tf.keyVal = key;
+			this.sourceToKey.set(tf.cmpLs, key);
+		}
+	}
+	execute() {
+		const reference = this.srcLs.v;
+		while (this.queued.length) this.updateComparedState(this.queued.pop(), reference);
+		if (reference === this.oldReference) return;
+		for (const ref of [this.oldReference, reference]) {
+			const targets = this.compared.get(ref);
+			if (!targets) continue;
+			const value = Object.is(ref, reference);
+			if (isArray(targets)) for (const result of targets) updateValue(result, value, this.srcLs.ver);
+			else updateValue(targets, value, this.srcLs.ver);
+		}
+		this.oldReference = reference;
+	}
+	updateComparedState(ls, reference) {
+		const target = this.popComparedState(ls);
+		this.addCompared(ls.v, target, ls);
+		updateValue(target, Object.is(ls.v, reference), ls.ver);
+	}
+	popComparedState(ls) {
+		const old = this.sourceToKey.get(ls);
+		const targets = this.compared.get(old);
+		if (!isArray(targets)) {
+			this.compared.delete(old);
+			return targets;
+		}
+		const i = targets.findIndex((rls) => targetTransform(rls).cmpLs === ls);
+		const target = targets[i];
+		this.removeCompared(old, targets, i);
+		return target;
+	}
+	removeCompared(key, targets, i) {
+		targets.splice(i, 1);
+		if (targets.length === 1) this.compared.set(key, targets[0]);
+	}
+	queue(target) {
+		if (target && target !== this.srcLs) this.queued.push(target);
+		super.queue();
+	}
+	isOwnTarget(ls) {
+		return ls.tf instanceof IsTargetTransform && ls.tf.owner === this;
+	}
+	subTo(ls) {
+		if (this.sourceToKey.has(ls)) return super.subTo(ls);
+		const key = targetTransform(ls).keyVal;
+		if (!includes(this.compared.get(key), ls)) {
+			this.addCompared(key, ls);
+			updateValue(ls, Object.is(key, this.srcLs.v));
+		}
+		if (++this.sourceRefCount === 1) super.subTo(this.srcLs);
+	}
+	uns(state) {
+		if (!this.isOwnTarget(state)) return super.uns(state);
+		const key = targetTransform(state).keyVal;
+		const targets = this.compared.get(key);
+		if (isArray(targets)) this.removeCompared(key, targets, targets.indexOf(state));
+		else this.compared.delete(key);
+		if (--this.sourceRefCount === 0) super.uns(this.srcLs);
+	}
+	addCompared(comparedValue, target, comparedState) {
+		if (comparedState) this.sourceToKey.set(comparedState, comparedValue);
+		targetTransform(target).keyVal = comparedValue;
+		const targets = this.compared.get(comparedValue);
+		if (!targets) this.compared.set(comparedValue, target);
+		else if (isArray(targets)) targets.push(target);
+		else this.compared.set(comparedValue, [targets, target]);
+	}
+	new(compared) {
+		const reference = this.srcLs.v;
+		const ls = getLightState(compared);
+		const comparedValue = ls?.v ?? compared;
+		const target = lightState(Object.is(comparedValue, reference));
+		target.tf = new IsTargetTransform(this, target, comparedValue, ls);
+		target.srcs = ls ? [target, ls] : target;
+		this.addCompared(comparedValue, target, ls);
+		return state(target);
+	}
+};
+//#endregion
+//#region src/state/transforms/ComputeTransform.ts
+var ComputeTransform = class extends Transform {
+	constructor(computeFunction) {
+		super();
+		this.hookFunction = computeFunction;
+	}
+};
+ComputeTransform.prototype.flg = 2;
+transforms.ComputeTransform = ComputeTransform;
+//#endregion
+//#region src/state/transforms/PromiseTransform.ts
+var PromiseTransform = class extends Transform {
+	constructor(promise) {
+		super();
+		this.tgt = new LightState(void 0);
+		promise.then((v) => {
+			updateValue(this.tgt, v);
+		}, (cause) => {
+			updateValue(this.tgt, createPoisonedValue(cause));
+		});
+	}
+	execute() {
+		return this.tgt;
+	}
+};
+transforms.PromiseTransform = PromiseTransform;
+//#endregion
+//#region src/state/transforms/SubscribeTransform.ts
+var getSubState = (owner, prop) => {
+	const container = owner.v;
+	const ls = getLightState(container[prop]);
+	if (ls) return ls;
+	if (!(prop in container)) return void 0;
+	return promoteMemberToStateLightState(owner, container, prop);
+};
+var SubscribeTransform = class SubscribeTransform extends Transform {
+	static instances = /* @__PURE__ */ new WeakMap();
+	pendingSelf = false;
+	seq = 0;
+	static for(ls) {
+		return (SubscribeTransform.instances.get(ls) ?? new SubscribeTransform(ls)).tgt;
+	}
+	constructor(source) {
+		super(source);
+		SubscribeTransform.instances.set(source, this);
+		this.execute();
+	}
+	queue(target) {
+		if (target === this.srcLs) this.pendingSelf = true;
+		super.queue(target);
+	}
+	execute() {
+		const sources = acquireSet();
+		if (this.pendingSelf || !this.tgt) {
+			this.pendingSelf = false;
+			sources.add(this.srcLs);
+			const stateType = getStateType(this.srcLs);
+			if (stateType === 1 || stateType === 2) {
+				const parent = this.srcLs.v;
+				for (const key of Object.keys(parent)) {
+					const childLs = getSubState(this.srcLs, key);
+					if (!childLs) continue;
+					const childType = getStateType(childLs);
+					const nestedLs = (childType === 1 || childType === 2) && SubscribeTransform.for(childLs);
+					sources.add(nestedLs || childLs);
+				}
+			}
+		} else {
+			const store = this.tgt.srcs;
+			for (const s of store) sources.add(s);
+		}
+		this.updateTarget(this.seq++, sources);
+		releaseSet(sources);
+	}
+};
+SubscribeTransform.prototype.flg = 1;
+transforms.SubscribeTransform = SubscribeTransform;
+//#endregion
+//#region src/state/transforms/DOMRootTransform.ts
+var DOMRootTransform = class extends Transform {
+	rootCtl;
+	constructor(root) {
+		super();
+		this.rootCtl = root;
+	}
+	queue() {
+		queueRoot(this);
+	}
+	execute() {
+		this.rootCtl.createRoot();
+	}
+};
+transforms.DOMRootTransform = DOMRootTransform;
+//#endregion
+//#region src/common/computeMutation.ts
+var afterIndex = /* @__PURE__ */ new Map();
+var beforeSet = /* @__PURE__ */ new Set();
+var flushRun$1 = (out, lo, hi) => {
+	if (lo < 0) return;
+	out.push(lo);
+	if (hi > lo) out.push(-1 - hi);
+};
+var computeMutation = (before, after, known) => {
+	let prefixL = 0;
+	if (known) prefixL = known.pre;
+	else while (prefixL < after.length && before[prefixL] === after[prefixL]) prefixL++;
+	if (prefixL === after.length && prefixL === before.length) return {};
+	let suffixL = 0;
+	if (known?.suf !== void 0) suffixL = known.suf;
+	else while (before[before.length - 1 - suffixL] === after[after.length - 1 - suffixL]) suffixL++;
+	const commonLength = prefixL + suffixL;
+	if (commonLength === after.length) return before.length - commonLength === 1 ? {
+		removed: [prefixL],
+		pre: prefixL,
+		suf: suffixL
+	} : {
+		removed: [prefixL, -1 - (before.length - suffixL - 1)],
+		pre: prefixL,
+		suf: suffixL
+	};
+	if (commonLength === before.length) return after.length - commonLength === 1 ? {
+		added: [prefixL],
+		pre: prefixL,
+		suf: suffixL
+	} : {
+		added: [prefixL, -1 - (after.length - suffixL - 1)],
+		pre: prefixL,
+		suf: suffixL
+	};
+	return before.length === after.length && mutateSingleMoveOrSwap(before, after, prefixL, suffixL, known?.changedCount) || diffChangedMiddle(before, after, prefixL, suffixL);
+};
+var mutateSingleMoveOrSwap = (before, after, prefixL, suffixL, changedCount) => {
+	const first = prefixL;
+	const last = after.length - suffixL - 1;
+	const movedForward = after[last] === before[first];
+	const movedBack = after[first] === before[last];
+	if (!movedForward && !movedBack) return void 0;
+	const swapped = movedForward && movedBack && last > first + 1;
+	if (changedCount === 2) {
+		if (!movedForward || !movedBack) return void 0;
+	} else {
+		const offset = Number(movedBack) - Number(movedForward);
+		for (let i = first + Number(movedForward); i <= last - Number(movedBack); i++) if (before[i] !== after[i + offset]) return void 0;
+	}
+	let common;
+	let move;
+	if (swapped) {
+		common = [last];
+		flushRun$1(common, first + 1, last - 1);
+		common.push(first);
+		move = [first, last];
+	} else if (movedForward) {
+		common = [last];
+		flushRun$1(common, first, last - 1);
+		move = [last];
+	} else {
+		common = [
+			first + 1,
+			-1 - last,
+			first
+		];
+		move = [first];
+	}
+	return {
+		removed: [],
+		moved: move,
+		added: [],
+		kept: common,
+		pre: prefixL,
+		suf: suffixL
+	};
+};
+var diffChangedMiddle = (before, after, prefixL, suffixL) => {
+	const remove = [];
+	const add = [];
+	const move = [];
+	const common = [];
+	afterIndex.clear();
+	beforeSet.clear();
+	for (let i = prefixL; i < after.length - suffixL; i++) afterIndex.set(after[i], i);
+	let runLo = -1;
+	let runHi = -1;
+	for (let beforeI = prefixL; beforeI <= before.length - 1 - suffixL; beforeI++) {
+		const v = before[beforeI];
+		const afterI = afterIndex.get(v);
+		if (afterI !== void 0) {
+			common.push(afterI);
+			beforeSet.add(v);
+		} else if (runLo >= 0 && beforeI === runHi + 1) runHi = beforeI;
+		else {
+			flushRun$1(remove, runLo, runHi);
+			runLo = runHi = beforeI;
+		}
+	}
+	flushRun$1(remove, runLo, runHi);
+	const stableRuns = extractLongestIncreasingSubsequence(common);
+	let sr = stableRuns.length - 1;
+	let stable = Infinity;
+	let stableHi = Infinity;
+	if (stableRuns.length) {
+		stable = stableRuns[sr--];
+		stableHi = stableRuns[sr] < 0 ? -1 - stableRuns[sr--] : stable;
+	}
+	let keptRank = prefixL;
+	let moveLo = -1;
+	let moveHi = -1;
+	let addLo = -1;
+	let addHi = -1;
+	for (let i = prefixL; i < after.length - suffixL; i++) if (beforeSet.has(after[i])) {
+		if (i === stable) {
+			if (stable < stableHi) stable++;
+			else if (sr >= 0) {
+				stable = stableRuns[sr--];
+				stableHi = stableRuns[sr] < 0 ? -1 - stableRuns[sr--] : stable;
+			} else stable = Infinity;
+		} else if (moveLo >= 0 && keptRank === moveHi + 1) moveHi = keptRank;
+		else {
+			flushRun$1(move, moveLo, moveHi);
+			moveLo = moveHi = keptRank;
+		}
+		keptRank++;
+	} else if (addLo >= 0 && i === addHi + 1) addHi = i;
+	else {
+		flushRun$1(add, addLo, addHi);
+		addLo = addHi = i;
+	}
+	flushRun$1(move, moveLo, moveHi);
+	flushRun$1(add, addLo, addHi);
+	return {
+		removed: remove,
+		moved: move,
+		added: add,
+		kept: common,
+		pre: prefixL,
+		suf: suffixL
+	};
+};
+var extractLongestIncreasingSubsequence = (X) => {
+	const N = X.length;
+	if (N < 2) return [...X];
+	const predecessor = new Int32Array(N);
+	const lowestEnd = new Int32Array(N + 1);
+	let longestLIS = 1;
+	let lo, hi, mid;
+	for (let i = 1; i < N; i++) {
+		lo = 1;
+		hi = longestLIS + 1;
+		while (lo < hi) {
+			mid = lo + hi >> 1;
+			if (X[lowestEnd[mid]] >= X[i]) hi = mid;
+			else lo = mid + 1;
+		}
+		predecessor[i] = lowestEnd[lo - 1];
+		lowestEnd[lo] = i;
+		if (lo > longestLIS) longestLIS = lo;
+	}
+	const runs = [];
+	let k = lowestEnd[longestLIS];
+	let runHi = X[k];
+	let runLo = runHi;
+	for (let n = longestLIS - 1; n > 0; n--) {
+		k = predecessor[k];
+		const v = X[k];
+		if (v === runLo - 1) runLo = v;
+		else {
+			if (runHi > runLo) runs.push(-1 - runHi);
+			runs.push(runLo);
+			runHi = runLo = v;
+		}
+	}
+	if (runHi > runLo) runs.push(-1 - runHi);
+	runs.push(runLo);
+	return runs;
+};
+//#endregion
+//#region src/DOM/util/moveBeforeSupport.ts
+var supportsMoveBefore = typeof Element !== "undefined" && typeof Element.prototype.moveBefore === "function";
+//#endregion
+//#region src/DOM/nodeControllers/StateController.ts
+var stateControllerMap = /* @__PURE__ */ new Map();
+var promoteArrayElements = (arr) => {
+	for (let i = 0; i < arr.length; i++) {
+		const el = arr[i];
+		if (isAnyState(el) || isArray(el)) continue;
+		const ls = lightState(el);
+		markPromotedElement(ls);
+		arr[i] = ls;
+	}
+	return arr;
+};
+var getKeptChildren = (newChildren, mutation) => {
+	let keptChildren = newChildren;
+	if (mutation.added.length) {
+		const add = mutation.added;
+		keptChildren = [];
+		let k = 0;
+		let lo = add[k++];
+		let hi = k < add.length && add[k] < 0 ? -1 - add[k++] : lo;
+		for (let i = 0; i < newChildren.length; i++) {
+			if (i > hi && k < add.length) {
+				lo = add[k++];
+				hi = k < add.length && add[k] < 0 ? -1 - add[k++] : lo;
+			}
+			if (i < lo || i > hi) keptChildren.push(newChildren[i]);
+		}
+	}
+	return keptChildren;
+};
+var StateController = class StateController extends NodeController {
+	nst;
+	nxt;
+	insertionParent;
+	nestLevel = 1;
+	namedStates;
+	static pendingDestroy = /* @__PURE__ */ new Set();
+	static idleDestroy = /* @__PURE__ */ new Set();
+	static pendingClears = /* @__PURE__ */ new Map();
+	static idleClears = /* @__PURE__ */ new Map();
+	static pendingCalls = /* @__PURE__ */ new Set();
+	static idleCalls = /* @__PURE__ */ new Set();
+	static previousStateControllers = {
+		prev: [],
+		indexed: false,
+		lookup(ls) {
+			if (!this.indexed) {
+				for (const child of this.prev) if (child instanceof StateController) stateControllerMap.set(child.def, child);
+				this.indexed = true;
+			}
+			return stateControllerMap.get(ls);
+		}
+	};
+	static movableControllersByDef = /* @__PURE__ */ new Map();
+	get tfm() {
+		return this.def.tf;
+	}
+	build(parentController, DOMContext, stateContext, namedStates, hydrationContext, level = 1) {
+		super.build(parentController, DOMContext, stateContext, namedStates, hydrationContext, level);
+		StateController.registerMovableChildren(this);
+	}
+	remove(removeNode = true) {
+		const def = this.def;
+		if (StateController.movableControllersByDef.get(def) === this) StateController.movableControllersByDef.delete(def);
+		super.remove(removeNode);
+	}
+	static registerMovableChildren(sc) {
+		if (sc.nst !== 1 || sc.ctx?.md === 2 || !sc.hasMovableChildren()) return;
+		for (const child of sc.c) if (child instanceof StateController) StateController.movableControllersByDef.set(child.def, child);
+	}
+	static detachFromDonor(donor, gainer) {
+		const donorPar = donor.par;
+		if (!(donorPar instanceof StateController) || donorPar === gainer || !donorPar.c) return;
+		const dc = donorPar.c;
+		const di = dc.indexOf(donor);
+		dc.splice(di, 1);
+		donorPar.updateNodeCount(donorPar.nc - getNodeCount(donor));
+	}
+	hasMovableChildren() {
+		return !!(this.par && this.par.flg & 4);
+	}
+	static registerPendingCall(fn) {
+		StateController.pendingCalls.add(fn);
+	}
+	static flushPendingWork() {
+		const clears = StateController.pendingClears;
+		if (clears.size) {
+			StateController.pendingClears = StateController.idleClears;
+			StateController.idleClears = clears;
+			for (const [sc, el] of clears) sc.detachCleared(el);
+			clears.clear();
+		}
+		const pending = StateController.pendingDestroy;
+		if (pending.size) {
+			StateController.pendingDestroy = StateController.idleDestroy;
+			StateController.idleDestroy = pending;
+			swapDeferredNodes();
+			for (const child of pending) if (child instanceof Node) child.parentNode?.removeChild(child);
+			else child.remove();
+			pending.clear();
+			clearDrainedDeferredNodes();
+		}
+		const calls = StateController.pendingCalls;
+		if (calls.size) {
+			StateController.pendingCalls = StateController.idleCalls;
+			StateController.idleCalls = calls;
+			for (const fn of calls) fn();
+			calls.clear();
+		}
+	}
+	buildNode(_properties, namedStates, _stateContext, _hydrationContext, level = 1) {
+		this.nestLevel = level;
+		this.namedStates = namedStates;
+		const is = this.def;
+		refresh(is);
+		const tf = is.tf;
+		if (tf && tf.flg & 2 && is.v instanceof NodeController && is.v.isSpent()) tf.execute();
+		const value = is.v;
+		if (typeof value === "string" || typeof value === "number") this.c = [this.createTextChild(value)];
+		else this.parseArgs(this.childArgs(value));
+		this.addSub(new CallbackTransform(is, StateController.stateChanged, this, this.nestLevel));
+		this.nst = this.checkNodeStateType();
+	}
+	childArgs(value) {
+		if (!isArray(value)) return [value];
+		return this.def.tf ? value : promoteArrayElements(value);
+	}
+	checkNodeStateType() {
+		const state = this.def;
+		const stateType = getStateType(state);
+		return stateType !== 0 ? stateType : state.v == null ? 6 : 0;
+	}
+	static stateChanged(_value, sc) {
+		sc.onStateChange();
+	}
+	onStateChange() {
+		try {
+			this.updateBody();
+		} catch (e) {
+			this.handleReactiveError(e);
+		}
+	}
+	updateBody() {
+		const definition = this.def.v;
+		const oldNodeStateType = this.nst;
+		this.nst = this.checkNodeStateType();
+		const node = this.c[0];
+		if (node && oldNodeStateType === 0 && this.nst === 0) {
+			node.textContent = String(definition);
+			return;
+		}
+		const pendingClear = StateController.pendingClears.get(this);
+		if (pendingClear) {
+			StateController.pendingClears.delete(this);
+			this.detachCleared(pendingClear);
+		}
+		if (oldNodeStateType === 1 && this.nst === 1 && !definition.length && this.clearAll()) return;
+		if ((oldNodeStateType === 1 || this.nst === 1) && (oldNodeStateType === this.nst || this.hasMovableChildren())) {
+			const oldChildren = this.c;
+			const pos = this.par.findNode(this);
+			this.nxt = liveChildNodeAt(pos.p, pos.i + this.nc, pos.n, pos.i);
+			const previousStateControllers = StateController.previousStateControllers;
+			previousStateControllers.prev = oldChildren;
+			previousStateControllers.indexed = false;
+			this.parseArgs(this.childArgs(definition), previousStateControllers);
+			previousStateControllers.prev = [];
+			stateControllerMap.clear();
+			let fnr = {
+				i: 0,
+				s: 0
+			};
+			let cursorNode;
+			let cursorNodeIndex = 0;
+			const children = this.c;
+			let newNodeCount = 0;
+			let firstChange;
+			let lastChange = 0;
+			let changedCount = 0;
+			const movable = this.hasMovableChildren();
+			const registersMovableChildren = movable && this.nst === 1 && this.ctx?.md !== 2;
+			for (let idx = 0; idx < children.length; idx++) {
+				let child = children[idx];
+				if (child instanceof NodeController) {
+					if (child.par !== this) {
+						const donor = movable && child instanceof StateController && !child.par ? StateController.movableControllersByDef.get(child.def) : void 0;
+						if (donor) {
+							StateController.pendingDestroy.delete(donor);
+							for (const n of this.getNodes(donor)) adoptDeferredNode(n);
+							StateController.detachFromDonor(donor, this);
+							donor.par = this;
+							child = children[idx] = donor;
+						} else if (movable && !(child instanceof StateController) && child.isMounted() && this.adoptBareChild(child)) {} else if (child.flg & 4) {
+							child.build(this, void 0, child, this.namedStates, void 0, this.nestLevel + 1);
+							if (cursorNode !== void 0) cursorNodeIndex += getNodeCount(child);
+						} else {
+							fnr = this.findNode(child, fnr.i, fnr.s, cursorNode, cursorNodeIndex);
+							child.build(this, fnr, child, this.namedStates, void 0, this.nestLevel + 1);
+							cursorNode = fnr.n;
+							cursorNodeIndex = fnr.i + getNodeCount(child);
+						}
+					}
+					children[idx] = this.resolveChild(child, true);
+				}
+				const resolvedChild = children[idx];
+				if (registersMovableChildren && resolvedChild instanceof StateController) StateController.movableControllersByDef.set(resolvedChild.def, resolvedChild);
+				newNodeCount += getNodeCount(resolvedChild);
+				if (resolvedChild !== oldChildren[idx]) {
+					firstChange ??= idx;
+					lastChange = idx;
+					changedCount++;
+				}
+			}
+			const newChildren = children;
+			const sameLength = newChildren.length === oldChildren.length;
+			const mutation = computeMutation(oldChildren, newChildren, {
+				pre: firstChange ?? newChildren.length,
+				suf: sameLength ? newChildren.length - 1 - lastChange : void 0,
+				changedCount: sameLength ? changedCount : void 0
+			});
+			this.applyMutation(mutation, oldChildren, newChildren);
+			this.updateNodeCount(newNodeCount);
+			return;
+		}
+		this.removeChildren();
+		this.parseArgs(this.childArgs(definition));
+		this.updateNodeCount(this.addChildren(this.par.findNode(this), void 0, void 0, this.namedStates, this.nestLevel));
+		StateController.registerMovableChildren(this);
+	}
+	clearAll() {
+		if (!this.nc || this.ctx?.md === 2) return false;
+		if (this.hasMovableChildren()) {
+			const el = this.par.el;
+			if (!this.par.isSoleChild(this) || el.childNodes.length !== this.nc) return false;
+			for (const child of this.c) {
+				StateController.pendingDestroy.add(child);
+				if (child instanceof NodeController) child.par = void 0;
+			}
+			StateController.pendingClears.set(this, el);
+		} else {
+			const el = this.enclosingMountElement();
+			if (el?.childNodes.length !== this.nc) return false;
+			el.textContent = "";
+			this.removeChildren(false);
+		}
+		this.c = [];
+		this.updateNodeCount(0);
+		return true;
+	}
+	detachCleared(el) {
+		el.textContent = "";
+	}
+	adoptBareChild(child) {
+		const held = child.heldForm();
+		if (!StateController.pendingDestroy.delete(held)) {
+			const owner = child.par;
+			if (!(owner instanceof StateController) || owner === this || !owner.hasMovableChildren()) return false;
+			const oc = owner.c;
+			oc.splice(oc.indexOf(held), 1);
+			owner.updateNodeCount(owner.nc - getNodeCount(held));
+		}
+		for (const n of this.getNodes(held)) adoptDeferredNode(n);
+		child.par = this;
+		return true;
+	}
+	detachChild(children, i) {
+		const child = children[i];
+		if (!this.hasMovableChildren()) {
+			if (child instanceof Node) child.parentNode?.removeChild(child);
+			else child.remove();
+			return;
+		}
+		StateController.pendingDestroy.add(child);
+		if (child instanceof Node) deferNode(child);
+		else for (const n of this.getNodes(child)) deferNode(n);
+		if (child instanceof NodeController) child.par = void 0;
+	}
+	insertChild(children, i) {
+		const child = children[i];
+		this.insertionParent ??= this.par.findNode(this);
+		const parent = this.insertionParent.p;
+		const ref = this.nextDomNode(children, i);
+		const node = child instanceof NodeController ? child.el : child;
+		if (node) StateController.insertNode(parent, node, ref);
+		else for (const childNode of this.getNodes(child)) StateController.insertNode(parent, childNode, ref);
+	}
+	static insertNode(parent, node, ref) {
+		if (node.parentNode !== parent || node.nextSibling !== ref) {
+			if (supportsMoveBefore && node.parentNode) parent.moveBefore(node, ref);
+			else parent.insertBefore(node, ref);
+		}
+	}
+	moveChild(children, i) {
+		const child = children[i];
+		this.insertionParent ??= this.par.findNode(this);
+		const parent = this.insertionParent.p;
+		const ref = this.nextDomNode(children, i);
+		for (const childNode of this.getNodes(child)) if (supportsMoveBefore) parent.moveBefore(childNode, ref);
+		else parent.insertBefore(childNode, ref);
+	}
+	nextDomNode(children, i) {
+		for (let j = i + 1; j < children.length; j++) if (getNodeCount(children[j])) return this.getFirstNode(children[j]);
+		return this.nxt ?? null;
+	}
+	mutateRange(children, range, operator) {
+		if (!range) return;
+		let hi = -1;
+		for (let k = range.length - 1; k >= 0; k--) {
+			const e = range[k];
+			if (e < 0) hi = -1 - e;
+			else {
+				for (let j = hi < 0 ? e : hi; j >= e; j--) operator.call(this, children, j);
+				hi = -1;
+			}
+		}
+	}
+	applyMutation(mutation, oldChildren, newChildren) {
+		this.mutateRange(oldChildren, mutation.removed, this.detachChild);
+		if (mutation.moved) this.mutateRange(getKeptChildren(newChildren, mutation), mutation.moved, this.moveChild);
+		this.mutateRange(newChildren, mutation.added, this.insertChild);
+		this.insertionParent = void 0;
+		this.nxt = void 0;
+	}
+};
+StateController.prototype.flg = 10;
+registerFlushPendingWork(StateController.flushPendingWork);
+//#endregion
+//#region src/DOM/nodeControllers/ElementController.ts
+var collectClassNames = (v, classNames) => {
+	const dv = peek(v);
+	throwIfPoisoned(dv);
+	if (typeof dv === "string") classNames.push(dv);
+	else if (isArray(dv)) for (const subValue of dv) collectClassNames(subValue, classNames);
+	else if (isPOJO(dv)) {
+		const classObject = v;
+		for (const className in classObject) {
+			const rawEnabled = peek(classObject[className]);
+			throwIfPoisoned(rawEnabled);
+			if (rawEnabled) classNames.push(className);
+		}
+	}
+	return classNames;
+};
+var calculateClassString = (v) => collectClassNames(v, []).join(" ");
+var refreshClassStates = (v) => {
+	const ls = getLightState(v);
+	if (ls) refresh(ls);
+	const value = ls ? ls.v : v;
+	if (isArray(value)) for (const subValue of value) refreshClassStates(subValue);
+	else if (isPOJO(value)) {
+		const classObject = value;
+		for (const className in classObject) refreshClassStates(classObject[className]);
+	}
+};
+var nonAttributeKeys = /* @__PURE__ */ new Set([
+	"innerHTML",
+	"value",
+	"checked",
+	"selected",
+	"autofocus"
+]);
+var isLifecycleKey = (key) => key === "nodeCreated" || key === "nodeRemoved" || key === "nodeInserted";
+var isAutoBindableEventKey = (key) => key === "input" || key === "change";
+var isEventListener = (v) => typeof v === "function" ? !isState(v) : typeof v?.handleEvent === "function";
+var isEventListenerTuple = (v) => isArray(v) && isEventListener(v[0]);
+var isPlainArray = (v) => {
+	return v != null && Object.getPrototypeOf(v) === Array.prototype;
+};
+var isReactiveClassObject = (classObject) => {
+	for (const className in classObject) if (isAnyState(classObject[className])) return true;
+	return false;
+};
+var isReactiveClassValue = (v) => isAnyState(v) || isPlainArray(v) && v.some(isReactiveClassValue) || isPOJO(v) && isReactiveClassObject(v);
+var ElementController = class ElementController extends NodeController {
+	makeElement(tagName) {
+		return (this.ctx?.md === 2 ? this.ctx.doc : document).createElement(tagName);
+	}
+	remove(removeNode = true) {
+		super.remove(removeNode);
+		if (removeNode && this.eventListeners) this.eventListeners = void 0;
+	}
+	buildNode(properties, _namedStates, stateContext, hydrationContext) {
+		const target = stateContext;
+		if (this.ctx?.md === 1) {
+			this.removeExcessNodes(hydrationContext);
+			if (!(hydrationContext.nxt instanceof HTMLElement || hydrationContext.nxt instanceof SVGElement)) throw Error("Hydration failed due to DOM mismatch");
+			this.el = hydrationContext.nxt;
+			hydrationContext.nxt = hydrationContext.nxt.nextSibling;
+		} else this.el = this.makeElement(this.def);
+		if (properties) for (const key in properties) {
+			const value = properties[key];
+			if (key === "class") {
+				const isReactive = typeof value !== "string" && isReactiveClassValue(value);
+				if (isReactive) refreshClassStates(value);
+				this.handleProp(key, typeof value === "string" ? value : isReactive ? new transforms.LightStateFunctionTransform(void 0, calculateClassString, [value]).execute() : calculateClassString(value), target);
+			} else if (key === "style") {
+				const styleObject = value;
+				for (const styleKey in styleObject) this.handleProp(key, styleObject[styleKey], target, camelToKebab(styleKey));
+			} else this.handleProp(key, value, target);
+		}
+	}
+	joinPropArray(a) {
+		return a.filter((v) => peek(v) != null).join("");
+	}
+	handleProp(key, value, stateContext, subkey) {
+		if ((typeof value === "string" || typeof value === "number") && !subkey && !nonAttributeKeys.has(key) && (value !== "" || key !== "class")) {
+			this.el.setAttribute(key, String(value));
+			return;
+		}
+		const joinedValue = isPlainArray(value) && !isEventListenerTuple(destate(value)) ? value.some(isAnyState) ? new transforms.LightStateFunctionTransform(void 0, this.joinPropArray, [value]).execute() : this.joinPropArray(value) : value;
+		const joinedValueLightState = this.updateProperty(key, joinedValue, subkey, stateContext);
+		if (joinedValueLightState) this.addSub(new CallbackTransform(joinedValueLightState, ElementController.propertyChanged, {
+			ctl: this,
+			prop: key,
+			subkey
+		}), stateContext);
+	}
+	static propertyChanged(newValue, binding) {
+		binding.ctl.applyUpdate(newValue, binding.prop, binding.subkey);
+	}
+	applyUpdate(newValue, key, subkey) {
+		try {
+			this.updateProperty(key, newValue, subkey);
+		} catch (e) {
+			this.handleReactiveError(e);
+		}
+	}
+	updateProperty(key, value, subkey, target) {
+		let ls = getLightState(value);
+		if (ls) refresh(ls);
+		let dv = ls ? ls.v : value;
+		throwIfPoisoned(dv);
+		if (key === "innerHTML") this.el.innerHTML = String(dv);
+		else if (key === "style") this.el.style.setProperty(subkey, dv);
+		else if (this.ctx?.md !== 2 && (key === "value" || key === "checked" || key === "selected")) this.el[key] = dv;
+		else if (this.eventListeners && key in this.eventListeners || (typeof dv === "function" || isEventListenerTuple(dv)) && !isLifecycleKey(key) || ls && isAutoBindableEventKey(key)) {
+			if (this.ctx?.md !== 2) {
+				if (this.eventListeners && key in this.eventListeners) {
+					this.el.removeEventListener(key, ...this.eventListeners[key]);
+					delete this.eventListeners[key];
+				} else if (dv !== null && typeof dv !== "function" && !isArray(dv) && (dv !== void 0 || !ls.tf)) {
+					const stateToUpdate = ls;
+					assertWritable(stateToUpdate);
+					dv = (ev) => {
+						const checked = ev.target.type === "checkbox" || ev.target.type === "radio";
+						const numeric = ev.target.type === "number" || ev.target.type === "range";
+						updateValue(stateToUpdate, checked ? ev.target.checked : numeric ? ev.target.valueAsNumber : ev.target.value);
+					};
+					ls = void 0;
+				}
+				if (dv != null) {
+					const tuple = isArray(dv) ? dv : void 0;
+					const rawHandler = tuple ? tuple[0] : dv;
+					const listenerOptions = tuple?.[1];
+					const wrapped = typeof rawHandler === "function" ? (e) => fastFlush(rawHandler, e) : { handleEvent: (e) => fastFlush((ev) => rawHandler.handleEvent(ev), e) };
+					this.el.addEventListener(key, wrapped, listenerOptions);
+					if (ls || !target) (this.eventListeners ??= {})[key] = [wrapped, listenerOptions];
+				}
+			}
+		} else if (key === "autofocus" && this.ctx?.md === 0) {} else if (typeof dv === "string" || typeof dv === "number" || typeof dv === "bigint") {
+			if (dv === "" && key === "class") this.el.removeAttribute(key);
+			else this.el.setAttribute(key, String(dv));
+		} else if (dv === null || dv === false) this.el.removeAttribute(key);
+		else if (dv === true) this.el.setAttribute(key, "");
+		else if (this.ctx?.md === 2 && isLifecycleKey(key)) {} else if (key === "nodeCreated") dv?.({ target: this.el });
+		else if (key === "nodeRemoved") {
+			if (ls) throw TypeError("nodeRemoved cannot be a reactive State");
+			target.addCleanup(dv);
+		} else if (key === "nodeInserted") {
+			const callback = dv;
+			if (this.ctx?.md === 1) callback?.({ target: this.el });
+			else if (callback) this.deferUntilConnected(() => callback({ target: this.el }));
+		}
+		if (key === "autofocus" && dv && this.ctx?.md === 0) this.deferUntilConnected(() => this.el.focus());
+		return ls;
+	}
+	deferUntilConnected(fn) {
+		const el = this.el;
+		StateController.registerPendingCall(() => {
+			if (el.isConnected) fn();
+		});
+	}
+};
+ElementController.prototype.flg = 4;
+//#endregion
+//#region src/DOM/nodeControllers/SVGElementController.ts
+var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+var SVGElementController = class extends ElementController {
+	makeElement(tagName) {
+		return this.ctx?.md === 2 ? this.ctx.doc.createElement(tagName) : document.createElementNS(SVG_NAMESPACE, tagName);
+	}
+};
+//#endregion
+//#region src/DOM/nodeControllers/ComponentController.ts
+var ComponentController = class extends NodeController {
+	orValue;
+	renderError;
+	buildNode(properties, namedStates, stateContext) {
+		const target = stateContext;
+		startCapturingStateCalls(namedStates);
+		let args;
+		let captured;
+		try {
+			const componentArgs = {
+				...properties ?? {},
+				children: this.c,
+				renderError: this.renderError
+			};
+			if (this.orValue && this.def.constructor.name === "AsyncFunction") {
+				const componentPromise = this.def(componentArgs);
+				const delayedComponent = new transforms.PromiseTransform(componentPromise).execute();
+				args = new transforms.FunctionTransform(delayedComponent, orFunction, [delayedComponent, this.orValue]).execute();
+			} else args = this.def(componentArgs);
+		} finally {
+			captured = stopCapturingStateCalls();
+		}
+		const { namedStates: newNamedStates, subscriptions } = captured;
+		subscriptions?.forEach((unsub) => target.addCleanup(unsub));
+		this.parseArgs([args]);
+		return newNamedStates;
+	}
+	or(v) {
+		this.orValue = v;
+		return this;
+	}
+};
+ComponentController.prototype.flg = 1;
+//#endregion
+//#region src/DOM/nodeControllers/RootController.ts
+var RootController = class extends NodeController {
+	rootEl;
+	constructor(definition, args) {
+		super(definition, args);
+		if (!isInComponent()) new transforms.DOMRootTransform(this).queue();
+	}
+	buildNode(properties) {
+		const inherited = this.ctx?.md;
+		const mode = properties?.mode;
+		this.ctx = {
+			md: mode === void 0 ? inherited ?? 0 : mode === "render" ? 2 : mode === "hydrate" ? 1 : 0,
+			doc: properties?.doc ?? this.ctx?.doc
+		};
+		const given = properties?.root;
+		if (this.par) {
+			if (inherited === 2) {
+				this.c = [];
+				this.rootEl = this.ctx.doc.createElement("");
+				return;
+			}
+			if (inherited === 1 && mode === void 0) this.ctx.md = 0;
+		}
+		if (this.ctx.md === 2) {
+			if (given) throw Error("render mode does not install into a root - use renderToString()");
+			this.rootEl = this.ctx.doc.createElement("");
+			return;
+		}
+		this.rootEl = given ?? document.body;
+		if (this.ctx.md === 0) this.pnc = liveChildNodeCount(this.rootEl);
+	}
+	getMountElement() {
+		return this.rootEl;
+	}
+	getParallelNodeCount() {
+		return 0;
+	}
+	createRoot() {
+		if (!this.rootEl) this.build();
+	}
+	renderedRoot() {
+		return this.rootEl;
+	}
+	remove() {
+		this.unsubscribeAll();
+		this.removeChildren(true);
+	}
+};
+RootController.prototype.flg = 25;
+//#endregion
+//#region src/DOM/domFunctions.ts
+NodeController.setStateController(StateController);
+NodeController.setComponentController(ComponentController);
+var component = (definition) => (...args) => new ComponentController(definition, args);
+var domElement = (elementName) => (...args) => new ElementController(elementName, args);
+var svgElement = (elementName) => (...args) => new SVGElementController(elementName, args);
+var SnapseRoot = (...args) => new RootController("", args);
+//#endregion
+//#region src/state/compute.ts
+var compute = (computeFunction) => new transforms.ComputeTransform(computeFunction).execute();
+//#endregion
+//#region src/common/undoUtils.ts
+var decodeAscendingRLE = function* (range) {
+	if (!range) return;
+	let runStart;
+	for (let k = 0; k < range.length; k++) {
+		const v = range[k];
+		if (v < 0) for (let j = runStart + 1; j < -v; j++) yield j;
+		else {
+			runStart = v;
+			yield v;
+		}
+	}
+};
+//#endregion
+//#region src/state/transforms/ChangeAggregateTransform.ts
+var deepDestate = (value) => {
+	const raw = destate(value);
+	if (isArray(raw)) return raw.map(deepDestate);
+	if (isPOJO(raw)) return Object.fromEntries(Object.entries(raw).map(([k, v]) => [k, deepDestate(v)]));
+	return raw;
+};
+var ChangeAggregateTransform = class ChangeAggregateTransform extends Transform {
+	parent;
+	pathKey;
+	changes;
+	containerChildren;
+	leafValues;
+	previousArrayChildren;
+	seq = 0;
+	flg = 1;
+	static forState(ls) {
+		return new ChangeAggregateTransform(ls, void 0, "", [], /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), false).tgt;
+	}
+	constructor(source, parent, key, changes, containerChildren, leafValues, addChanges = true) {
+		super(source);
+		this.parent = parent;
+		this.pathKey = key;
+		this.changes = changes;
+		this.containerChildren = containerChildren;
+		this.leafValues = leafValues;
+		this.execute(addChanges);
+	}
+	buildPath(extra) {
+		const segments = extra !== void 0 ? [extra] : [];
+		if (this.parent) segments.unshift(this.pathKey);
+		let node = this.parent;
+		while (node?.parent) {
+			segments.unshift(node.pathKey);
+			node = node.parent;
+		}
+		return segments;
+	}
+	drain() {
+		const records = this.changes.slice();
+		this.changes.length = 0;
+		return records;
+	}
+	execute(addChanges = true) {
+		const sources = acquireSet();
+		sources.add(this.srcLs);
+		const isArray = getStateType(this.srcLs) === 1;
+		const parent = this.srcLs.v;
+		const keys = Object.keys(parent);
+		const currentChildren = [];
+		let childReplaced = false;
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const childLs = getSubState(this.srcLs, key);
+			if (isArray) {
+				currentChildren.push(childLs);
+				childReplaced ||= this.previousArrayChildren?.[i] !== childLs;
+			}
+			const childType = getStateType(childLs);
+			if (childType === 1 || childType === 2) {
+				let childContainer = this.containerChildren.get(childLs);
+				if (childContainer) {
+					if (isArray) childContainer.pathKey = key;
+				} else {
+					childContainer = new ChangeAggregateTransform(childLs, this, key, this.changes, this.containerChildren, this.leafValues, addChanges && !isArray);
+					this.containerChildren.set(childLs, childContainer);
+				}
+				sources.add(childContainer.tgt);
+			} else {
+				const cur = destate(childLs);
+				const had = this.leafValues.has(childLs);
+				const prev = this.leafValues.get(childLs);
+				if (addChanges && (had && !Object.is(prev, cur) || !had && !isArray)) this.changes.push({
+					"path": this.buildPath(key),
+					"value": cur,
+					"oldValue": prev
+				});
+				this.leafValues.set(childLs, cur);
+				sources.add(childLs);
+			}
+		}
+		if (isArray && (childReplaced || keys.length != this.previousArrayChildren?.length)) this.handleArrayMutation(currentChildren, addChanges);
+		this.updateTarget(this.seq++, sources);
+		releaseSet(sources);
+	}
+	handleArrayMutation(currentChildren, addChanges) {
+		const previousChildren = this.previousArrayChildren ?? [];
+		const mutation = computeMutation(previousChildren, currentChildren);
+		if (addChanges) {
+			const addedValues = [];
+			for (const i of decodeAscendingRLE(mutation.added)) {
+				const ls = currentChildren[i];
+				const containerChild = this.containerChildren.get(ls);
+				addedValues.push(containerChild ? deepDestate(containerChild.srcLs.v) : this.leafValues.get(ls));
+			}
+			const removedValues = [];
+			for (const i of decodeAscendingRLE(mutation.removed)) {
+				const ls = previousChildren[i];
+				const child = this.containerChildren.get(ls);
+				removedValues.push(child ? deepDestate(child.srcLs.v) : this.leafValues.get(ls));
+			}
+			const record = {
+				"path": this.buildPath(),
+				"reorder": true,
+				"prefixL": mutation.pre,
+				"suffixL": mutation.suf,
+				"addedValues": addedValues,
+				"removedValues": removedValues
+			};
+			if (mutation.removed !== void 0) record["remove"] = mutation.removed;
+			if (mutation.added !== void 0) record["add"] = mutation.added;
+			if (mutation.kept !== void 0) record["common"] = mutation.kept;
+			this.changes.push(record);
+		}
+		for (const i of decodeAscendingRLE(mutation.removed)) {
+			const ls = previousChildren[i];
+			this.containerChildren.delete(ls);
+			this.leafValues.delete(ls);
+		}
+		this.previousArrayChildren = currentChildren;
+	}
+};
+//#endregion
+//#region src/state/transforms/ChangeCallbackTransform.ts
+var ChangeCallbackTransform = class extends CallbackTransform {
+	execute() {
+		const records = this.srcLs.tf.drain();
+		if (!records.length) return;
+		const v = destate(this.srcLs);
+		for (let i = 0; i < records.length; i++) {
+			if (i === records.length - 1) records[i]["done"] = true;
+			try {
+				this.hookFunction(v, records[i]);
+			} catch (e) {
+				Transform.throwDelayed(e);
+			}
+		}
+	}
+};
+//#endregion
+//#region src/state/subscribeChanges.ts
+var subscribeChanges = (state, callback) => subscribeWith(state, (ls) => {
+	const target = ChangeAggregateTransform.forState(ls);
+	return [target, new ChangeCallbackTransform(target, callback)];
+});
+//#endregion
+//#region src/undo/undo.ts
+var flushRun = (out, lo, hi) => {
+	out.push(lo);
+	if (hi > lo) out.push(-1 - hi);
+};
+var encodeAscendingRLE = (values) => {
+	const out = [];
+	let lo = -1;
+	let hi = -2;
+	for (const v of values) {
+		if (v < 0) return values;
+		if (v !== hi + 1) {
+			if (lo >= 0) flushRun(out, lo, hi);
+			lo = v;
+		}
+		hi = v;
+	}
+	flushRun(out, lo, hi);
+	return out;
+};
+var stripDefaults = (change) => {
+	for (const k in change) {
+		if (k === "value" || k === "oldValue") continue;
+		const v = change[k];
+		if (!v || isArray(v) && v.length === 0) delete change[k];
+	}
+};
+var TrackHistory = class {
+	tracked;
+	opts;
+	undoStack = [];
+	redoStack = [];
+	batch = [];
+	applying = false;
+	batching = false;
+	unsub;
+	undoEmpty;
+	redoEmpty;
+	historyVersions;
+	onChange = (_v, change) => {
+		if (this.applying || !change) return;
+		stripDefaults(change);
+		if (change.common) change.common = encodeAscendingRLE(change.common);
+		if (this.batch.length === 0 && this.redoStack.length) {
+			this.redoStack.length = 0;
+			this.updateDerivedState();
+		}
+		this.batch.push(change);
+		if (this.batching || !change.done) return;
+		this.finalizeBatch();
+	};
+	finalizeBatch() {
+		if (!this.batch.length) return;
+		this.undoStack.push({
+			batch: this.batch,
+			t: this.opts?.addHistoryVersion?.() ?? Date.now()
+		});
+		if (this.opts?.limit && this.undoStack.length > this.opts.limit) this.undoStack.shift();
+		this.batch = [];
+		this.updateDerivedState();
+	}
+	updateDerivedState() {
+		this.undoEmpty.set(this.undoStack.length === 0);
+		this.redoEmpty.set(this.redoStack.length === 0);
+		this.historyVersions.set(this.undoStack.map((entry) => entry.t));
+	}
+	constructor(root, opts) {
+		this.tracked = root;
+		this.opts = opts;
+		this.undoEmpty = state(true);
+		this.redoEmpty = state(true);
+		this.historyVersions = state([]);
+		this.unsub = subscribeChanges(root, this.onChange);
+	}
+	walkToNode(path = []) {
+		let node = this.tracked;
+		for (const key of path) node = node[key];
+		return node;
+	}
+	applyReorder(parent, change, forward) {
+		const src = peek(parent);
+		const uncompactedSrc = forward ? void 0 : src.slice();
+		const addValues = forward ? change.addedValues : change.removedValues;
+		const remove = forward ? change.remove : change.add;
+		const removedCount = (forward ? change.removedValues : change.addedValues)?.length ?? 0;
+		const afterLength = src.length - removedCount + (addValues?.length ?? 0);
+		const prefixL = change.prefixL ?? 0;
+		const suffixL = change.suffixL ?? 0;
+		const rle = decodeAscendingRLE(remove);
+		let skip = rle.next().value;
+		let j = 0;
+		for (let i = 0; i < src.length; i++) {
+			while (i < (skip ?? src.length)) src[j++] = src[i++];
+			skip = rle.next().value;
+		}
+		const keptLength = j;
+		let out = [];
+		if (change.common) {
+			for (let p = 0; p < prefixL; p++) out[p] = src[p];
+			let mid = prefixL;
+			if (forward) for (const i of decodeAscendingRLE(change.common)) out[i] = src[mid++];
+			else for (const i of decodeAscendingRLE(change.common)) out[mid++] = uncompactedSrc[i];
+			const suffixStart = forward ? afterLength - suffixL : mid;
+			for (let s = 0; s < suffixL; s++) out[suffixStart + s] = src[keptLength - suffixL + s];
+		} else out = src.slice();
+		j = 0;
+		if (forward && change.common) for (const i of decodeAscendingRLE(change.add)) out[i] = addValues[j++];
+		else {
+			const spliceAt = decodeAscendingRLE(forward ? change.add : change.remove);
+			for (const i of spliceAt) out.splice(i, 0, addValues[j++]);
+		}
+		out.length = afterLength;
+		parent.set(out);
+	}
+	applyChange(change, forward) {
+		if (change.reorder) return this.applyReorder(this.walkToNode(change.path), change, forward);
+		const path = change.path;
+		const parent = this.walkToNode(path.slice(0, -1));
+		const key = path[path.length - 1];
+		parent[key] = forward ? change.value : change.oldValue;
+	}
+	replay(entry, forward) {
+		this.applying = true;
+		if (forward) for (const change of entry.batch) this.applyChange(change, true);
+		else for (let i = entry.batch.length - 1; i >= 0; i--) this.applyChange(entry.batch[i], false);
+		flush();
+		this.applying = false;
+	}
+	undo = () => {
+		const entry = this.undoStack.pop();
+		if (!entry) return false;
+		this.replay(entry, false);
+		this.redoStack.push(entry);
+		this.updateDerivedState();
+		return true;
+	};
+	redo = () => {
+		const entry = this.redoStack.pop();
+		if (!entry) return false;
+		this.replay(entry, true);
+		this.undoStack.push(entry);
+		this.updateDerivedState();
+		return true;
+	};
+	restoreAt(timestamp) {
+		while (this.undoStack.length && this.undoStack[this.undoStack.length - 1].t > timestamp) {
+			const entry = this.undoStack.pop();
+			this.replay(entry, false);
+			this.redoStack.push(entry);
+		}
+		while (this.redoStack.length && this.redoStack[this.redoStack.length - 1].t <= timestamp) {
+			const entry = this.redoStack.pop();
+			this.replay(entry, true);
+			this.undoStack.push(entry);
+		}
+		this.updateDerivedState();
+	}
+	startBatch() {
+		this.batching = true;
+	}
+	commitBatch() {
+		this.batching = false;
+		this.finalizeBatch();
+	}
+	getHistory() {
+		return [...this.undoStack];
+	}
+	setHistory(history) {
+		this.undoStack.length = 0;
+		this.undoStack.push(...history);
+		this.redoStack.length = 0;
+		this.updateDerivedState();
+	}
+	unsubscribe() {
+		this.unsub();
+	}
+};
+//#endregion
+//#region src/DOM/elements/DOMElements.ts
+function inputFactory(...args) {
+	return new ElementController("input", args);
+}
+var a$1 = domElement("a");
+var abbr = domElement("abbr");
+var address = domElement("address");
+var area = domElement("area");
+var article = domElement("article");
+var aside = domElement("aside");
+var audio = domElement("audio");
+var b = domElement("b");
+var base = domElement("base");
+var bdi = domElement("bdi");
+var bdo = domElement("bdo");
+var blockquote = domElement("blockquote");
+var body = domElement("body");
+var br = domElement("br");
+var button = domElement("button");
+var canvas = domElement("canvas");
+var caption = domElement("caption");
+var cite = domElement("cite");
+var code = domElement("code");
+var col = domElement("col");
+var colgroup = domElement("colgroup");
+var data = domElement("data");
+var datalist = domElement("datalist");
+var dd = domElement("dd");
+var del = domElement("del");
+var details = domElement("details");
+var dfn = domElement("dfn");
+var dialog = domElement("dialog");
+var div = domElement("div");
+var dl = domElement("dl");
+var dt = domElement("dt");
+var em = domElement("em");
+var embed = domElement("embed");
+var fieldset = domElement("fieldset");
+var figcaption = domElement("figcaption");
+var figure = domElement("figure");
+var footer = domElement("footer");
+var form = domElement("form");
+var h1 = domElement("h1");
+var h2 = domElement("h2");
+var h3 = domElement("h3");
+var h4 = domElement("h4");
+var h5 = domElement("h5");
+var h6 = domElement("h6");
+var head = domElement("head");
+var header = domElement("header");
+var hgroup = domElement("hgroup");
+var hr = domElement("hr");
+var html = domElement("html");
+var i = domElement("i");
+var iframe = domElement("iframe");
+var img = domElement("img");
+var input = inputFactory;
+var ins = domElement("ins");
+var kbd = domElement("kbd");
+var label = domElement("label");
+var legend = domElement("legend");
+var li = domElement("li");
+var link = domElement("link");
+var main = domElement("main");
+var map = domElement("map");
+var mark = domElement("mark");
+var menu = domElement("menu");
+var meta = domElement("meta");
+var meter = domElement("meter");
+var nav = domElement("nav");
+var noscript = domElement("noscript");
+var object = domElement("object");
+var ol = domElement("ol");
+var optgroup = domElement("optgroup");
+var option = domElement("option");
+var output = domElement("output");
+var p = domElement("p");
+var picture = domElement("picture");
+var pre = domElement("pre");
+var progress = domElement("progress");
+var q = domElement("q");
+var rp = domElement("rp");
+var rt = domElement("rt");
+var ruby = domElement("ruby");
+var s = domElement("s");
+var samp = domElement("samp");
+var script$1 = domElement("script");
+var search = domElement("search");
+var section = domElement("section");
+var select = domElement("select");
+var slot = domElement("slot");
+var small = domElement("small");
+var source = domElement("source");
+var span = domElement("span");
+var strong = domElement("strong");
+var style$1 = domElement("style");
+var sub = domElement("sub");
+var summary = domElement("summary");
+var sup = domElement("sup");
+var table = domElement("table");
+var tbody = domElement("tbody");
+var td = domElement("td");
+var template = domElement("template");
+var textarea = domElement("textarea");
+var tfoot = domElement("tfoot");
+var th = domElement("th");
+var thead = domElement("thead");
+var time = domElement("time");
+var title$1 = domElement("title");
+var tr = domElement("tr");
+var track = domElement("track");
+var u = domElement("u");
+var ul = domElement("ul");
+var cvar = domElement("var");
+var video = domElement("video");
+var wbr = domElement("wbr");
+//#endregion
+//#region src/DOM/elements/SVGElements.ts
+var a = svgElement("a");
+var animate = svgElement("animate");
+var animateMotion = svgElement("animateMotion");
+var animateTransform = svgElement("animateTransform");
+var circle = svgElement("circle");
+var clipPath = svgElement("clipPath");
+var defs = svgElement("defs");
+var desc = svgElement("desc");
+var ellipse = svgElement("ellipse");
+var feBlend = svgElement("feBlend");
+var feColorMatrix = svgElement("feColorMatrix");
+var feComponentTransfer = svgElement("feComponentTransfer");
+var feComposite = svgElement("feComposite");
+var feConvolveMatrix = svgElement("feConvolveMatrix");
+var feDiffuseLighting = svgElement("feDiffuseLighting");
+var feDisplacementMap = svgElement("feDisplacementMap");
+var feDistantLight = svgElement("feDistantLight");
+var feDropShadow = svgElement("feDropShadow");
+var feFlood = svgElement("feFlood");
+var feFuncA = svgElement("feFuncA");
+var feFuncB = svgElement("feFuncB");
+var feFuncG = svgElement("feFuncG");
+var feFuncR = svgElement("feFuncR");
+var feGaussianBlur = svgElement("feGaussianBlur");
+var feImage = svgElement("feImage");
+var feMerge = svgElement("feMerge");
+var feMergeNode = svgElement("feMergeNode");
+var feMorphology = svgElement("feMorphology");
+var feOffset = svgElement("feOffset");
+var fePointLight = svgElement("fePointLight");
+var feSpecularLighting = svgElement("feSpecularLighting");
+var feSpotLight = svgElement("feSpotLight");
+var feTile = svgElement("feTile");
+var feTurbulence = svgElement("feTurbulence");
+var filter = svgElement("filter");
+var foreignObject = svgElement("foreignObject");
+var g = svgElement("g");
+var image = svgElement("image");
+var line = svgElement("line");
+var linearGradient = svgElement("linearGradient");
+var marker = svgElement("marker");
+var mask = svgElement("mask");
+var metadata = svgElement("metadata");
+var mpath = svgElement("mpath");
+var path = svgElement("path");
+var pattern = svgElement("pattern");
+var polygon = svgElement("polygon");
+var polyline = svgElement("polyline");
+var radialGradient = svgElement("radialGradient");
+var rect = svgElement("rect");
+var script = svgElement("script");
+var set = svgElement("set");
+var stop = svgElement("stop");
+var style = svgElement("style");
+var svg = svgElement("svg");
+var cswitch = svgElement("switch");
+var symbol = svgElement("symbol");
+var text = svgElement("text");
+var textPath = svgElement("textPath");
+var title = svgElement("title");
+var tspan = svgElement("tspan");
+var use = svgElement("use");
+var view = svgElement("view");
+//#endregion
+//#region src/DOM/server/serverNodes.ts
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var COMMENT_NODE = 8;
+var ServerNode = class {
+	parentNode;
+	remove() {
+		this.parentNode?.removeChild(this);
+	}
+};
+var CharacterDataNode = class extends ServerNode {
+	data;
+	constructor(data) {
+		super();
+		this.data = data;
+	}
+	get textContent() {
+		return this.data;
+	}
+	set textContent(value) {
+		this.data = String(value);
+	}
+};
+var ServerText = class extends CharacterDataNode {
+	get nodeType() {
+		return TEXT_NODE;
+	}
+};
+var ServerComment = class extends CharacterDataNode {
+	get nodeType() {
+		return COMMENT_NODE;
+	}
+};
+var ServerStyle = class {
+	el;
+	props = /* @__PURE__ */ new Map();
+	constructor(el) {
+		this.el = el;
+	}
+	setProperty(name, value) {
+		if (value == null || value === "") this.props.delete(name);
+		else this.props.set(name, String(value));
+		let text = "";
+		for (const [k, v] of this.props) text += `${text ? " " : ""}${k}: ${v};`;
+		if (text) this.el.attrs.set("style", text);
+		else this.el.attrs.delete("style");
+	}
+};
+var ServerElement = class extends ServerNode {
+	tagName;
+	attrs = /* @__PURE__ */ new Map();
+	childNodes = [];
+	style;
+	html;
+	constructor(tagName) {
+		super();
+		this.tagName = tagName;
+		this.style = new ServerStyle(this);
+	}
+	get nodeType() {
+		return ELEMENT_NODE;
+	}
+	setAttribute(name, value) {
+		this.attrs.set(name, String(value));
+	}
+	removeAttribute(name) {
+		this.attrs.delete(name);
+	}
+	set innerHTML(markup) {
+		this.html = String(markup);
+		this.childNodes.length = 0;
+	}
+	insertBefore(node, ref) {
+		const at = ref ? this.childNodes.indexOf(ref) : -1;
+		if (at < 0) this.childNodes.push(node);
+		else this.childNodes.splice(at, 0, node);
+		if (node instanceof ServerNode) node.parentNode = this;
+		return node;
+	}
+	removeChild(node) {
+		const at = this.childNodes.indexOf(node);
+		if (at >= 0) this.childNodes.splice(at, 1);
+		if (node instanceof ServerNode && node.parentNode === this) node.parentNode = void 0;
+		return node;
+	}
+};
+var serverDocument = {
+	createElement: (tagName) => new ServerElement(tagName),
+	createTextNode: (data) => new ServerText(data),
+	createComment: (data) => new ServerComment(data)
+};
+//#endregion
+//#region src/DOM/server/serialize.ts
+var voidElements;
+var isVoidElement = (tag) => (voidElements ??= /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"source",
+	"track",
+	"wbr"
+])).has(tag);
+var escapeText = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\u00A0/g, "&nbsp;");
+var escapeAttribute = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/\u00A0/g, "&nbsp;");
+var serializeNode = (node, out) => {
+	if (node instanceof ServerElement) {
+		const tag = node.tagName;
+		out.push(`<${tag}`);
+		for (const [name, value] of node.attrs) out.push(` ${name}="${escapeAttribute(value)}"`);
+		out.push(">");
+		if (isVoidElement(tag)) return;
+		serializeContent(node, out);
+		out.push(`</${tag}>`);
+	} else if (node instanceof ServerComment) out.push(`<!--${node.data}-->`);
+	else if (node instanceof ServerText) out.push(escapeText(node.data));
+	else {
+		const real = node;
+		if (real.nodeType === 1) out.push(real.outerHTML);
+		else if (real.nodeType === 8) out.push(`<!--${real.data}-->`);
+		else out.push(escapeText(real.data));
+	}
+};
+var serializeContent = (el, out) => {
+	if (el.html !== void 0) out.push(el.html);
+	else for (const child of el.childNodes) serializeNode(child, out);
+};
+var serializeChildren = (el) => {
+	const out = [];
+	serializeContent(el, out);
+	return out.join("");
+};
+//#endregion
+//#region src/server.ts
+var renderToString = (...children) => {
+	const root = new RootController("", [{
+		mode: "render",
+		doc: serverDocument
+	}, ...children]);
+	flush();
+	return serializeChildren(root.renderedRoot());
+};
+//#endregion
+export { script as $, table as $n, h4 as $t, feMorphology as A, p as An, col as At, image as B, script$1 as Bn, div as Bt, feFuncB as C, nav as Cn, isState as Cr, body as Ct, feImage as D, optgroup as Dn, flush as Dr, caption as Dt, feGaussianBlur as E, ol as En, subscribe as Er, canvas as Et, feTile as F, rp as Fn, dd as Ft, metadata as G, small as Gn, fieldset as Gt, linearGradient as H, section as Hn, dt as Ht, feTurbulence as I, rt as In, del as It, pattern as J, strong as Jn, footer as Jt, mpath as K, source as Kn, figcaption as Kt, filter as L, ruby as Ln, details as Lt, fePointLight as M, pre as Mn, cvar as Mt, feSpecularLighting as N, progress as Nn, data as Nt, feMerge as O, option as On, cite as Ot, feSpotLight as P, q as Pn, datalist as Pt, rect as Q, sup as Qn, h3 as Qt, foreignObject as R, s as Rn, dfn as Rt, feFuncA as S, meter as Sn, findState as Sr, blockquote as St, feFuncR as T, object as Tn, state as Tr, button as Tt, marker as U, select as Un, em as Ut, line as V, search as Vn, dl as Vt, mask as W, slot as Wn, embed as Wt, polyline as X, sub as Xn, h1 as Xt, polygon as Y, style$1 as Yn, form as Yt, radialGradient as Z, summary as Zn, h2 as Zt, feDiffuseLighting as _, main as _n, SnapseRoot as _r, audio as _t, animateTransform as a, hr as an, th as ar, text as at, feDropShadow as b, menu as bn, svgElement as br, bdi as bt, cswitch as c, iframe as cn, title$1 as cr, tspan as ct, ellipse as d, ins as dn, u as dr, a$1 as dt, h5 as en, tbody as er, set as et, feBlend as f, kbd as fn, ul as fr, abbr as ft, feConvolveMatrix as g, link as gn, compute as gr, aside as gt, feComposite as h, li as hn, TrackHistory as hr, article as ht, animateMotion as i, hgroup as in, tfoot as ir, symbol as it, feOffset as j, picture as jn, colgroup as jt, feMergeNode as k, output as kn, code as kt, defs as l, img as ln, tr as lr, use as lt, feComponentTransfer as m, legend as mn, wbr as mr, area as mt, a as n, head as nn, template as nr, style as nt, circle as o, html as on, thead as or, textPath as ot, feColorMatrix as p, label as pn, video as pr, address as pt, path as q, span as qn, figure as qt, animate as r, header as rn, textarea as rr, svg as rt, clipPath as s, i as sn, time as sr, title as st, renderToString as t, h6 as tn, td as tr, stop as tt, desc as u, input as un, track as ur, view as ut, feDisplacementMap as v, map as vn, component as vr, b as vt, feFuncG as w, noscript as wn, peek as wr, br as wt, feFlood as x, meta as xn, CircularDependencyError as xr, bdo as xt, feDistantLight as y, mark as yn, domElement as yr, base as yt, g as z, samp as zn, dialog as zt };
+
+//# sourceMappingURL=snapseCore-DpadpXgD.js.map