@expressive/dom 0.0.0

package/dist/index.js

@@ -0,0 +1,1664 @@
+import { a as vnode, i as isVNode, n as childrenOf, r as createPortal, t as PORTAL } from "./chunk-vnode-DA7cLTKP.js";
+import "./jsx-runtime.js";
+import { Component, Context, State, has, map, pending, unbind } from "@expressive/mvc";
+import { watch } from "@expressive/mvc/observable";
+import { Fragment } from "@expressive/mvc/runtime";
+
+//#region src/scheduler.ts
+const urgent = /* @__PURE__ */ new Set();
+const passive = /* @__PURE__ */ new Set();
+const after = [];
+let depth$1 = 0;
+let urgentQueued = false;
+let passiveQueued = false;
+function flush(scopes) {
+	for (const scope of scopes) {
+		scopes.delete(scope);
+		scope.queued = void 0;
+		let waiting = void 0;
+		try {
+			waiting = scope.update(false);
+		} catch (error) {
+			console.error(error);
+		}
+		settle$1(scope);
+		if (!waiting) unblock(scope);
+	}
+}
+function flushUrgent() {
+	urgentQueued = false;
+	flush(urgent);
+	for (const run of after.splice(0)) run();
+}
+function afterFlush(run) {
+	after.push(run);
+	if (!urgentQueued) {
+		urgentQueued = true;
+		queueMicrotask(flushUrgent);
+	}
+}
+function flushPassive() {
+	passiveQueued = false;
+	const batch = [...passive].filter((scope) => scope.queued === "passive");
+	passive.clear();
+	for (const scope of batch) {
+		const waiting = scope.probe?.();
+		if (waiting) return defer(batch, waiting, scope);
+	}
+	batch.sort((a, b) => Number(!!b.empty?.()) - Number(!!a.empty?.()));
+	for (let index = 0; index < batch.length; index++) {
+		const scope = batch[index];
+		if (scope.queued !== "passive") continue;
+		scope.queued = void 0;
+		let waiting = void 0;
+		try {
+			waiting = scope.update(true);
+		} catch (error) {
+			console.error(error);
+		}
+		settle$1(scope);
+		if (waiting) return defer(batch.slice(index + 1), waiting, scope);
+		unblock(scope);
+	}
+}
+function defer(scopes, waiting, source) {
+	const held = scopes.filter((scope) => scope.queued === "passive");
+	for (const scope of held) {
+		scope.queued = "deferred";
+		scope.probed = void 0;
+	}
+	const resume = () => {
+		for (const scope of held) if (scope.queued === "deferred") {
+			scope.queued = void 0;
+			transition(() => schedule(scope));
+		}
+	};
+	(source.blocking ||= []).push(resume);
+	waiting.then(resume, resume);
+}
+function unblock(scope) {
+	const { blocking } = scope;
+	scope.blocking = void 0;
+	blocking?.forEach((resume) => resume());
+}
+function release(holds) {
+	holds?.forEach((held) => held());
+}
+function settle$1(scope) {
+	const { holds } = scope;
+	scope.holds = void 0;
+	release(holds);
+}
+function schedule(scope) {
+	const held = pending();
+	if (held) (scope.holds ||= []).push(held);
+	scope.probed = void 0;
+	if (!depth$1) {
+		passive.delete(scope);
+		scope.queued = "urgent";
+		urgent.add(scope);
+		if (!urgentQueued) {
+			urgentQueued = true;
+			queueMicrotask(flushUrgent);
+		}
+		return;
+	}
+	if (scope.queued && scope.queued !== "deferred") return;
+	scope.queued = "passive";
+	passive.add(scope);
+	if (!passiveQueued) {
+		passiveQueued = true;
+		setTimeout(flushPassive);
+	}
+}
+function transition(work) {
+	depth$1++;
+	try {
+		work();
+	} finally {
+		depth$1--;
+	}
+}
+function claim$1(scope) {
+	urgent.delete(scope);
+	passive.delete(scope);
+	scope.queued = void 0;
+	scope.probed = void 0;
+}
+function unschedule(scope) {
+	urgent.delete(scope);
+	passive.delete(scope);
+	scope.queued = void 0;
+	scope.probed = void 0;
+	settle$1(scope);
+	unblock(scope);
+}
+
+//#endregion
+//#region src/adapter.ts
+let current;
+let collecting;
+function enter(scope, render) {
+	const parent = current;
+	const releases = collecting;
+	const next = [];
+	current = scope;
+	collecting = next;
+	scope.childContext = scope.context;
+	scope.useIndex = 0;
+	try {
+		const output = render();
+		if (scope.kind == "function" && scope.useIndex !== scope.uses.length) throw new Error("State.use() calls must keep the same order on every function-component render.");
+		return output;
+	} finally {
+		current = parent;
+		collecting = releases;
+		scope.subscriptions.forEach((release) => release());
+		scope.subscriptions = next;
+	}
+}
+function dispose(scope) {
+	scope.active = false;
+	unschedule(scope);
+	scope.subscriptions.forEach((release) => release());
+	scope.subscriptions = [];
+	for (let i = scope.uses.length - 1; i >= 0; i--) {
+		const slot = scope.uses[i];
+		slot.release();
+		if (typeof slot.cleanup == "function") slot.cleanup();
+		slot.context.pop();
+		slot.instance.set(null);
+	}
+	scope.uses = [];
+}
+function commit(scope) {
+	for (const slot of scope.uses) if (!slot.mounted) {
+		slot.mounted = true;
+		slot.cleanup = slot.instance.mount?.();
+	}
+}
+function requireScope() {
+	if (!current) throw new Error("State.get() and State.use() may only run while @expressive/dom is rendering.");
+	return current;
+}
+function tracked(target, required) {
+	const scope = requireScope();
+	let proxy = target;
+	let first = true;
+	const release = watch(target, (next) => {
+		proxy = next;
+		if (!first && scope.active) schedule(scope);
+		first = false;
+	}, required, transition);
+	collecting.push(release);
+	return proxy;
+}
+State.get = function get(argument) {
+	const scope = requireScope();
+	const instance = scope.childContext.get(this, argument === false ? false : true);
+	if (!instance) return void 0;
+	const proxy = tracked(instance, argument === true);
+	if (typeof argument != "function") return proxy;
+	const refresh = ((action) => {
+		if (typeof action == "function") action = action();
+		schedule(scope);
+		return action instanceof Promise ? action.finally(() => schedule(scope)) : void 0;
+	});
+	return argument.call(proxy, proxy, refresh) ?? null;
+};
+State.use = function use(...args) {
+	const scope = requireScope();
+	if (scope.kind != "function") throw new Error("State.use() is only available at the top level of a function component.");
+	const index = scope.useIndex++;
+	let slot = scope.uses[index];
+	if (slot && slot.Type !== this) throw new Error("State.use() calls must keep the same order on every function-component render.");
+	if (!slot) {
+		let instance;
+		const assign = (value) => typeof value == "object" && value && instance.set(value);
+		let apply = (...values) => Promise.all(values.flat().map(assign));
+		instance = new this((self) => {
+			const own = self;
+			if (typeof own.use == "function") {
+				apply = own.use.bind(own);
+				apply(...args);
+				return;
+			}
+			return args;
+		});
+		const context = scope.childContext.push(instance);
+		slot = {
+			Type: this,
+			context,
+			instance,
+			proxy: instance,
+			release: void 0,
+			apply
+		};
+		let first = true;
+		slot.release = watch(instance, (proxy) => {
+			slot.proxy = proxy;
+			if (!first && scope.active) schedule(scope);
+			first = false;
+		}, void 0, transition);
+		slot.apply = apply;
+		scope.uses.push(slot);
+	} else slot.apply(...args);
+	scope.childContext = slot.context;
+	return slot.proxy;
+};
+Object.defineProperty(Component, "use", {
+	configurable: true,
+	value() {
+		throw new Error(`${this} is a Component - render it instead of calling use().`);
+	}
+});
+Component.on({
+	type(type) {
+		subcomponents(type.prototype);
+	},
+	before(self) {
+		subcomponents(self, true);
+	}
+});
+function subcomponents(target, configurable) {
+	for (const key of Object.getOwnPropertyNames(target)) {
+		if (!/^[A-Z]/.test(key)) continue;
+		const { value } = Object.getOwnPropertyDescriptor(target, key);
+		if (typeof value != "function") continue;
+		Object.defineProperty(target, key, {
+			configurable,
+			get() {
+				const owner = this.is;
+				let render = unbind(value);
+				const Subcomponent = (props) => render.call(tracked(owner), props);
+				Object.defineProperty(owner, key, {
+					configurable: true,
+					get: () => Subcomponent,
+					set(next) {
+						render = next;
+					}
+				});
+				return Subcomponent;
+			},
+			set(next) {
+				Object.defineProperty(this, key, {
+					value: next,
+					writable: true,
+					enumerable: true,
+					configurable: true
+				});
+				subcomponents(this, true);
+			}
+		});
+	}
+}
+
+//#endregion
+//#region src/context.ts
+function Consumer(props) {
+	return props.for.get((value) => props.children(value));
+}
+function Provider(_props) {
+	throw new Error("Provider must be rendered by @expressive/dom.");
+}
+function provide(context, props) {
+	const { for: input, is, children: _children, fallback: _fallback, name: _name, ...rest } = props;
+	const mount = [];
+	let single;
+	const solo = State.is(input) || input instanceof State;
+	context.set(input || {}, (state, owned) => {
+		if (solo) single = state;
+		is?.(state);
+		if (owned) {
+			let cleanup;
+			mount.push(() => {
+				cleanup = state.mount?.();
+			});
+			return () => cleanup?.();
+		}
+	});
+	if (solo && !single) {
+		const Type = input instanceof State ? input.constructor : input;
+		single = context.get(Type, false);
+	}
+	if (single && Object.keys(rest).length) single.set(rest);
+	return () => mount.forEach((commit) => commit());
+}
+
+//#endregion
+//#region src/lazy.ts
+function lazy(load) {
+	let pending;
+	let resolved;
+	let rejected;
+	let failed = false;
+	return function Lazy(props) {
+		if (failed) throw rejected;
+		if (resolved) return vnode(resolved, props);
+		if (!pending) pending = load().then((module) => {
+			const output = typeof module == "function" ? module : module?.default;
+			if (typeof output != "function") {
+				failed = true;
+				rejected = /* @__PURE__ */ new Error("lazy() loader resolved no component.");
+				return;
+			}
+			resolved = output;
+		}, (error) => {
+			failed = true;
+			rejected = error;
+		});
+		throw pending;
+	};
+}
+
+//#endregion
+//#region src/css.ts
+const unitless = /* @__PURE__ */ new Map();
+let probe;
+/**
+* Does the CSSOM accept a bare number for this property? Probed once with a
+* canonical value; the answer is a property of CSS, not of the value.
+*/
+function bare(property) {
+	let known = unitless.get(property);
+	if (known === void 0) {
+		probe ||= document.createElement("div").style;
+		probe[property] = "";
+		probe[property] = 1;
+		unitless.set(property, known = Boolean(probe[property]));
+	}
+	return known;
+}
+function sized(property, value) {
+	if (Array.isArray(value)) return value.map((entry) => sized(property, entry));
+	return typeof value == "number" && value !== 0 && !bare(property) ? `${value}px` : value;
+}
+/**
+* Web macro pack. Register with `macro(css)` to opt into pixel units for
+* numbers and the axis shorthands CSS itself does not provide.
+*/
+const css = {
+	"*": (value, key) => ({ [key]: sized(key, value) }),
+	mx: (value) => ({
+		marginLeft: value,
+		marginRight: value
+	}),
+	my: (value) => ({
+		marginTop: value,
+		marginBottom: value
+	}),
+	px: (value) => ({
+		paddingLeft: value,
+		paddingRight: value
+	}),
+	py: (value) => ({
+		paddingTop: value,
+		paddingBottom: value
+	}),
+	size: (value) => Array.isArray(value) ? {
+		width: value[0],
+		height: value[1]
+	} : {
+		width: value,
+		height: value
+	}
+};
+
+//#endregion
+//#region src/appearance-protocol.ts
+const registrations = /* @__PURE__ */ new WeakMap();
+const tokens = /* @__PURE__ */ new WeakMap();
+let root;
+let emitter;
+let rendered = false;
+function registerAppearance(type, enter) {
+	registrations.set(type, enter);
+}
+function registerAppearanceRoot(factory) {
+	root = factory;
+}
+function registerEmitter(emit) {
+	emitter = emit;
+}
+function emitClass(block, depth, document) {
+	return emitter(block, depth, document);
+}
+function appearanceRoot() {
+	rendered = true;
+	return root?.();
+}
+/** Has anything rendered yet - global registration is closed after it has. */
+function appearanceSealed() {
+	return rendered;
+}
+function enterAppearance(parent, type) {
+	const chain = [];
+	let current = type;
+	while (current && current !== Function.prototype) {
+		const enter = registrations.get(current);
+		if (enter) chain.unshift(enter);
+		current = Object.getPrototypeOf(current);
+	}
+	for (const enter of chain) parent = enter(parent);
+	return parent;
+}
+function createAppearanceToken(appearance) {
+	const token = {};
+	tokens.set(token, appearance);
+	return token;
+}
+function appearanceToken(value) {
+	return value && typeof value == "object" ? tokens.get(value) : void 0;
+}
+
+//#endregion
+//#region src/appearance.ts
+const bases = /* @__PURE__ */ new WeakMap();
+const chains = /* @__PURE__ */ new WeakMap();
+const contexts = /* @__PURE__ */ new WeakMap();
+const rootScopes = /* @__PURE__ */ new WeakMap();
+const styles = /* @__PURE__ */ new WeakMap();
+const entered = /* @__PURE__ */ new WeakSet();
+const globals = [];
+let globalContext;
+function createStyleScope(parent, value, label, defines) {
+	if (!isObject(value)) return parent;
+	const cache = parent?.children || rootScopes;
+	const cached = cache.get(value);
+	if (cached) return cached;
+	const own = [];
+	const source = {};
+	const base = {};
+	for (const key of Object.keys(value)) {
+		const entry = value[key];
+		if (key[0] == "$") throw new Error(`Reserved key "${key}" in style map.`);
+		if (key[0] == "_") {
+			if (!isObject(entry)) throw new Error(`Rule "${key}" must be an object. Macros are defined by macro().`);
+			const name = key.slice(1);
+			own.push(name);
+			source[name] = entry;
+		} else if (defines && typeof entry == "function") {
+			own.push(key);
+			source[key] = entry;
+		} else base[key] = entry;
+	}
+	const names = parent ? [...parent.names, ...own.filter((name) => !parent.names.includes(name))] : own;
+	const rules = Object.create(parent?.rules || null);
+	const labels = Object.create(parent?.labels || null);
+	const scopeLabel = label || parent?.label || "style";
+	for (const name of own) {
+		const rule = source[name];
+		const inherited = parent?.rules[name];
+		rules[name] = isObject(inherited) && isObject(rule) ? {
+			...inherited,
+			...rule
+		} : rule;
+		labels[name] = scopeLabel;
+	}
+	const scope = {
+		children: /* @__PURE__ */ new WeakMap(),
+		expansions: /* @__PURE__ */ new Map(),
+		label: scopeLabel,
+		labels,
+		names,
+		own: base,
+		routes: /* @__PURE__ */ new Map(),
+		rules
+	};
+	cache.set(value, scope);
+	return scope;
+}
+function createContext(scope) {
+	const cached = contexts.get(scope);
+	if (cached) return cached;
+	const context = {
+		scope,
+		base: baseToken(scope),
+		resolve(props, tag) {
+			return resolveAppearance(scope, props, tag);
+		}
+	};
+	contexts.set(scope, context);
+	return context;
+}
+function extendContext(parent, maps, label, defines) {
+	let scope = parent?.scope;
+	const base = { ...scope && bases.get(scope) };
+	for (const map of maps) {
+		scope = createStyleScope(scope, map, label, defines);
+		Object.assign(base, scope.own);
+	}
+	if (Object.keys(base).length) bases.set(scope, base);
+	return createContext(scope);
+}
+function baseToken(scope) {
+	const base = bases.get(scope);
+	if (!base) return void 0;
+	const expansion = expand(scope, base, /* @__PURE__ */ new Map());
+	const appearance = {};
+	if (Object.keys(expansion.declarations).length) appearance.blocks = [{
+		declarations: expansion.declarations,
+		name: scope.label,
+		ordinal: -1
+	}];
+	if (expansion.classes.length) appearance.classes = expansion.classes;
+	return createAppearanceToken(appearance);
+}
+function style$1(type, rules) {
+	if (entered.has(type)) throw new Error("Cannot add styles after a component has rendered.");
+	const maps = styles.get(type);
+	if (maps) maps.push(rules);
+	else {
+		const label = type.displayName || type.name;
+		styles.set(type, [rules]);
+		registerAppearance(type, (parent) => {
+			entered.add(type);
+			return extendContext(parent, styles.get(type), label);
+		});
+	}
+	return type;
+}
+function macro$1(rules) {
+	for (const key of Object.keys(rules)) if (key[0] != "_" && key[0] != "$" && typeof rules[key] != "function") throw new Error(`Macro "${key}" must be a function. Use "_${key}" to register a rule.`);
+	if (appearanceSealed()) throw new Error("Cannot add macros after rendering has started.");
+	globals.push(rules);
+	globalContext = void 0;
+	registerAppearanceRoot(() => globalContext ||= extendContext(void 0, globals, "global", true));
+	return rules;
+}
+function createAppearanceRoute(scope, props, tag) {
+	if (!scope) return void 0;
+	const keys = Object.keys(props).filter((key) => key.startsWith("_")).sort();
+	const id = `${tag || ""}\0${keys.join("\0")}`;
+	const cached = scope.routes.get(id);
+	if (cached) return cached;
+	const present = new Set(keys.map((key) => key.slice(1)));
+	const flags = [];
+	for (const name of scope.names) {
+		if (!present.has(name) || name == tag) continue;
+		if (isObject(scope.rules[name])) flags.push(name);
+	}
+	const route = {
+		flags,
+		scope,
+		tag: tag && isObject(scope.rules[tag]) ? tag : void 0
+	};
+	scope.routes.set(id, route);
+	return route;
+}
+function resolveAppearance(scope, props, tag) {
+	const route = createAppearanceRoute(scope, props, tag);
+	if (!route) return void 0;
+	const parts = [];
+	const names = route.tag ? [route.tag] : [];
+	for (const name of route.flags) if (props[`_${name}`]) names.push(name);
+	for (const name of names) parts.push(expandRule(route.scope, name));
+	const blocks = parts.flatMap((part) => part.block ? [part.block] : []);
+	const classes = parts.flatMap((part) => part.classes);
+	let child = route.scope;
+	for (const part of parts) for (const nested of part.nested) child = createStyleScope(child, nested, tag ? `${route.scope.label}_${tag}` : route.scope.label);
+	if (!blocks.length && !classes.length && child === route.scope) return void 0;
+	const appearance = {};
+	if (blocks.length) appearance.blocks = blocks;
+	if (classes.length) appearance.classes = classes;
+	if (child !== route.scope) appearance.context = createContext(child);
+	return appearance;
+}
+function expandRule(scope, name) {
+	let expansion = scope.expansions.get(name);
+	if (!expansion) {
+		expansion = expand(scope, scope.rules[name], /* @__PURE__ */ new Map());
+		if (Object.keys(expansion.declarations).length) expansion.block = {
+			declarations: expansion.declarations,
+			name: `${scope.labels[name]}_${name}`,
+			ordinal: scope.names.indexOf(name)
+		};
+		scope.expansions.set(name, expansion);
+	}
+	return expansion;
+}
+function handlers(scope, name) {
+	let known = chains.get(scope);
+	if (!known) chains.set(scope, known = /* @__PURE__ */ new Map());
+	let chain = known.get(name);
+	if (!chain) {
+		chain = [];
+		for (const key of [name, "*"]) for (let rules = scope.rules; rules; rules = Object.getPrototypeOf(rules)) {
+			const own = Object.getOwnPropertyDescriptor(rules, key);
+			if (own && typeof own.value == "function") chain.push(own.value);
+		}
+		known.set(name, chain);
+	}
+	return chain;
+}
+function expand(scope, value, depths) {
+	const output = {
+		classes: [],
+		declarations: {},
+		nested: []
+	};
+	const nested = {};
+	function walk(value, depths) {
+		if (!value) return;
+		if (typeof value == "string") {
+			output.classes.push(...value.split(/\s+/).filter(Boolean));
+			return;
+		}
+		if (Array.isArray(value)) {
+			value.forEach((entry) => walk(entry, depths));
+			return;
+		}
+		for (const [name, entry] of Object.entries(value)) {
+			if (name[0] == "_") {
+				if (isObject(entry)) nested[name] = entry;
+				continue;
+			}
+			const chain = handlers(scope, name);
+			const depth = depths.get(name) || 0;
+			if (depth < chain.length) {
+				if (isPresent(entry)) walk(chain[depth](entry === true ? void 0 : entry, name), new Map(depths).set(name, depth + 1));
+			} else output.declarations[name] = terminal(name, entry);
+		}
+	}
+	walk(value, depths);
+	if (Object.keys(nested).length) output.nested.push(nested);
+	return output;
+}
+function terminal(name, value) {
+	if (Array.isArray(value)) return value.join(" ");
+	if (typeof value == "function" || isObject(value)) throw new Error(`No macro handles "${name}".`);
+	return typeof value == "number" ? String(value) : value;
+}
+function isPresent(value) {
+	return value !== false && value !== null && value !== void 0;
+}
+function isObject(value) {
+	return !!value && typeof value == "object" && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/declarations.ts
+function applyDeclarations(style, declarations, previous = {}) {
+	const target = style;
+	for (const key of Object.keys({
+		...previous,
+		...declarations
+	})) {
+		const value = declarations[key];
+		if (key.startsWith("--")) {
+			style.setProperty(key, value == null ? "" : String(value));
+			continue;
+		}
+		if (typeof value == "number") target[key] = "";
+		target[key] = value == null ? "" : value;
+		if (typeof value == "number" && value !== 0 && !target[key]) target[key] = `${value}px`;
+	}
+}
+
+//#endregion
+//#region src/stylesheet.ts
+const sheets = /* @__PURE__ */ new WeakMap();
+function style(type, rules) {
+	style$1(type, rules);
+	registerEmitter(emit);
+	return type;
+}
+function macro(rules) {
+	macro$1(rules);
+	registerEmitter(emit);
+	return rules;
+}
+function emit(block, depth, document) {
+	let sheet = sheets.get(document);
+	if (!sheet?.element.sheet) {
+		const element = document.createElement("style");
+		element.dataset.expressive = "dom";
+		document.head.append(element);
+		sheet = {
+			element,
+			emitted: /* @__PURE__ */ new WeakMap(),
+			names: /* @__PURE__ */ new Map(),
+			positions: []
+		};
+		sheets.set(document, sheet);
+	}
+	let byDepth = sheet.emitted.get(block);
+	if (!byDepth) sheet.emitted.set(block, byDepth = /* @__PURE__ */ new Map());
+	const cached = byDepth.get(depth);
+	if (cached) return cached;
+	const css = serialize(document, block.declarations);
+	const base = (depth ? `${block.name}-d${depth}` : block.name).replace(/[^\w-]/g, "_");
+	let name = base;
+	for (let index = 2; sheet.names.has(name) && sheet.names.get(name) !== css; index++) name = `${base}-${index}`;
+	if (!sheet.names.has(name)) {
+		const { positions } = sheet;
+		let at = positions.findIndex(([d, o]) => d > depth || d == depth && o > block.ordinal);
+		if (at < 0) at = positions.length;
+		sheet.names.set(name, css);
+		positions.splice(at, 0, [depth, block.ordinal]);
+		sheet.element.sheet.insertRule(`.${name}{${css}}`, at);
+	}
+	byDepth.set(depth, name);
+	return name;
+}
+function serialize(document, declarations) {
+	const value = document.createElement("div").style;
+	applyDeclarations(value, declarations);
+	return value.cssText;
+}
+
+//#endregion
+//#region src/render.ts
+const roots = /* @__PURE__ */ new WeakMap();
+const SVG = "http://www.w3.org/2000/svg";
+const dirty = /* @__PURE__ */ new Set();
+const stashes = /* @__PURE__ */ new WeakMap();
+const CONTROLS = ["checked", "value"];
+const ENUMERATED = [
+	"contentEditable",
+	"contenteditable",
+	"draggable",
+	"spellcheck"
+];
+const ALIASES = {
+	autoFocus: "autofocus",
+	contentEditable: "contenteditable",
+	htmlFor: "for"
+};
+const focusing = [];
+const controlled = /* @__PURE__ */ new WeakMap();
+const restoring = /* @__PURE__ */ new WeakSet();
+let passiveRender = false;
+let inserting;
+let depth = 0;
+let settling = false;
+let rendering;
+let touched = false;
+const observed = /* @__PURE__ */ new WeakMap();
+const tickets = /* @__PURE__ */ new WeakMap();
+function render(node, container) {
+	roots.get(container)?.();
+	container.replaceChildren();
+	const context = new Context(Context.root);
+	const fiber = range("fragment", container, null, context);
+	try {
+		pass(() => {
+			const appearanceContext = appearanceRoot();
+			reconcile(fiber, node, context, void 0, appearanceContext ? {
+				context: appearanceContext,
+				entries: []
+			} : void 0);
+		});
+	} catch (error) {
+		unmountFiber(fiber);
+		context.pop();
+		throw error;
+	}
+	let active = true;
+	const unmount = () => {
+		if (!active) return;
+		active = false;
+		unmountFiber(fiber);
+		context.pop();
+		roots.delete(container);
+	};
+	roots.set(container, unmount);
+	return unmount;
+}
+function range(kind, parent, before, context) {
+	const start = document.createComment(kind);
+	const end = document.createComment(`/${kind}`);
+	parent.insertBefore(start, before);
+	parent.insertBefore(end, before);
+	return {
+		kind,
+		context,
+		start,
+		end,
+		children: []
+	};
+}
+function makeScope(kind, context, update) {
+	return {
+		active: true,
+		childContext: context,
+		context,
+		kind,
+		subscriptions: [],
+		update,
+		useIndex: 0,
+		uses: []
+	};
+}
+function complete(fiber, work) {
+	try {
+		work();
+	} catch (error) {
+		unmountFiber(fiber);
+		throw error;
+	}
+	return fiber;
+}
+function componentProps(type, props, appearance) {
+	const context = appearance?.context;
+	if (!context || typeof type != "function") return {
+		appearance,
+		props
+	};
+	const value = context.resolve(props);
+	const entries = appearance.entries;
+	if (!value) return {
+		appearance: { entries },
+		props
+	};
+	return {
+		appearance: {
+			context: value.context,
+			entries
+		},
+		props: {
+			...props,
+			style: [createAppearanceToken(value), props.style]
+		}
+	};
+}
+function mount(value, parent, before, context, boundary, appearance) {
+	if (typeof value == "string" || typeof value == "number" || typeof value == "bigint") {
+		const text = document.createTextNode(String(value));
+		parent.insertBefore(text, before);
+		return {
+			kind: "text",
+			value,
+			context,
+			start: text,
+			end: text,
+			children: []
+		};
+	}
+	if (value instanceof Component) return mountComponent(value, parent, before, context, boundary, appearance);
+	if (isCollection(value)) return mountCollection(value, parent, before, context, boundary, appearance);
+	if (!isVNode(value)) throw new TypeError(`Cannot render ${String(value)}.`);
+	if (value.type === Fragment) return mountFragment(value, parent, before, context, boundary, appearance);
+	if (value.type === PORTAL) return mountPortal(value, parent, before, context, boundary, appearance);
+	if (value.type === Provider) return mountProvider(value, parent, before, context, boundary, appearance);
+	if (typeof value.type == "string") return mountElement(value, parent, before, context, boundary, appearance);
+	if (typeof value.type != "function") throw new Error(`Cannot render ${String(value.type)}.`);
+	if (value.type.prototype instanceof Component) return mountOwnedComponent(value, parent, before, context, boundary, appearance);
+	return mountFunction(value, parent, before, context, boundary, appearance);
+}
+function mountFragment(value, parent, before, context, boundary, appearance) {
+	const fiber = range("fragment", parent, before, context);
+	fiber.key = value.key;
+	fiber.type = Fragment;
+	fiber.appearance = appearance;
+	return complete(fiber, () => {
+		reconcile(fiber, value.props.children, context, boundary, appearance);
+	});
+}
+function mountFunction(value, parent, before, context, boundary, appearance) {
+	const fiber = range("function", parent, before, context);
+	const resolved = componentProps(value.type, value.props, appearance);
+	fiber.key = value.key;
+	fiber.type = value.type;
+	fiber.props = observe(resolved.props);
+	fiber.boundary = boundary;
+	fiber.appearance = resolved.appearance;
+	fiber.scope = makeScope("function", context, (passive) => runFunction(fiber, passive));
+	fiber.render = () => enter(fiber.scope, () => fiber.type(fiber.props));
+	probing(fiber);
+	return complete(fiber, () => {
+		runFunction(fiber, passiveRender);
+	});
+}
+function mountOwnedComponent(value, parent, before, context, boundary, appearance) {
+	const resolved = componentProps(value.type, value.props, appearance);
+	return mountComponent(new value.type(observe(resolved.props)), parent, before, context, boundary, resolved.appearance, true, value.key);
+}
+function runFunction(fiber, passive) {
+	const result = attempt(fiber, passive, fiber.render);
+	if (result === true) inserted(fiber, () => commit(fiber.scope));
+	else return result;
+}
+function probing(fiber) {
+	const scope = fiber.scope;
+	scope.empty = () => !fiber.children.length;
+	scope.probe = () => {
+		try {
+			scope.probed = { output: consume(fiber, fiber.render) };
+		} catch (thrown) {
+			if (isThenable(thrown)) return thrown;
+		}
+	};
+}
+function mountComponent(instance, parent, before, context, inherited, appearance, owned = false, key) {
+	const fiber = range("component", parent, before, context);
+	const childContext = context.push(instance);
+	const ownBoundary = instance.fallback !== false || instance.catch ? {
+		catch: instance.catch?.bind(instance),
+		fallback: () => instance.fallback,
+		owner: fiber,
+		parent: inherited
+	} : inherited;
+	fiber.boundary = ownBoundary;
+	if (ownBoundary !== inherited) fiber.ownBoundary = ownBoundary;
+	fiber.childContext = childContext;
+	fiber.instance = instance;
+	fiber.key = owned ? key : instance.key;
+	fiber.type = instance.constructor;
+	fiber.props = instance.props;
+	fiber.owned = owned;
+	fiber.appearance = appearance;
+	fiber.scope = makeScope("component", childContext, (passive) => runComponent(fiber, passive));
+	fiber.render = () => enter(fiber.scope, () => instance.render.call(fiber.value, instance.props));
+	probing(fiber);
+	let first = true;
+	let proxy = instance;
+	fiber.release = watch(instance, (current, events) => {
+		const { applied, scope } = fiber;
+		proxy = current;
+		fiber.applied = void 0;
+		if (!first && scope.active) if (applied && events.includes("props")) transition(() => schedule(scope));
+		else schedule(scope);
+		first = false;
+	}, void 0, transition);
+	Object.defineProperty(fiber, "value", { get: () => proxy });
+	complete(fiber, () => {
+		runComponent(fiber, passiveRender);
+	});
+	if (owned) inserted(fiber, () => fiber.cleanup = instance.mount?.());
+	return fiber;
+}
+function runComponent(fiber, passive) {
+	const result = attempt(fiber, passive, fiber.render);
+	if (result !== true) return result;
+}
+function mountCollection(value, parent, before, context, boundary, appearance) {
+	const fiber = range("collection", parent, before, context);
+	fiber.source = value;
+	fiber.value = value;
+	fiber.boundary = boundary;
+	fiber.appearance = appearance;
+	fiber.scope = makeScope("collection", context, (passive) => runCollection(fiber, passive));
+	let first = true;
+	fiber.release = watch(value, (current) => {
+		fiber.value = current;
+		if (!first && fiber.scope?.active) schedule(fiber.scope);
+		first = false;
+	}, void 0, transition);
+	return complete(fiber, () => {
+		runCollection(fiber, passiveRender);
+	});
+}
+function runCollection(fiber, passive) {
+	attempt(fiber, passive, () => {
+		const value = fiber.value;
+		return value instanceof map.Managed ? [...value.values()] : [...value];
+	});
+}
+function mountProvider(value, parent, before, context, inherited, appearance) {
+	const fiber = range("provider", parent, before, context);
+	const childContext = new Context(context);
+	fiber.key = value.key;
+	fiber.type = Provider;
+	fiber.props = value.props;
+	fiber.appearance = appearance;
+	fiber.childContext = childContext;
+	const commit = provide(childContext, value.props);
+	const boundary = value.props.fallback !== void 0 ? {
+		fallback: () => fiber.props.fallback,
+		owner: fiber,
+		parent: inherited
+	} : inherited;
+	fiber.boundary = boundary;
+	if (boundary !== inherited) fiber.ownBoundary = boundary;
+	complete(fiber, () => {
+		reconcile(fiber, value.props.children, childContext, boundary, appearance);
+	});
+	commit();
+	return fiber;
+}
+function mountPortal(value, parent, before, context, boundary, appearance) {
+	const marker = document.createComment("portal");
+	const container = value.props.container;
+	const portalStart = document.createComment("portal-root");
+	const portalEnd = document.createComment("/portal-root");
+	parent.insertBefore(marker, before);
+	container.append(portalStart, portalEnd);
+	const output = {
+		kind: "portal",
+		key: value.key,
+		type: PORTAL,
+		props: value.props,
+		context,
+		boundary,
+		appearance,
+		start: marker,
+		end: marker,
+		children: [],
+		portalContainer: container,
+		portalStart,
+		portalEnd
+	};
+	return complete(output, () => {
+		reconcilePortal(output, value.props.children, context, boundary, appearance);
+	});
+}
+function mountElement(value, parent, before, context, boundary, appearance) {
+	const tag = value.type;
+	let host = parent;
+	for (let owner = stashes.get(host); owner; owner = stashes.get(host)) host = owner.end.parentNode;
+	const element = (tag == "svg" || host instanceof SVGElement && host.localName != "foreignObject" ? SVG : void 0) ? document.createElementNS(SVG, tag) : document.createElement(tag);
+	const fiber = {
+		kind: "element",
+		key: value.key,
+		type: tag,
+		props: {},
+		context,
+		boundary,
+		start: element,
+		end: element,
+		children: [],
+		events: /* @__PURE__ */ new Map()
+	};
+	parent.insertBefore(element, before);
+	complete(fiber, () => {
+		patchProps(fiber, value.props, appearance);
+	});
+	if (value.props.autofocus || value.props.autoFocus) focusing.push(element);
+	return fiber;
+}
+function pass(work) {
+	depth++;
+	try {
+		return work();
+	} finally {
+		if (!--depth) {
+			settle();
+			focus();
+		}
+	}
+}
+function focus() {
+	for (const element of focusing.splice(0)) if (element.isConnected) element.focus();
+}
+function attempt(fiber, passive, render) {
+	const previous = passiveRender;
+	const scope = fiber.scope;
+	const probed = scope.probed;
+	scope.probed = void 0;
+	passiveRender ||= passive;
+	if (passive && !depth && !fiber.children.length && !fiber.stash) fiber.staging ||= document.createDocumentFragment();
+	const outer = inserting;
+	if (fiber.staging) inserting = fiber.inserted ||= [];
+	try {
+		return pass(() => {
+			try {
+				reconcile(fiber, probed ? probed.output : consume(fiber, render), scope.childContext, fiber.boundary, renderedAppearance(fiber));
+				if (fiber.staging) {
+					const queued = fiber.inserted;
+					fiber.end.parentNode.insertBefore(fiber.staging, fiber.end);
+					fiber.staging = fiber.inserted = void 0;
+					inserting = outer;
+					queued.forEach((run) => run());
+				}
+				if (!fiber.recovering) unwait(fiber);
+				fiber.retried = void 0;
+				return true;
+			} catch (thrown) {
+				return suspend(fiber, thrown, passive);
+			}
+		});
+	} finally {
+		passiveRender = previous;
+		inserting = outer;
+	}
+}
+function inserted(fiber, run) {
+	if (inserting) inserting.push(() => fiber.dead || run());
+	else run();
+}
+function observe(props) {
+	if (!("style" in props)) return props;
+	let output = observed.get(props);
+	if (!output) {
+		const { style } = props;
+		let handle;
+		let resolved = false;
+		output = Object.defineProperty({ ...props }, "style", {
+			enumerable: true,
+			get() {
+				if (rendering === output) touched = true;
+				if (!resolved) {
+					handle = door(style);
+					resolved = true;
+				}
+				return handle;
+			}
+		});
+		observed.set(props, output);
+	}
+	return output;
+}
+function door(value) {
+	const collected = {
+		classes: [],
+		declarations: {},
+		tokens: []
+	};
+	const { classes, declarations, tokens } = collected;
+	collect(value, collected, 1);
+	if (!classes.length && !tokens.length && !Object.keys(declarations).length) return void 0;
+	const key = Object.freeze({});
+	tickets.set(key, {
+		classes,
+		tokens
+	});
+	return Object.freeze({
+		...declarations,
+		[Symbol("style")]: key
+	});
+}
+function consume(fiber, render) {
+	const previous = rendering;
+	const read = touched;
+	rendering = fiber.props;
+	touched = false;
+	try {
+		const output = render();
+		fiber.consumed = touched;
+		return output;
+	} finally {
+		rendering = previous;
+		touched = read;
+	}
+}
+function wait(fiber, boundary) {
+	if (fiber.waitingOn !== boundary) unwait(fiber);
+	fiber.waitingOn = boundary;
+	(boundary.waiting ||= /* @__PURE__ */ new Set()).add(fiber);
+	dirty.add(boundary);
+}
+function unwait(fiber) {
+	const boundary = fiber.waitingOn;
+	if (!boundary) return;
+	fiber.waitingOn = void 0;
+	boundary.waiting.delete(fiber);
+	if (!boundary.owner.dead) dirty.add(boundary);
+}
+function settle() {
+	if (settling) return;
+	settling = true;
+	try {
+		for (const boundary of dirty) {
+			dirty.delete(boundary);
+			const owner = boundary.owner;
+			const waiting = boundary.waiting.size > 0;
+			if (!owner.dead && waiting != !!owner.stash) waiting ? hide(owner, boundary) : reveal(owner);
+		}
+	} finally {
+		settling = false;
+	}
+}
+function hide(owner, boundary) {
+	const stash = document.createDocumentFragment();
+	for (const child of owner.children) move(child, stash, null);
+	owner.portals = portals(owner, []).map((portal) => {
+		const content = document.createDocumentFragment();
+		moveRange(portal.portalStart, portal.portalEnd, content);
+		return [portal, content];
+	});
+	stashes.set(stash, owner);
+	const context = owner.childContext;
+	const placeholder = range("fragment", owner.end.parentNode, owner.end, context);
+	owner.stash = stash;
+	owner.placeholder = placeholder;
+	reconcile(placeholder, boundary.fallback(), context, boundary.parent);
+}
+function reveal(owner) {
+	unmountFiber(owner.placeholder);
+	owner.end.parentNode.insertBefore(owner.stash, owner.end);
+	for (const [portal, content] of owner.portals) if (!portal.dead) portal.portalContainer.append(content);
+	owner.portals = void 0;
+	owner.placeholder = void 0;
+	owner.stash = void 0;
+}
+function portals(fiber, found) {
+	for (const child of fiber.children) {
+		if (child.kind == "portal") found.push(child);
+		portals(child, found);
+	}
+	return found;
+}
+function moveRange(start, end, target) {
+	let node = start;
+	while (node) {
+		const next = node.nextSibling;
+		target.appendChild(node);
+		if (node === end) break;
+		node = next;
+	}
+}
+function suspend(fiber, thrown, passive) {
+	const boundary = fiber.boundary;
+	if (isThenable(thrown)) {
+		if (!boundary) throw thrown;
+		if (passive && !fiber.children.length && depth > 1) throw thrown;
+		if (!passive) wait(fiber, boundary);
+		const scope = fiber.scope;
+		let held = scope.holds;
+		scope.holds = void 0;
+		const clear = () => {
+			fiber.suspended.delete(clear);
+			release(held);
+			held = void 0;
+		};
+		(fiber.suspended ||= /* @__PURE__ */ new Set()).add(clear);
+		const resume = (retry) => {
+			fiber.suspended.delete(clear);
+			if (!scope.active) return clear();
+			if (held) (scope.holds ||= []).push(...held);
+			held = void 0;
+			retry();
+		};
+		thrown.then(() => resume(() => passive ? transition(() => schedule(scope)) : schedule(scope)), (error) => resume(() => pass(() => recover(fiber, error, fiber.boundary))));
+		return thrown;
+	}
+	recover(fiber, thrown, fiber.boundary);
+}
+function recover(fiber, thrown, boundary) {
+	const error = thrown instanceof Error ? thrown : new Error(String(thrown));
+	while (boundary && !boundary.catch) boundary = boundary.parent;
+	if (!boundary) throw error;
+	const handler = boundary;
+	const token = {};
+	wait(fiber, handler);
+	fiber.recovering = token;
+	Promise.resolve(handler.catch(error)).then(() => {
+		if (fiber.recovering !== token) return;
+		fiber.recovering = void 0;
+		if (!fiber.scope.active || fiber.retried) return;
+		fiber.retried = true;
+		schedule(fiber.scope);
+	}, (next) => {
+		if (fiber.recovering === token && fiber.scope.active) pass(() => recover(fiber, next, handler.parent));
+	});
+}
+function isThenable(value) {
+	return !!value && typeof value.then == "function";
+}
+function reconcile(fiber, value, context, boundary, appearance) {
+	const detached = fiber.stash || fiber.staging;
+	if (detached) reconcileChildren(fiber, detached, null, value, context, boundary, appearance);
+	else reconcileChildren(fiber, fiber.end.parentNode, fiber.end, value, context, boundary, appearance);
+}
+function reconcilePortal(fiber, value, context, boundary, appearance) {
+	reconcileChildren(fiber, fiber.portalEnd.parentNode, fiber.portalEnd, value, context, boundary, appearance);
+}
+function reconcileChildren(owner, parent, before, value, context, boundary, appearance) {
+	const values = childrenOf(value);
+	const old = owner.children;
+	const keyed = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	const next = [];
+	for (const child of old) if (child.key !== null && child.key !== void 0) keyed.set(child.key, child);
+	try {
+		for (let index = 0; index < values.length; index++) {
+			const value = source(values[index]);
+			const key = keyOf(value);
+			let child = key !== null && key !== void 0 ? keyed.get(key) : old[index]?.key == null ? old[index] : void 0;
+			if (child && used.has(child)) child = void 0;
+			if (child) used.add(child);
+			next.push(patch(child, value, parent, before, context, boundary, appearance));
+		}
+	} catch (error) {
+		owner.children = [...next, ...old.filter((child) => !child.dead && !next.includes(child))];
+		throw error;
+	}
+	for (const child of old) if (!used.has(child)) unmountFiber(child);
+	let anchor = before;
+	for (let index = next.length - 1; index >= 0; index--) {
+		move(next[index], parent, anchor);
+		anchor = next[index].start;
+	}
+	owner.children = next;
+}
+function patch(old, value, parent, before, context, boundary, appearance) {
+	if (!old || !compatible(old, value)) {
+		const next = mount(value, parent, old?.start || before, context, boundary, appearance);
+		if (old) unmountFiber(old);
+		return next;
+	}
+	if (old.ownBoundary) old.ownBoundary.parent = boundary;
+	old.boundary = old.ownBoundary || boundary;
+	if (old.kind == "collection") {
+		if (old.appearance !== appearance) {
+			old.appearance = appearance;
+			runCollection(old, passiveRender);
+		}
+		return old;
+	}
+	if (old.kind == "text") {
+		const next = String(value);
+		if (old.start.nodeValue !== next) old.start.nodeValue = next;
+		old.value = value;
+	} else if (old.kind == "element") patchProps(old, value.props, appearance);
+	else if (old.kind == "fragment") {
+		old.context = context;
+		old.appearance = appearance;
+		reconcile(old, value.props.children, context, old.boundary, appearance);
+	} else if (old.kind == "function") {
+		const vnode = value;
+		const resolved = componentProps(vnode.type, vnode.props, appearance);
+		old.appearance = resolved.appearance;
+		old.props = observe(resolved.props);
+		rerun(old, () => runFunction(old, passiveRender));
+	} else if (old.kind == "component") {
+		const resolved = isVNode(value) ? componentProps(value.type, value.props, appearance) : {
+			appearance,
+			props: old.instance.props
+		};
+		old.appearance = resolved.appearance;
+		const props = isVNode(value) ? observe(resolved.props) : resolved.props;
+		if (isVNode(value) && props !== old.instance.props) {
+			if (passiveRender) old.applied = true;
+			old.instance.props = props;
+		}
+		old.props = props;
+		rerun(old, () => runComponent(old, passiveRender));
+	} else if (old.kind == "provider") {
+		old.appearance = appearance;
+		old.props = value.props;
+		const commit = provide(old.childContext, old.props);
+		reconcile(old, old.props.children, old.childContext, old.boundary, appearance);
+		commit();
+	} else {
+		old.appearance = appearance;
+		const vnode = value;
+		old.props = vnode.props;
+		reconcilePortal(old, vnode.props.children, context, old.boundary, appearance);
+	}
+	return old;
+}
+function rerun(fiber, run) {
+	claim$1(fiber.scope);
+	run();
+	settle$1(fiber.scope);
+}
+function compatible(fiber, value) {
+	if (fiber.kind == "text") return [
+		"string",
+		"number",
+		"bigint"
+	].includes(typeof value);
+	if (value instanceof Component) return fiber.kind == "component" && fiber.instance === value;
+	if (isCollection(value)) return fiber.kind == "collection" && fiber.source === value;
+	if (!isVNode(value)) return false;
+	if (fiber.key !== value.key || fiber.type !== value.type) return false;
+	if (fiber.kind == "portal") return fiber.portalContainer === value.props.container;
+	return true;
+}
+function source(value) {
+	if (value instanceof Component) return value.is;
+	while (isCollection(value) && isCollection(Object.getPrototypeOf(value))) value = Object.getPrototypeOf(value);
+	return value;
+}
+function isCollection(value) {
+	return value instanceof has.List || value instanceof has.Pool || value instanceof map.Managed;
+}
+function keyOf(value) {
+	if (value instanceof Component) return value.key;
+	return isVNode(value) ? value.key : void 0;
+}
+function move(fiber, parent, before) {
+	if (fiber.start.parentNode === parent && fiber.end.nextSibling === before) return;
+	let node = fiber.start;
+	while (node) {
+		const next = node.nextSibling;
+		parent.insertBefore(node, before);
+		if (node === fiber.end) break;
+		node = next;
+	}
+}
+function patchProps(fiber, next, appearance) {
+	const element = fiber.start;
+	const previous = fiber.props;
+	const raw = "dangerouslySetInnerHTML" in next;
+	const resolved = appearance?.context?.resolve(next, fiber.type);
+	if (raw) {
+		for (let index = fiber.children.length - 1; index >= 0; index--) unmountFiber(fiber.children[index]);
+		fiber.children = [];
+	}
+	for (const key of Object.keys({
+		...previous,
+		...next
+	})) {
+		if (key.startsWith("_") || key == "children" || key == "className" || key == "key" || key == "ref" || key == "style" || CONTROLS.includes(key)) continue;
+		if (previous[key] === next[key]) continue;
+		patchProp(fiber, element, key, previous[key], next[key]);
+	}
+	const claimed = claim(element, appearance, resolved, next.className, next.style);
+	applyClaim(element, fiber.claimed, claimed);
+	fiber.claimed = claimed;
+	fiber.props = next;
+	fiber.appearance = appearance;
+	if (!raw) reconcileChildren(fiber, element, null, next.children, fiber.context, fiber.boundary, claimed.context ? {
+		context: claimed.context,
+		entries: []
+	} : void 0);
+	for (const key of CONTROLS) {
+		const value = next[key];
+		const live = element[key];
+		if (value == null || !(key in element) ? previous[key] !== value : key == "value" ? String(live) !== String(value) : live !== value) patchProp(fiber, element, key, previous[key], value);
+	}
+	if (CONTROLS.some((key) => next[key] != null)) {
+		const document = element.ownerDocument;
+		controlled.set(element, fiber);
+		if (!restoring.has(document)) {
+			restoring.add(document);
+			document.addEventListener("input", restoreTarget);
+			document.addEventListener("change", restoreTarget);
+		}
+	}
+	if (previous.ref !== next.ref) patchProp(fiber, element, "ref", previous.ref, next.ref);
+}
+function patchProp(fiber, element, key, previous, next) {
+	if (key == "ref") {
+		applyRef(previous, null);
+		inserted(fiber, () => applyRef(next, element));
+		return;
+	}
+	if (key == "dangerouslySetInnerHTML") {
+		element.innerHTML = next?.__html || "";
+		return;
+	}
+	if (/^on[A-Z]/.test(key)) {
+		const capture = key.endsWith("Capture");
+		const lower = (capture ? key.slice(2, -7) : key.slice(2)).toLowerCase();
+		const name = lower == "doubleclick" ? "dblclick" : lower;
+		const id = `${name}:${capture}`;
+		const current = fiber.events.get(id);
+		if (current) element.removeEventListener(name, current, capture);
+		if (typeof next == "function") {
+			fiber.events.set(id, next);
+			element.addEventListener(name, next, capture);
+		} else fiber.events.delete(id);
+		return;
+	}
+	const name = ALIASES[key] || key;
+	if ((key.startsWith("aria-") || key.startsWith("data-") || ENUMERATED.includes(key)) && next != null) {
+		element.setAttribute(name, String(next));
+		return;
+	}
+	if (next === null || next === void 0 || next === false) {
+		if (key in element && typeof element[key] != "function") try {
+			const current = element[key];
+			element[key] = typeof current == "boolean" ? false : typeof current == "number" ? 0 : "";
+		} catch {}
+		element.removeAttribute(element.namespaceURI === SVG ? name.toLowerCase() : name);
+		element.removeAttribute(name);
+		return;
+	}
+	if (key in element && (element.namespaceURI !== SVG || settable(element, key))) try {
+		element[key] = next;
+		return;
+	} catch {}
+	element.setAttribute(name, next === true ? "" : String(next));
+}
+function applyClaim(element, before, after) {
+	const previous = before || {
+		className: "",
+		declarations: {}
+	};
+	if (previous.className !== after.className) if (after.className) element.setAttribute("class", after.className);
+	else element.removeAttribute("class");
+	applyDeclarations(element.style, after.declarations, previous.declarations);
+}
+function claim(element, appearance, resolved, className, value) {
+	const collected = {
+		classes: [],
+		declarations: {},
+		tokens: []
+	};
+	const entries = appearance?.entries || [];
+	let context = appearance?.context;
+	let reach = -1;
+	if (resolved) collect(createAppearanceToken(resolved), collected, 0);
+	appendClasses(collected.classes, className);
+	collect(value, collected, 0);
+	for (let index = entries.length - 1; index >= 0; index--) collect(entries[index].style, collected, entries[index].hops);
+	for (const { appearance, doors } of collected.tokens) {
+		for (const block of appearance.blocks || []) collected.classes.push(emitClass(block, doors, element.ownerDocument));
+		if (appearance.classes) collected.classes.push(...appearance.classes);
+		if (appearance.context && doors >= reach) {
+			context = appearance.context;
+			reach = doors;
+		}
+	}
+	return {
+		className: [...new Set(collected.classes)].join(" "),
+		context,
+		declarations: collected.declarations
+	};
+}
+function renderedAppearance(fiber) {
+	if (fiber.kind != "component" && fiber.kind != "function") return fiber.appearance;
+	const style = fiber.props?.style;
+	const entries = (fiber.appearance?.entries || []).map(({ hops, style }) => ({
+		hops: hops + 1,
+		style
+	}));
+	const inherited = fiber.appearance?.context || appearanceRoot();
+	const context = enterAppearance(inherited, fiber.type);
+	if (context?.base && context !== inherited) entries.push({
+		hops: 0,
+		style: context.base
+	});
+	if (style && !fiber.consumed && !(fiber.instance && "style" in fiber.instance)) entries.push({
+		hops: 0,
+		style
+	});
+	return entries.length || context ? {
+		context,
+		entries
+	} : void 0;
+}
+function collect(value, collected, doors) {
+	if (!value) return;
+	const token = appearanceToken(value);
+	if (token) {
+		collected.tokens.push({
+			appearance: token,
+			doors
+		});
+		Object.assign(collected.declarations, token.declarations);
+		return;
+	}
+	if (typeof value == "string") {
+		appendClasses(collected.classes, value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		value.forEach((entry) => collect(entry, collected, doors));
+		return;
+	}
+	for (const symbol of Object.getOwnPropertySymbols(value)) {
+		const ticket = tickets.get(value[symbol]);
+		if (!ticket) continue;
+		collected.classes.push(...ticket.classes);
+		for (const carried of ticket.tokens) collected.tokens.push({
+			appearance: carried.appearance,
+			doors: carried.doors + doors
+		});
+	}
+	for (const key of Object.keys(value)) collected.declarations[key] = value[key];
+}
+function appendClasses(classes, value) {
+	if (typeof value == "string") classes.push(...value.split(/\s+/).filter(Boolean));
+}
+function restoreTarget(event) {
+	const element = event.target;
+	const fiber = controlled.get(element);
+	if (fiber && event.type == settles(fiber.props, element)) queueMicrotask(() => afterFlush(() => restore(fiber)));
+}
+function settles(props, element) {
+	if (props.onInput) return "input";
+	if (props.onChange) return "change";
+	return element.type == "checkbox" || element.type == "radio" || element.localName == "select" ? "change" : "input";
+}
+function restore(fiber) {
+	const element = fiber.start;
+	for (const key of CONTROLS) {
+		const value = fiber.props[key];
+		if (value == null || fiber.dead) continue;
+		if (key == "value" ? String(element.value) !== String(value) : element[key] !== value) element[key] = value;
+	}
+}
+function settable(element, key) {
+	let target = element;
+	let descriptor;
+	while (!(descriptor = Object.getOwnPropertyDescriptor(target, key))) target = Object.getPrototypeOf(target);
+	return !!(descriptor.set || descriptor.writable);
+}
+function applyRef(ref, value) {
+	if (typeof ref == "function") ref(value);
+	else if (ref && typeof ref == "object" && "current" in ref) ref.current = value;
+}
+function unmountFiber(fiber) {
+	fiber.dead = true;
+	unwait(fiber);
+	for (let index = fiber.children.length - 1; index >= 0; index--) unmountFiber(fiber.children[index]);
+	if (fiber.placeholder) unmountFiber(fiber.placeholder);
+	fiber.suspended?.forEach((clear) => clear());
+	if (fiber.scope) dispose(fiber.scope);
+	fiber.release?.();
+	if (fiber.kind == "element") {
+		applyRef(fiber.props?.ref, null);
+		for (const [id, listener] of fiber.events) {
+			const [name, capture] = id.split(":");
+			fiber.start.removeEventListener(name, listener, capture === "true");
+		}
+	}
+	if (fiber.kind == "component") {
+		if (typeof fiber.cleanup == "function") fiber.cleanup();
+		fiber.childContext?.pop();
+		if (fiber.owned && !fiber.instance.get(null)) fiber.instance.set(null);
+	} else if (fiber.kind == "provider") fiber.childContext?.pop();
+	else if (fiber.kind == "portal") {
+		fiber.portalStart.remove();
+		fiber.portalEnd.remove();
+	}
+	removeRange(fiber.start, fiber.end);
+}
+function removeRange(start, end) {
+	let node = start;
+	while (true) {
+		const next = node.nextSibling;
+		node.remove();
+		if (node === end) break;
+		node = next;
+	}
+}
+
+//#endregion
+export { Consumer, Provider, createPortal, css, lazy, macro, render, style };
+//# sourceMappingURL=index.js.map