snapse 0.0.0-stage → 0.9.0

package/dist/snapseCore-Xfnvf03Z.cjs

@@ -0,0 +1,4135 @@
+//#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
+Object.defineProperty(exports, "CircularDependencyError", {
+	enumerable: true,
+	get: function() {
+		return CircularDependencyError;
+	}
+});
+Object.defineProperty(exports, "SnapseRoot", {
+	enumerable: true,
+	get: function() {
+		return SnapseRoot;
+	}
+});
+Object.defineProperty(exports, "TrackHistory", {
+	enumerable: true,
+	get: function() {
+		return TrackHistory;
+	}
+});
+Object.defineProperty(exports, "a", {
+	enumerable: true,
+	get: function() {
+		return a;
+	}
+});
+Object.defineProperty(exports, "a$1", {
+	enumerable: true,
+	get: function() {
+		return a$1;
+	}
+});
+Object.defineProperty(exports, "abbr", {
+	enumerable: true,
+	get: function() {
+		return abbr;
+	}
+});
+Object.defineProperty(exports, "address", {
+	enumerable: true,
+	get: function() {
+		return address;
+	}
+});
+Object.defineProperty(exports, "animate", {
+	enumerable: true,
+	get: function() {
+		return animate;
+	}
+});
+Object.defineProperty(exports, "animateMotion", {
+	enumerable: true,
+	get: function() {
+		return animateMotion;
+	}
+});
+Object.defineProperty(exports, "animateTransform", {
+	enumerable: true,
+	get: function() {
+		return animateTransform;
+	}
+});
+Object.defineProperty(exports, "area", {
+	enumerable: true,
+	get: function() {
+		return area;
+	}
+});
+Object.defineProperty(exports, "article", {
+	enumerable: true,
+	get: function() {
+		return article;
+	}
+});
+Object.defineProperty(exports, "aside", {
+	enumerable: true,
+	get: function() {
+		return aside;
+	}
+});
+Object.defineProperty(exports, "audio", {
+	enumerable: true,
+	get: function() {
+		return audio;
+	}
+});
+Object.defineProperty(exports, "b", {
+	enumerable: true,
+	get: function() {
+		return b;
+	}
+});
+Object.defineProperty(exports, "base", {
+	enumerable: true,
+	get: function() {
+		return base;
+	}
+});
+Object.defineProperty(exports, "bdi", {
+	enumerable: true,
+	get: function() {
+		return bdi;
+	}
+});
+Object.defineProperty(exports, "bdo", {
+	enumerable: true,
+	get: function() {
+		return bdo;
+	}
+});
+Object.defineProperty(exports, "blockquote", {
+	enumerable: true,
+	get: function() {
+		return blockquote;
+	}
+});
+Object.defineProperty(exports, "body", {
+	enumerable: true,
+	get: function() {
+		return body;
+	}
+});
+Object.defineProperty(exports, "br", {
+	enumerable: true,
+	get: function() {
+		return br;
+	}
+});
+Object.defineProperty(exports, "button", {
+	enumerable: true,
+	get: function() {
+		return button;
+	}
+});
+Object.defineProperty(exports, "canvas", {
+	enumerable: true,
+	get: function() {
+		return canvas;
+	}
+});
+Object.defineProperty(exports, "caption", {
+	enumerable: true,
+	get: function() {
+		return caption;
+	}
+});
+Object.defineProperty(exports, "circle", {
+	enumerable: true,
+	get: function() {
+		return circle;
+	}
+});
+Object.defineProperty(exports, "cite", {
+	enumerable: true,
+	get: function() {
+		return cite;
+	}
+});
+Object.defineProperty(exports, "clipPath", {
+	enumerable: true,
+	get: function() {
+		return clipPath;
+	}
+});
+Object.defineProperty(exports, "code", {
+	enumerable: true,
+	get: function() {
+		return code;
+	}
+});
+Object.defineProperty(exports, "col", {
+	enumerable: true,
+	get: function() {
+		return col;
+	}
+});
+Object.defineProperty(exports, "colgroup", {
+	enumerable: true,
+	get: function() {
+		return colgroup;
+	}
+});
+Object.defineProperty(exports, "component", {
+	enumerable: true,
+	get: function() {
+		return component;
+	}
+});
+Object.defineProperty(exports, "compute", {
+	enumerable: true,
+	get: function() {
+		return compute;
+	}
+});
+Object.defineProperty(exports, "cswitch", {
+	enumerable: true,
+	get: function() {
+		return cswitch;
+	}
+});
+Object.defineProperty(exports, "cvar", {
+	enumerable: true,
+	get: function() {
+		return cvar;
+	}
+});
+Object.defineProperty(exports, "data", {
+	enumerable: true,
+	get: function() {
+		return data;
+	}
+});
+Object.defineProperty(exports, "datalist", {
+	enumerable: true,
+	get: function() {
+		return datalist;
+	}
+});
+Object.defineProperty(exports, "dd", {
+	enumerable: true,
+	get: function() {
+		return dd;
+	}
+});
+Object.defineProperty(exports, "defs", {
+	enumerable: true,
+	get: function() {
+		return defs;
+	}
+});
+Object.defineProperty(exports, "del", {
+	enumerable: true,
+	get: function() {
+		return del;
+	}
+});
+Object.defineProperty(exports, "desc", {
+	enumerable: true,
+	get: function() {
+		return desc;
+	}
+});
+Object.defineProperty(exports, "details", {
+	enumerable: true,
+	get: function() {
+		return details;
+	}
+});
+Object.defineProperty(exports, "dfn", {
+	enumerable: true,
+	get: function() {
+		return dfn;
+	}
+});
+Object.defineProperty(exports, "dialog", {
+	enumerable: true,
+	get: function() {
+		return dialog;
+	}
+});
+Object.defineProperty(exports, "div", {
+	enumerable: true,
+	get: function() {
+		return div;
+	}
+});
+Object.defineProperty(exports, "dl", {
+	enumerable: true,
+	get: function() {
+		return dl;
+	}
+});
+Object.defineProperty(exports, "domElement", {
+	enumerable: true,
+	get: function() {
+		return domElement;
+	}
+});
+Object.defineProperty(exports, "dt", {
+	enumerable: true,
+	get: function() {
+		return dt;
+	}
+});
+Object.defineProperty(exports, "ellipse", {
+	enumerable: true,
+	get: function() {
+		return ellipse;
+	}
+});
+Object.defineProperty(exports, "em", {
+	enumerable: true,
+	get: function() {
+		return em;
+	}
+});
+Object.defineProperty(exports, "embed", {
+	enumerable: true,
+	get: function() {
+		return embed;
+	}
+});
+Object.defineProperty(exports, "feBlend", {
+	enumerable: true,
+	get: function() {
+		return feBlend;
+	}
+});
+Object.defineProperty(exports, "feColorMatrix", {
+	enumerable: true,
+	get: function() {
+		return feColorMatrix;
+	}
+});
+Object.defineProperty(exports, "feComponentTransfer", {
+	enumerable: true,
+	get: function() {
+		return feComponentTransfer;
+	}
+});
+Object.defineProperty(exports, "feComposite", {
+	enumerable: true,
+	get: function() {
+		return feComposite;
+	}
+});
+Object.defineProperty(exports, "feConvolveMatrix", {
+	enumerable: true,
+	get: function() {
+		return feConvolveMatrix;
+	}
+});
+Object.defineProperty(exports, "feDiffuseLighting", {
+	enumerable: true,
+	get: function() {
+		return feDiffuseLighting;
+	}
+});
+Object.defineProperty(exports, "feDisplacementMap", {
+	enumerable: true,
+	get: function() {
+		return feDisplacementMap;
+	}
+});
+Object.defineProperty(exports, "feDistantLight", {
+	enumerable: true,
+	get: function() {
+		return feDistantLight;
+	}
+});
+Object.defineProperty(exports, "feDropShadow", {
+	enumerable: true,
+	get: function() {
+		return feDropShadow;
+	}
+});
+Object.defineProperty(exports, "feFlood", {
+	enumerable: true,
+	get: function() {
+		return feFlood;
+	}
+});
+Object.defineProperty(exports, "feFuncA", {
+	enumerable: true,
+	get: function() {
+		return feFuncA;
+	}
+});
+Object.defineProperty(exports, "feFuncB", {
+	enumerable: true,
+	get: function() {
+		return feFuncB;
+	}
+});
+Object.defineProperty(exports, "feFuncG", {
+	enumerable: true,
+	get: function() {
+		return feFuncG;
+	}
+});
+Object.defineProperty(exports, "feFuncR", {
+	enumerable: true,
+	get: function() {
+		return feFuncR;
+	}
+});
+Object.defineProperty(exports, "feGaussianBlur", {
+	enumerable: true,
+	get: function() {
+		return feGaussianBlur;
+	}
+});
+Object.defineProperty(exports, "feImage", {
+	enumerable: true,
+	get: function() {
+		return feImage;
+	}
+});
+Object.defineProperty(exports, "feMerge", {
+	enumerable: true,
+	get: function() {
+		return feMerge;
+	}
+});
+Object.defineProperty(exports, "feMergeNode", {
+	enumerable: true,
+	get: function() {
+		return feMergeNode;
+	}
+});
+Object.defineProperty(exports, "feMorphology", {
+	enumerable: true,
+	get: function() {
+		return feMorphology;
+	}
+});
+Object.defineProperty(exports, "feOffset", {
+	enumerable: true,
+	get: function() {
+		return feOffset;
+	}
+});
+Object.defineProperty(exports, "fePointLight", {
+	enumerable: true,
+	get: function() {
+		return fePointLight;
+	}
+});
+Object.defineProperty(exports, "feSpecularLighting", {
+	enumerable: true,
+	get: function() {
+		return feSpecularLighting;
+	}
+});
+Object.defineProperty(exports, "feSpotLight", {
+	enumerable: true,
+	get: function() {
+		return feSpotLight;
+	}
+});
+Object.defineProperty(exports, "feTile", {
+	enumerable: true,
+	get: function() {
+		return feTile;
+	}
+});
+Object.defineProperty(exports, "feTurbulence", {
+	enumerable: true,
+	get: function() {
+		return feTurbulence;
+	}
+});
+Object.defineProperty(exports, "fieldset", {
+	enumerable: true,
+	get: function() {
+		return fieldset;
+	}
+});
+Object.defineProperty(exports, "figcaption", {
+	enumerable: true,
+	get: function() {
+		return figcaption;
+	}
+});
+Object.defineProperty(exports, "figure", {
+	enumerable: true,
+	get: function() {
+		return figure;
+	}
+});
+Object.defineProperty(exports, "filter", {
+	enumerable: true,
+	get: function() {
+		return filter;
+	}
+});
+Object.defineProperty(exports, "findState", {
+	enumerable: true,
+	get: function() {
+		return findState;
+	}
+});
+Object.defineProperty(exports, "flush", {
+	enumerable: true,
+	get: function() {
+		return flush;
+	}
+});
+Object.defineProperty(exports, "footer", {
+	enumerable: true,
+	get: function() {
+		return footer;
+	}
+});
+Object.defineProperty(exports, "foreignObject", {
+	enumerable: true,
+	get: function() {
+		return foreignObject;
+	}
+});
+Object.defineProperty(exports, "form", {
+	enumerable: true,
+	get: function() {
+		return form;
+	}
+});
+Object.defineProperty(exports, "g", {
+	enumerable: true,
+	get: function() {
+		return g;
+	}
+});
+Object.defineProperty(exports, "h1", {
+	enumerable: true,
+	get: function() {
+		return h1;
+	}
+});
+Object.defineProperty(exports, "h2", {
+	enumerable: true,
+	get: function() {
+		return h2;
+	}
+});
+Object.defineProperty(exports, "h3", {
+	enumerable: true,
+	get: function() {
+		return h3;
+	}
+});
+Object.defineProperty(exports, "h4", {
+	enumerable: true,
+	get: function() {
+		return h4;
+	}
+});
+Object.defineProperty(exports, "h5", {
+	enumerable: true,
+	get: function() {
+		return h5;
+	}
+});
+Object.defineProperty(exports, "h6", {
+	enumerable: true,
+	get: function() {
+		return h6;
+	}
+});
+Object.defineProperty(exports, "head", {
+	enumerable: true,
+	get: function() {
+		return head;
+	}
+});
+Object.defineProperty(exports, "header", {
+	enumerable: true,
+	get: function() {
+		return header;
+	}
+});
+Object.defineProperty(exports, "hgroup", {
+	enumerable: true,
+	get: function() {
+		return hgroup;
+	}
+});
+Object.defineProperty(exports, "hr", {
+	enumerable: true,
+	get: function() {
+		return hr;
+	}
+});
+Object.defineProperty(exports, "html", {
+	enumerable: true,
+	get: function() {
+		return html;
+	}
+});
+Object.defineProperty(exports, "i", {
+	enumerable: true,
+	get: function() {
+		return i;
+	}
+});
+Object.defineProperty(exports, "iframe", {
+	enumerable: true,
+	get: function() {
+		return iframe;
+	}
+});
+Object.defineProperty(exports, "image", {
+	enumerable: true,
+	get: function() {
+		return image;
+	}
+});
+Object.defineProperty(exports, "img", {
+	enumerable: true,
+	get: function() {
+		return img;
+	}
+});
+Object.defineProperty(exports, "input", {
+	enumerable: true,
+	get: function() {
+		return input;
+	}
+});
+Object.defineProperty(exports, "ins", {
+	enumerable: true,
+	get: function() {
+		return ins;
+	}
+});
+Object.defineProperty(exports, "isState", {
+	enumerable: true,
+	get: function() {
+		return isState;
+	}
+});
+Object.defineProperty(exports, "kbd", {
+	enumerable: true,
+	get: function() {
+		return kbd;
+	}
+});
+Object.defineProperty(exports, "label", {
+	enumerable: true,
+	get: function() {
+		return label;
+	}
+});
+Object.defineProperty(exports, "legend", {
+	enumerable: true,
+	get: function() {
+		return legend;
+	}
+});
+Object.defineProperty(exports, "li", {
+	enumerable: true,
+	get: function() {
+		return li;
+	}
+});
+Object.defineProperty(exports, "line", {
+	enumerable: true,
+	get: function() {
+		return line;
+	}
+});
+Object.defineProperty(exports, "linearGradient", {
+	enumerable: true,
+	get: function() {
+		return linearGradient;
+	}
+});
+Object.defineProperty(exports, "link", {
+	enumerable: true,
+	get: function() {
+		return link;
+	}
+});
+Object.defineProperty(exports, "main", {
+	enumerable: true,
+	get: function() {
+		return main;
+	}
+});
+Object.defineProperty(exports, "map", {
+	enumerable: true,
+	get: function() {
+		return map;
+	}
+});
+Object.defineProperty(exports, "mark", {
+	enumerable: true,
+	get: function() {
+		return mark;
+	}
+});
+Object.defineProperty(exports, "marker", {
+	enumerable: true,
+	get: function() {
+		return marker;
+	}
+});
+Object.defineProperty(exports, "mask", {
+	enumerable: true,
+	get: function() {
+		return mask;
+	}
+});
+Object.defineProperty(exports, "menu", {
+	enumerable: true,
+	get: function() {
+		return menu;
+	}
+});
+Object.defineProperty(exports, "meta", {
+	enumerable: true,
+	get: function() {
+		return meta;
+	}
+});
+Object.defineProperty(exports, "metadata", {
+	enumerable: true,
+	get: function() {
+		return metadata;
+	}
+});
+Object.defineProperty(exports, "meter", {
+	enumerable: true,
+	get: function() {
+		return meter;
+	}
+});
+Object.defineProperty(exports, "mpath", {
+	enumerable: true,
+	get: function() {
+		return mpath;
+	}
+});
+Object.defineProperty(exports, "nav", {
+	enumerable: true,
+	get: function() {
+		return nav;
+	}
+});
+Object.defineProperty(exports, "noscript", {
+	enumerable: true,
+	get: function() {
+		return noscript;
+	}
+});
+Object.defineProperty(exports, "object", {
+	enumerable: true,
+	get: function() {
+		return object;
+	}
+});
+Object.defineProperty(exports, "ol", {
+	enumerable: true,
+	get: function() {
+		return ol;
+	}
+});
+Object.defineProperty(exports, "optgroup", {
+	enumerable: true,
+	get: function() {
+		return optgroup;
+	}
+});
+Object.defineProperty(exports, "option", {
+	enumerable: true,
+	get: function() {
+		return option;
+	}
+});
+Object.defineProperty(exports, "output", {
+	enumerable: true,
+	get: function() {
+		return output;
+	}
+});
+Object.defineProperty(exports, "p", {
+	enumerable: true,
+	get: function() {
+		return p;
+	}
+});
+Object.defineProperty(exports, "path", {
+	enumerable: true,
+	get: function() {
+		return path;
+	}
+});
+Object.defineProperty(exports, "pattern", {
+	enumerable: true,
+	get: function() {
+		return pattern;
+	}
+});
+Object.defineProperty(exports, "peek", {
+	enumerable: true,
+	get: function() {
+		return peek;
+	}
+});
+Object.defineProperty(exports, "picture", {
+	enumerable: true,
+	get: function() {
+		return picture;
+	}
+});
+Object.defineProperty(exports, "polygon", {
+	enumerable: true,
+	get: function() {
+		return polygon;
+	}
+});
+Object.defineProperty(exports, "polyline", {
+	enumerable: true,
+	get: function() {
+		return polyline;
+	}
+});
+Object.defineProperty(exports, "pre", {
+	enumerable: true,
+	get: function() {
+		return pre;
+	}
+});
+Object.defineProperty(exports, "progress", {
+	enumerable: true,
+	get: function() {
+		return progress;
+	}
+});
+Object.defineProperty(exports, "q", {
+	enumerable: true,
+	get: function() {
+		return q;
+	}
+});
+Object.defineProperty(exports, "radialGradient", {
+	enumerable: true,
+	get: function() {
+		return radialGradient;
+	}
+});
+Object.defineProperty(exports, "rect", {
+	enumerable: true,
+	get: function() {
+		return rect;
+	}
+});
+Object.defineProperty(exports, "renderToString", {
+	enumerable: true,
+	get: function() {
+		return renderToString;
+	}
+});
+Object.defineProperty(exports, "rp", {
+	enumerable: true,
+	get: function() {
+		return rp;
+	}
+});
+Object.defineProperty(exports, "rt", {
+	enumerable: true,
+	get: function() {
+		return rt;
+	}
+});
+Object.defineProperty(exports, "ruby", {
+	enumerable: true,
+	get: function() {
+		return ruby;
+	}
+});
+Object.defineProperty(exports, "s", {
+	enumerable: true,
+	get: function() {
+		return s;
+	}
+});
+Object.defineProperty(exports, "samp", {
+	enumerable: true,
+	get: function() {
+		return samp;
+	}
+});
+Object.defineProperty(exports, "script", {
+	enumerable: true,
+	get: function() {
+		return script;
+	}
+});
+Object.defineProperty(exports, "script$1", {
+	enumerable: true,
+	get: function() {
+		return script$1;
+	}
+});
+Object.defineProperty(exports, "search", {
+	enumerable: true,
+	get: function() {
+		return search;
+	}
+});
+Object.defineProperty(exports, "section", {
+	enumerable: true,
+	get: function() {
+		return section;
+	}
+});
+Object.defineProperty(exports, "select", {
+	enumerable: true,
+	get: function() {
+		return select;
+	}
+});
+Object.defineProperty(exports, "set", {
+	enumerable: true,
+	get: function() {
+		return set;
+	}
+});
+Object.defineProperty(exports, "slot", {
+	enumerable: true,
+	get: function() {
+		return slot;
+	}
+});
+Object.defineProperty(exports, "small", {
+	enumerable: true,
+	get: function() {
+		return small;
+	}
+});
+Object.defineProperty(exports, "source", {
+	enumerable: true,
+	get: function() {
+		return source;
+	}
+});
+Object.defineProperty(exports, "span", {
+	enumerable: true,
+	get: function() {
+		return span;
+	}
+});
+Object.defineProperty(exports, "state", {
+	enumerable: true,
+	get: function() {
+		return state;
+	}
+});
+Object.defineProperty(exports, "stop", {
+	enumerable: true,
+	get: function() {
+		return stop;
+	}
+});
+Object.defineProperty(exports, "strong", {
+	enumerable: true,
+	get: function() {
+		return strong;
+	}
+});
+Object.defineProperty(exports, "style", {
+	enumerable: true,
+	get: function() {
+		return style;
+	}
+});
+Object.defineProperty(exports, "style$1", {
+	enumerable: true,
+	get: function() {
+		return style$1;
+	}
+});
+Object.defineProperty(exports, "sub", {
+	enumerable: true,
+	get: function() {
+		return sub;
+	}
+});
+Object.defineProperty(exports, "subscribe", {
+	enumerable: true,
+	get: function() {
+		return subscribe;
+	}
+});
+Object.defineProperty(exports, "summary", {
+	enumerable: true,
+	get: function() {
+		return summary;
+	}
+});
+Object.defineProperty(exports, "sup", {
+	enumerable: true,
+	get: function() {
+		return sup;
+	}
+});
+Object.defineProperty(exports, "svg", {
+	enumerable: true,
+	get: function() {
+		return svg;
+	}
+});
+Object.defineProperty(exports, "svgElement", {
+	enumerable: true,
+	get: function() {
+		return svgElement;
+	}
+});
+Object.defineProperty(exports, "symbol", {
+	enumerable: true,
+	get: function() {
+		return symbol;
+	}
+});
+Object.defineProperty(exports, "table", {
+	enumerable: true,
+	get: function() {
+		return table;
+	}
+});
+Object.defineProperty(exports, "tbody", {
+	enumerable: true,
+	get: function() {
+		return tbody;
+	}
+});
+Object.defineProperty(exports, "td", {
+	enumerable: true,
+	get: function() {
+		return td;
+	}
+});
+Object.defineProperty(exports, "template", {
+	enumerable: true,
+	get: function() {
+		return template;
+	}
+});
+Object.defineProperty(exports, "text", {
+	enumerable: true,
+	get: function() {
+		return text;
+	}
+});
+Object.defineProperty(exports, "textPath", {
+	enumerable: true,
+	get: function() {
+		return textPath;
+	}
+});
+Object.defineProperty(exports, "textarea", {
+	enumerable: true,
+	get: function() {
+		return textarea;
+	}
+});
+Object.defineProperty(exports, "tfoot", {
+	enumerable: true,
+	get: function() {
+		return tfoot;
+	}
+});
+Object.defineProperty(exports, "th", {
+	enumerable: true,
+	get: function() {
+		return th;
+	}
+});
+Object.defineProperty(exports, "thead", {
+	enumerable: true,
+	get: function() {
+		return thead;
+	}
+});
+Object.defineProperty(exports, "time", {
+	enumerable: true,
+	get: function() {
+		return time;
+	}
+});
+Object.defineProperty(exports, "title", {
+	enumerable: true,
+	get: function() {
+		return title;
+	}
+});
+Object.defineProperty(exports, "title$1", {
+	enumerable: true,
+	get: function() {
+		return title$1;
+	}
+});
+Object.defineProperty(exports, "tr", {
+	enumerable: true,
+	get: function() {
+		return tr;
+	}
+});
+Object.defineProperty(exports, "track", {
+	enumerable: true,
+	get: function() {
+		return track;
+	}
+});
+Object.defineProperty(exports, "tspan", {
+	enumerable: true,
+	get: function() {
+		return tspan;
+	}
+});
+Object.defineProperty(exports, "u", {
+	enumerable: true,
+	get: function() {
+		return u;
+	}
+});
+Object.defineProperty(exports, "ul", {
+	enumerable: true,
+	get: function() {
+		return ul;
+	}
+});
+Object.defineProperty(exports, "use", {
+	enumerable: true,
+	get: function() {
+		return use;
+	}
+});
+Object.defineProperty(exports, "video", {
+	enumerable: true,
+	get: function() {
+		return video;
+	}
+});
+Object.defineProperty(exports, "view", {
+	enumerable: true,
+	get: function() {
+		return view;
+	}
+});
+Object.defineProperty(exports, "wbr", {
+	enumerable: true,
+	get: function() {
+		return wbr;
+	}
+});
+
+//# sourceMappingURL=snapseCore-Xfnvf03Z.cjs.map