@zeus-js/runtime-dom 0.0.2

package/dist/runtime-dom.cjs.js

@@ -0,0 +1,880 @@
+/**
+* runtime-dom v0.0.2
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+let _zeus_js_signal = require("@zeus-js/signal");
+//#region packages/runtime-dom/src/template.ts
+function template(html, _isImportNode = false, _isSVG = false, _isMathML = false) {
+	const t = document.createElement("template");
+	t.innerHTML = html;
+	return function clone() {
+		return t.content.cloneNode(true);
+	};
+}
+//#endregion
+//#region packages/runtime-dom/src/hostContext.ts
+let currentHostContext;
+function getCurrentHostContext() {
+	return currentHostContext;
+}
+function withHostContext(context, fn) {
+	const previous = currentHostContext;
+	currentHostContext = context;
+	try {
+		return fn();
+	} finally {
+		currentHostContext = previous;
+	}
+}
+function captureCurrentHostContext() {
+	return currentHostContext;
+}
+function withCapturedHostContext(fn) {
+	const context = captureCurrentHostContext();
+	return ((...args) => {
+		return withHostContext(context, () => fn(...args));
+	});
+}
+//#endregion
+//#region packages/runtime-dom/src/range.ts
+var DynamicRange = class {
+	constructor(parent, marker) {
+		this.parent = parent;
+		this.marker = marker;
+		this.nodes = [];
+	}
+	replace(value) {
+		this.clear();
+		this.nodes = insertTracked(this.parent, value, this.marker);
+	}
+	clear() {
+		for (const node of this.nodes) {
+			var _node$parentNode;
+			(_node$parentNode = node.parentNode) === null || _node$parentNode === void 0 || _node$parentNode.removeChild(node);
+		}
+		this.nodes = [];
+	}
+	current() {
+		return this.nodes;
+	}
+};
+function insertTracked(parent, value, marker) {
+	if (value === void 0 || value == null || value === false || value === true) return [];
+	if (Array.isArray(value)) {
+		const nodes = [];
+		for (const item of value) nodes.push(...insertTracked(parent, item, marker));
+		return nodes;
+	}
+	const node = value instanceof Node ? value : document.createTextNode(String(value));
+	parent.insertBefore(node, marker);
+	return [node];
+}
+function removeNodes$1(nodes) {
+	for (const node of nodes) {
+		var _node$parentNode2;
+		(_node$parentNode2 = node.parentNode) === null || _node$parentNode2 === void 0 || _node$parentNode2.removeChild(node);
+	}
+}
+function moveRangeBefore(nodes, parent, marker) {
+	for (const node of nodes) parent.insertBefore(node, marker);
+}
+//#endregion
+//#region packages/runtime-dom/src/insert.ts
+function insert(parent, value, marker = null) {
+	if (value === void 0) {
+		console.warn("[Zeus runtime] insert received `undefined`, which is ignored. Use `null` or a fallback value explicitly if you want to suppress this warning.");
+		return;
+	}
+	insertTracked(parent, value, marker);
+}
+function mountDynamic(parent, marker, value) {
+	const range = new DynamicRange(parent, marker);
+	const hostContext = captureCurrentHostContext();
+	const owner = getCurrentOwner();
+	const runner = (0, _zeus_js_signal.effect)(() => {
+		const next = runWithOwner(owner, () => withHostContext(hostContext, value));
+		range.replace(next);
+	});
+	(0, _zeus_js_signal.onScopeDispose)(() => {
+		(0, _zeus_js_signal.stop)(runner);
+		range.clear();
+	}, true);
+}
+//#endregion
+//#region packages/runtime-dom/src/context.ts
+let currentOwner;
+function getCurrentOwner() {
+	return currentOwner;
+}
+function createOwner(parent = currentOwner) {
+	return {
+		parent,
+		provides: /* @__PURE__ */ new Map()
+	};
+}
+function runWithOwner(owner, fn) {
+	const previous = currentOwner;
+	currentOwner = owner;
+	try {
+		return fn();
+	} finally {
+		currentOwner = previous;
+	}
+}
+function createContext(defaultValue) {
+	const hasDefaultValue = arguments.length > 0;
+	const context = {
+		id: Symbol("ZeusContext"),
+		defaultValue,
+		hasDefaultValue,
+		Provider(props) {
+			const owner = createOwner(currentOwner);
+			owner.provides.set(context.id, props.value);
+			return runWithOwner(owner, () => {
+				const children = resolveValue$3(props.children);
+				if (props.bridge) return createDOMContextBoundary(context, props.value, children);
+				return children;
+			});
+		},
+		Bridge(props) {
+			return createDOMContextBoundary(context, props.value, resolveValue$3(props.children));
+		}
+	};
+	return context;
+}
+function provide(context, value) {
+	const owner = currentOwner;
+	if (!owner) {
+		console.warn("[Zeus context] provide() was called without an active component owner.");
+		return;
+	}
+	owner.provides.set(context.id, value);
+}
+function inject(context, fallback) {
+	let owner = currentOwner;
+	while (owner) {
+		if (owner.provides.has(context.id)) return owner.provides.get(context.id);
+		owner = owner.parent;
+	}
+	if (arguments.length >= 2) return fallback;
+	if (context.hasDefaultValue) return context.defaultValue;
+	throw new Error(`[Zeus context] No provider found for context.`);
+}
+function useContext(context, fallback) {
+	if (arguments.length >= 2) return inject(context, fallback);
+	return inject(context);
+}
+const ZEUS_CONTEXT_REQUEST = "zeus:context-request";
+/**
+* Creates a transparent DOM element that acts as a context boundary.
+* Native custom elements inside it can use `requestDOMContext` to receive
+* context values via the DOM event protocol.
+*/
+function createDOMContextBoundary(context, value, children) {
+	const boundary = document.createElement("zeus-context");
+	boundary.style.cssText = "display:contents;position:unset;width:0;height:0;overflow:hidden";
+	provideDOMContext(boundary, context, value);
+	insert(boundary, children);
+	return boundary;
+}
+/**
+* Registers a context value on a DOM target so that any descendant custom
+* element can pick it up via `requestDOMContext`.
+*/
+function provideDOMContext(target, context, value) {
+	const handler = (event) => {
+		const request = event;
+		if (request.type !== "zeus:context-request") return;
+		if (request.detail.id !== context.id) return;
+		request.stopPropagation();
+		request.detail.resolve(value);
+	};
+	target.addEventListener(ZEUS_CONTEXT_REQUEST, handler);
+	(0, _zeus_js_signal.onScopeDispose)(() => {
+		target.removeEventListener(ZEUS_CONTEXT_REQUEST, handler);
+	}, true);
+}
+/**
+* Internal precise DOM context resolver.
+*
+* Unlike requestDOMContext(), this can distinguish:
+* - found: false, value: undefined
+* - found: true, value: undefined
+*/
+function resolveDOMContext(host, context) {
+	let found = false;
+	let value;
+	const event = new CustomEvent(ZEUS_CONTEXT_REQUEST, {
+		bubbles: true,
+		composed: true,
+		cancelable: true,
+		detail: {
+			id: context.id,
+			resolved: false,
+			value: void 0,
+			resolve(nextValue) {
+				found = true;
+				value = nextValue;
+				this.resolved = true;
+				this.value = nextValue;
+			}
+		}
+	});
+	host.dispatchEvent(event);
+	return {
+		found,
+		value
+	};
+}
+/**
+* Public compatibility API.
+*
+* Returns the resolved value if found, otherwise undefined.
+* If you need to distinguish "not found" from "found undefined",
+* use resolveDOMContext().
+*/
+function requestDOMContext(host, context) {
+	return resolveDOMContext(host, context).value;
+}
+function resolveValue$3(value) {
+	return typeof value === "function" ? value() : value !== null && value !== void 0 ? value : null;
+}
+//#endregion
+//#region packages/runtime-dom/src/devtools.ts
+function emitDevtoolsEvent(event) {
+	var _window$__ZEUS_DEVTOO;
+	if (typeof window === "undefined") return;
+	(_window$__ZEUS_DEVTOO = window.__ZEUS_DEVTOOLS_HOOK__) === null || _window$__ZEUS_DEVTOO === void 0 || _window$__ZEUS_DEVTOO.emit(event);
+}
+//#endregion
+//#region packages/runtime-dom/src/render.ts
+function render(value, container, options = {}) {
+	var _options$owner;
+	const renderScope = (0, _zeus_js_signal.scope)();
+	const owner = (_options$owner = options.owner) !== null && _options$owner !== void 0 ? _options$owner : createOwner();
+	renderScope.run(() => {
+		container.textContent = "";
+		runWithOwner(owner, () => {
+			insert(container, resolveValue$2(value));
+		});
+	});
+	emitDevtoolsEvent({
+		type: "render",
+		target: container
+	});
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		renderScope.stop();
+		container.textContent = "";
+	};
+}
+function resolveValue$2(value) {
+	return typeof value === "function" ? value() : value !== null && value !== void 0 ? value : null;
+}
+//#endregion
+//#region packages/runtime-dom/src/dom.ts
+function marker(parent, index) {
+	let seen = 0;
+	for (const node of parent.childNodes) {
+		if (node.nodeType !== Node.COMMENT_NODE) continue;
+		const comment = node;
+		if (comment.data !== "" && comment.data !== "!") continue;
+		if (seen === index) return comment;
+		seen++;
+	}
+	throw new Error(`[Zeus runtime] marker ${index} not found`);
+}
+function child(parent, index) {
+	const node = parent.childNodes.item(index);
+	if (!node) throw new Error(`[Zeus runtime] child ${index} not found`);
+	return node;
+}
+function removeNodes(nodes) {
+	for (const node of nodes) {
+		var _node$parentNode;
+		(_node$parentNode = node.parentNode) === null || _node$parentNode === void 0 || _node$parentNode.removeChild(node);
+	}
+}
+//#endregion
+//#region packages/runtime-dom/src/bindings.ts
+function bindText(node, value) {
+	(0, _zeus_js_signal.effect)(() => {
+		node.data = stringifyText(value());
+	});
+}
+function bindTextContent(el, value) {
+	(0, _zeus_js_signal.effect)(() => {
+		el.textContent = stringifyText(value());
+	});
+}
+function stringifyText(value) {
+	if (Array.isArray(value)) return value.map(stringifyText).join("");
+	if (value == null || value === false || value === true) return "";
+	if (typeof Node !== "undefined" && value instanceof Node) {
+		var _value$textContent;
+		return (_value$textContent = value.textContent) !== null && _value$textContent !== void 0 ? _value$textContent : "";
+	}
+	return String(value);
+}
+function setAttr(el, name, value) {
+	if (value == null || value === false) {
+		el.removeAttribute(normalizeAttrName(name));
+		return;
+	}
+	const attrName = normalizeAttrName(name);
+	if (value === true) {
+		el.setAttribute(attrName, "");
+		return;
+	}
+	el.setAttribute(attrName, String(value));
+}
+function normalizeAttrName(name) {
+	return name === "className" ? "class" : name;
+}
+function bindAttr(el, name, value) {
+	(0, _zeus_js_signal.effect)(() => {
+		setAttr(el, name, value());
+	});
+}
+function bindProp(el, name, value) {
+	(0, _zeus_js_signal.effect)(() => {
+		el[name] = value();
+	});
+}
+function bindClass(el, value) {
+	(0, _zeus_js_signal.effect)(() => {
+		const next = normalizeClass(value());
+		if (next) el.setAttribute("class", next);
+		else el.removeAttribute("class");
+	});
+}
+function normalizeClass(value) {
+	if (!value) return "";
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map(normalizeClass).filter(Boolean).join(" ");
+	if (typeof value === "object") return Object.keys(value).filter((key) => value[key]).join(" ");
+	return "";
+}
+function bindStyle(el, value) {
+	let prev;
+	(0, _zeus_js_signal.effect)(() => {
+		const next = value();
+		if (next == null) {
+			el.removeAttribute("style");
+			prev = void 0;
+			return;
+		}
+		if (typeof next === "string") {
+			el.setAttribute("style", next);
+			prev = void 0;
+			return;
+		}
+		patchStyle(el, prev, next);
+		prev = next;
+	});
+}
+function patchStyle(el, prev, next) {
+	const style = el.style;
+	if (prev) {
+		for (const key in prev) if (!(key in next)) style.setProperty(toKebabCase$1(key), "");
+	}
+	for (const key in next) {
+		const value = next[key];
+		const name = toKebabCase$1(key);
+		if (value == null) style.setProperty(name, "");
+		else style.setProperty(name, normalizeStyleValue(key, value));
+	}
+}
+function normalizeStyleValue(key, value) {
+	if (typeof value === "number" && value !== 0 && !isUnitlessNumber(key)) return `${value}px`;
+	return String(value);
+}
+const unitlessNumbers = new Set([
+	"opacity",
+	"zIndex",
+	"fontWeight",
+	"lineHeight",
+	"flex",
+	"flexGrow",
+	"flexShrink",
+	"order"
+]);
+function isUnitlessNumber(key) {
+	return unitlessNumbers.has(key);
+}
+function toKebabCase$1(value) {
+	return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+//#endregion
+//#region packages/runtime-dom/src/events.ts
+const delegatedEvents = /* @__PURE__ */ new Set();
+const delegatedListeners = [];
+const nonBubblingEventMap = {
+	focus: "focusin",
+	blur: "focusout"
+};
+function bindEvent(el, name, handler) {
+	const target = el;
+	const events = target.__zeusEvents || (target.__zeusEvents = {});
+	events[name] = handler;
+	(0, _zeus_js_signal.onScopeDispose)(() => {
+		var _target$__zeusEvents;
+		if (((_target$__zeusEvents = target.__zeusEvents) === null || _target$__zeusEvents === void 0 ? void 0 : _target$__zeusEvents[name]) === handler) delete target.__zeusEvents[name];
+	}, true);
+}
+function delegateEvents(events) {
+	for (const event of events) {
+		const delegatedName = normalizeDelegatedEventName(event);
+		if (delegatedEvents.has(delegatedName)) continue;
+		delegatedEvents.add(delegatedName);
+		const handler = dispatchDelegatedEvent;
+		delegatedListeners.push(delegatedName);
+		document.addEventListener(delegatedName, handler);
+		emitDevtoolsEvent({
+			type: "delegate-event",
+			event: delegatedName
+		});
+	}
+}
+function normalizeDelegatedEventName(name) {
+	var _nonBubblingEventMap$;
+	return (_nonBubblingEventMap$ = nonBubblingEventMap[name]) !== null && _nonBubblingEventMap$ !== void 0 ? _nonBubblingEventMap$ : name;
+}
+function normalizeOriginalEventName(name) {
+	if (name === "focusin") return "focus";
+	if (name === "focusout") return "blur";
+	return name;
+}
+function dispatchDelegatedEvent(event) {
+	const eventName = normalizeOriginalEventName(event.type);
+	let node = event.target;
+	while (node && node !== document) {
+		if (node.nodeType === Node.ELEMENT_NODE) {
+			var _el$__zeusEvents;
+			const el = node;
+			const handler = (_el$__zeusEvents = el.__zeusEvents) === null || _el$__zeusEvents === void 0 ? void 0 : _el$__zeusEvents[eventName];
+			if (handler) {
+				callDelegatedHandler(el, handler, event);
+				if (event.cancelBubble) return;
+			}
+		}
+		node = node.parentNode;
+	}
+}
+function callDelegatedHandler(el, handler, event) {
+	const previousCurrentTarget = Object.prototype.hasOwnProperty.call(event, "currentTarget") ? Object.getOwnPropertyDescriptor(event, "currentTarget") : void 0;
+	try {
+		Object.defineProperty(event, "currentTarget", {
+			configurable: true,
+			get() {
+				return el;
+			}
+		});
+	} catch {}
+	try {
+		handler.call(el, event);
+	} finally {
+		try {
+			if (previousCurrentTarget) Object.defineProperty(event, "currentTarget", previousCurrentTarget);
+			else delete event.currentTarget;
+		} catch {}
+	}
+}
+//#endregion
+//#region packages/runtime-dom/src/refs.ts
+function setRef(target, value) {
+	if (target == null) return;
+	if (typeof target === "function") {
+		target(value);
+		return;
+	}
+	if ("value" in target) {
+		target.value = value;
+		return;
+	}
+	if ("current" in target) {
+		target.current = value;
+		return;
+	}
+	console.warn("[Zeus runtime] Invalid ref target:", target);
+}
+function bindRef(el, target) {
+	setRef(target, el);
+	if ((0, _zeus_js_signal.getCurrentScope)()) (0, _zeus_js_signal.onScopeDispose)(() => {
+		setRef(target, null);
+	}, true);
+}
+//#endregion
+//#region packages/runtime-dom/src/component.ts
+function createComponent(component, props) {
+	return runWithOwner(createOwner(), () => component(props));
+}
+//#endregion
+//#region packages/runtime-dom/src/list.ts
+function mountFor$1(parent, marker, each, key, render) {
+	if (!key) {
+		mountIndexFor(parent, marker, each, render);
+		return;
+	}
+	mountKeyedFor(parent, marker, each, key, render);
+}
+function mountIndexFor(parent, marker, each, render) {
+	let current = [];
+	const owner = getCurrentOwner();
+	const runner = (0, _zeus_js_signal.effect)(() => {
+		var _each;
+		removeNodes$1(current);
+		current = [];
+		const list = (_each = each()) !== null && _each !== void 0 ? _each : [];
+		for (let i = 0; i < list.length; i++) current.push(...insertTracked(parent, runWithOwner(owner, () => render(list[i], i)), marker));
+	});
+	(0, _zeus_js_signal.onScopeDispose)(() => {
+		(0, _zeus_js_signal.stop)(runner);
+		removeNodes$1(current);
+		current = [];
+	}, true);
+}
+function mountKeyedFor(parent, marker, each, key, render) {
+	let records = [];
+	const owner = getCurrentOwner();
+	const runner = (0, _zeus_js_signal.effect)(() => {
+		var _each2;
+		const nextItems = (_each2 = each()) !== null && _each2 !== void 0 ? _each2 : [];
+		const oldMap = /* @__PURE__ */ new Map();
+		for (const record of records) oldMap.set(record.key, record);
+		const nextRecords = [];
+		for (let i = 0; i < nextItems.length; i++) {
+			const item = nextItems[i];
+			const itemKey = key(item, i);
+			const oldRecord = oldMap.get(itemKey);
+			if (oldRecord) {
+				oldMap.delete(itemKey);
+				oldRecord.item = item;
+				oldRecord.index = i;
+				nextRecords.push(oldRecord);
+			} else nextRecords.push({
+				key: itemKey,
+				item,
+				index: i,
+				nodes: insertTracked(parent, runWithOwner(owner, () => render(item, i)), marker)
+			});
+		}
+		for (const record of oldMap.values()) removeNodes$1(record.nodes);
+		for (let i = nextRecords.length - 1; i >= 0; i--) {
+			var _nextRecords$nodes$;
+			const record = nextRecords[i];
+			const anchor = i === nextRecords.length - 1 ? marker : (_nextRecords$nodes$ = nextRecords[i + 1].nodes[0]) !== null && _nextRecords$nodes$ !== void 0 ? _nextRecords$nodes$ : marker;
+			moveRangeBefore(record.nodes, parent, anchor);
+		}
+		emitDevtoolsEvent({
+			type: "mount-for",
+			length: records.length
+		});
+		records = nextRecords;
+	});
+	(0, _zeus_js_signal.onScopeDispose)(() => {
+		(0, _zeus_js_signal.stop)(runner);
+		for (const record of records) removeNodes$1(record.nodes);
+		records = [];
+	}, true);
+}
+//#endregion
+//#region packages/runtime-dom/src/controlFlow.ts
+function Show(props) {
+	return resolveValue(props.when ? props.children : props.fallback);
+}
+function resolveValue(value) {
+	if (typeof value === "function") return value();
+	return value !== null && value !== void 0 ? value : null;
+}
+function mountShow(parent, marker, when, children, fallback) {
+	mountDynamic(parent, marker, () => when() ? children() : fallback ? fallback() : null);
+}
+function For(props) {
+	var _props$each$map, _props$each;
+	return (_props$each$map = (_props$each = props.each) === null || _props$each === void 0 ? void 0 : _props$each.map((item, index) => props.children(item, index))) !== null && _props$each$map !== void 0 ? _props$each$map : null;
+}
+function mountFor(parent, marker, each, key, render) {
+	mountFor$1(parent, marker, each, key, render);
+}
+//#endregion
+//#region packages/runtime-dom/src/defineElement.ts
+function defineElement(tagName, options, setup) {
+	var _options$props;
+	const propDefs = normalizePropDefinitions((_options$props = options.props) !== null && _options$props !== void 0 ? _options$props : {});
+	const observedAttributes = propDefs.filter((def) => def.attr !== false).map((def) => def.attr);
+	class ZeusElement extends HTMLElement {
+		static get observedAttributes() {
+			return observedAttributes;
+		}
+		constructor() {
+			super();
+			this.props = (0, _zeus_js_signal.state)({});
+			this.lightChildren = [];
+			this.capturedLightChildren = false;
+			this.reflecting = false;
+			applyPropDefaults(this.props, propDefs);
+			definePropAccessors(this, this.props, propDefs);
+		}
+		connectedCallback() {
+			var _options$shadow, _options$consumes;
+			if (this.dispose) return;
+			const shadow = (_options$shadow = options.shadow) !== null && _options$shadow !== void 0 ? _options$shadow : false;
+			const mode = shadow ? "shadow" : "light";
+			if (mode === "light" && !this.capturedLightChildren) {
+				this.lightChildren = Array.from(this.childNodes);
+				this.capturedLightChildren = true;
+			}
+			this.syncAttributesToProps(propDefs);
+			const owner = createOwner();
+			for (const context of (_options$consumes = options.consumes) !== null && _options$consumes !== void 0 ? _options$consumes : []) {
+				const resolved = resolveDOMContext(this, context);
+				if (resolved.found) owner.provides.set(context.id, resolved.value);
+				else if (context.hasDefaultValue) owner.provides.set(context.id, context.defaultValue);
+			}
+			const target = this.resolveRenderTarget(shadow);
+			const hostContext = {
+				host: this,
+				mode,
+				lightChildren: this.lightChildren
+			};
+			const setupContext = {
+				host: this,
+				emit: (name, detail, eventOptions) => {
+					return this.dispatchEvent(new CustomEvent(name, {
+						bubbles: true,
+						composed: true,
+						cancelable: true,
+						...eventOptions,
+						detail
+					}));
+				}
+			};
+			this.dispose = render(() => runWithOwner(owner, () => withHostContext(hostContext, () => setup(this.props, setupContext))), target, { owner });
+			mountStyles(target, options.styles);
+			(0, _zeus_js_signal.onScopeDispose)(() => {
+				var _this$dispose;
+				(_this$dispose = this.dispose) === null || _this$dispose === void 0 || _this$dispose.call(this);
+				this.dispose = void 0;
+			}, true);
+		}
+		disconnectedCallback() {
+			var _this$dispose2;
+			(_this$dispose2 = this.dispose) === null || _this$dispose2 === void 0 || _this$dispose2.call(this);
+			this.dispose = void 0;
+		}
+		attributeChangedCallback(name, oldValue, newValue) {
+			if (oldValue === newValue || this.reflecting) return;
+			const def = propDefs.find((item) => item.attr === name);
+			if (!def) return;
+			this.props[def.key] = castAttributeValue(newValue, def);
+		}
+		resolveRenderTarget(shadow) {
+			if (this.target) return this.target;
+			if (!shadow) {
+				this.target = this;
+				return this.target;
+			}
+			this.target = this.attachShadow(typeof shadow === "object" ? shadow : { mode: "open" });
+			return this.target;
+		}
+		syncAttributesToProps(defs) {
+			for (const def of defs) {
+				if (def.attr === false) continue;
+				const value = this.getAttribute(def.attr);
+				if (value !== null || def.type === Boolean) this.props[def.key] = castAttributeValue(value, def);
+			}
+		}
+		_writePropFromProperty(key, value) {
+			const def = propDefs.find((item) => item.key === key);
+			this.props[key] = value;
+			if ((def === null || def === void 0 ? void 0 : def.reflect) && def.attr !== false) {
+				this.reflecting = true;
+				try {
+					reflectPropToAttribute(this, def, value);
+				} finally {
+					this.reflecting = false;
+				}
+			}
+		}
+	}
+	if (!customElements.get(tagName)) customElements.define(tagName, ZeusElement);
+	return ZeusElement;
+}
+function normalizePropDefinitions(props) {
+	return Object.keys(props).map((key) => {
+		const input = props[key];
+		if (typeof input === "function") return {
+			key,
+			attr: toKebabCase(key),
+			type: input,
+			reflect: false
+		};
+		return {
+			key,
+			attr: (input === null || input === void 0 ? void 0 : input.attr) === void 0 ? toKebabCase(key) : input.attr,
+			type: input === null || input === void 0 ? void 0 : input.type,
+			reflect: Boolean(input === null || input === void 0 ? void 0 : input.reflect),
+			default: input === null || input === void 0 ? void 0 : input.default
+		};
+	});
+}
+function applyPropDefaults(props, defs) {
+	for (const def of defs) {
+		if (!("default" in def)) continue;
+		const value = typeof def.default === "function" ? def.default() : def.default;
+		props[def.key] = value;
+	}
+}
+function definePropAccessors(element, props, defs) {
+	for (const def of defs) {
+		if (def.key in element) continue;
+		Object.defineProperty(element, def.key, {
+			configurable: true,
+			enumerable: true,
+			get() {
+				return props[def.key];
+			},
+			set(value) {
+				element._writePropFromProperty(def.key, value);
+			}
+		});
+	}
+}
+function castAttributeValue(value, def) {
+	if (def.type === Boolean) return value !== null;
+	if (value === null) return;
+	if (def.type === Number) return Number(value);
+	if (def.type === Object || def.type === Array) try {
+		return JSON.parse(value);
+	} catch {
+		console.warn(`[Zeus custom-element] Failed to parse JSON attribute "${def.attr}".`);
+		return def.type === Array ? [] : {};
+	}
+	return value;
+}
+function reflectPropToAttribute(element, def, value) {
+	if (def.attr === false) return;
+	if (def.type === Boolean) {
+		if (value) element.setAttribute(def.attr, "");
+		else element.removeAttribute(def.attr);
+		return;
+	}
+	if (value == null) {
+		element.removeAttribute(def.attr);
+		return;
+	}
+	if (def.type === Object || def.type === Array) {
+		element.setAttribute(def.attr, JSON.stringify(value));
+		return;
+	}
+	element.setAttribute(def.attr, String(value));
+}
+function mountStyles(target, styles) {
+	if (!styles) return;
+	const list = Array.isArray(styles) ? styles : [styles];
+	for (const css of list) {
+		const style = document.createElement("style");
+		style.textContent = css;
+		target.appendChild(style);
+	}
+}
+function toKebabCase(value) {
+	return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+//#endregion
+//#region packages/runtime-dom/src/slot.ts
+function createSlot(name, fallback) {
+	const context = getCurrentHostContext();
+	if (!context) return createNativeSlot(name, fallback);
+	if (context.mode === "shadow") return createNativeSlot(name, fallback);
+	const assigned = findLightSlotNodes(context.lightChildren, name);
+	if (assigned.length > 0) return Array.from(assigned);
+	return fallback ? fallback() : null;
+}
+function createNativeSlot(name, fallback) {
+	const slot = document.createElement("slot");
+	if (name) slot.setAttribute("name", name);
+	const fallbackValue = fallback === null || fallback === void 0 ? void 0 : fallback();
+	if (fallbackValue != null) insert(slot, fallbackValue);
+	return slot;
+}
+function findLightSlotNodes(nodes, name) {
+	if (name) return nodes.filter((node) => {
+		if (node.nodeType !== Node.ELEMENT_NODE) return false;
+		return node.getAttribute("slot") === name;
+	});
+	return nodes.filter((node) => {
+		if (node.nodeType === Node.ELEMENT_NODE) return !node.hasAttribute("slot");
+		return isMeaningfulTextNode(node);
+	});
+}
+function isMeaningfulTextNode(node) {
+	var _node$textContent;
+	if (node.nodeType !== Node.TEXT_NODE) return false;
+	return Boolean((_node$textContent = node.textContent) === null || _node$textContent === void 0 ? void 0 : _node$textContent.trim());
+}
+//#endregion
+//#region packages/runtime-dom/src/webComponents.ts
+function Host(props) {
+	return resolveValue$1(props.children);
+}
+function Slot(props) {
+	return createSlot(props.name, () => resolveValue$1(props.children));
+}
+function resolveValue$1(value) {
+	return typeof value === "function" ? value() : value;
+}
+//#endregion
+exports.For = For;
+exports.Host = Host;
+exports.Show = Show;
+exports.Slot = Slot;
+exports.ZEUS_CONTEXT_REQUEST = ZEUS_CONTEXT_REQUEST;
+exports.bindAttr = bindAttr;
+exports.bindClass = bindClass;
+exports.bindEvent = bindEvent;
+exports.bindProp = bindProp;
+exports.bindRef = bindRef;
+exports.bindStyle = bindStyle;
+exports.bindText = bindText;
+exports.bindTextContent = bindTextContent;
+exports.captureCurrentHostContext = captureCurrentHostContext;
+exports.child = child;
+exports.createComponent = createComponent;
+exports.createContext = createContext;
+exports.createDOMContextBoundary = createDOMContextBoundary;
+exports.createOwner = createOwner;
+exports.createSlot = createSlot;
+exports.defineElement = defineElement;
+exports.delegateEvents = delegateEvents;
+exports.getCurrentHostContext = getCurrentHostContext;
+exports.getCurrentOwner = getCurrentOwner;
+exports.inject = inject;
+exports.insert = insert;
+exports.marker = marker;
+exports.mountDynamic = mountDynamic;
+exports.mountFor = mountFor;
+exports.mountShow = mountShow;
+exports.normalizeClass = normalizeClass;
+exports.provide = provide;
+exports.provideDOMContext = provideDOMContext;
+exports.removeNodes = removeNodes;
+exports.render = render;
+exports.requestDOMContext = requestDOMContext;
+exports.resolveDOMContext = resolveDOMContext;
+exports.resolveValue = resolveValue;
+exports.runWithOwner = runWithOwner;
+exports.setAttr = setAttr;
+exports.setRef = setRef;
+exports.template = template;
+exports.useContext = useContext;
+exports.withCapturedHostContext = withCapturedHostContext;
+exports.withHostContext = withHostContext;