j20 0.0.0 → 0.0.1

package/dist/index.mjs

@@ -0,0 +1,883 @@
+//#region ../signal/dist/index.mjs
+let currentReaction = null;
+const depMap = /* @__PURE__ */ new WeakMap();
+/**
+* Signal类 - 用于存储响应式数据
+*/
+var Signal = class {
+	_value;
+	_version = 0;
+	_deps = /* @__PURE__ */ new Set();
+	constructor(value) {
+		this._value = value;
+	}
+	get value() {
+		if (currentReaction) this.track(currentReaction);
+		return this._value;
+	}
+	set value(newValue) {
+		if (Object.is(this._value, newValue)) return;
+		this._value = newValue;
+		this._version++;
+		this._deps.forEach((reaction) => {
+			if (reaction instanceof Computed) reaction.markDirty();
+			else if (reaction.isActive()) {
+				if (reaction._depVersions.has(this) || reaction.hasDepsChanged()) reaction.execute();
+			}
+		});
+	}
+	get version() {
+		return this._version;
+	}
+	track(reaction) {
+		if (!this._deps.has(reaction)) {
+			this._deps.add(reaction);
+			let reactions = depMap.get(this);
+			if (!reactions) {
+				reactions = /* @__PURE__ */ new Set();
+				depMap.set(this, reactions);
+			}
+			reactions.add(reaction);
+			reaction.track(this);
+		}
+	}
+};
+/**
+* Computed类 - 用于计算派生值
+*/
+var Computed = class Computed$1 {
+	computeFn;
+	_value;
+	_version = 0;
+	dirty = true;
+	disposed = false;
+	_deps = /* @__PURE__ */ new Set();
+	sources = /* @__PURE__ */ new Set();
+	constructor(computeFn) {
+		this.computeFn = computeFn;
+		this._value = void 0;
+	}
+	get value() {
+		if (this.disposed) throw new Error("Cannot access value of disposed computed");
+		if (this.dirty) this.compute();
+		if (currentReaction) {
+			if (!this._deps.has(currentReaction)) {
+				this._deps.add(currentReaction);
+				currentReaction.track(this);
+			}
+		}
+		return this._value;
+	}
+	get version() {
+		return this._version;
+	}
+	compute() {
+		if (this.disposed) throw new Error("Cannot compute disposed computed");
+		if (computationStack.includes(this)) throw new Error("Circular dependency detected in computed values");
+		this.dirty = false;
+		const prevReaction = currentReaction;
+		const prevSources = this.sources;
+		this.sources = /* @__PURE__ */ new Set();
+		computationStack.push(this);
+		currentReaction = this;
+		try {
+			this._value = this.computeFn();
+			this._version++;
+		} catch (e) {
+			this.dirty = true;
+			throw e;
+		} finally {
+			const index = computationStack.indexOf(this);
+			if (index !== -1) computationStack.splice(index, 1);
+			currentReaction = prevReaction;
+			prevSources.forEach((source) => {
+				if (!this.sources.has(source)) {
+					const reactions = depMap.get(source);
+					if (reactions) reactions.delete(this);
+				}
+			});
+		}
+	}
+	markDirty() {
+		if (this.disposed || this.dirty) return;
+		this.dirty = true;
+		this._deps.forEach((reaction) => {
+			if (reaction instanceof Computed$1) reaction.markDirty();
+			else if (reaction.isActive()) reaction.execute();
+		});
+	}
+	track(source) {
+		if (this.disposed) return;
+		if (!this.sources.has(source)) {
+			this.sources.add(source);
+			let reactions = depMap.get(source);
+			if (!reactions) {
+				reactions = /* @__PURE__ */ new Set();
+				depMap.set(source, reactions);
+			}
+			reactions.add(this);
+		}
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.sources.forEach((source) => {
+			const reactions = depMap.get(source);
+			if (reactions) reactions.delete(this);
+		});
+		this.sources.clear();
+		this._deps.clear();
+		this._value = void 0;
+		this.computeFn = void 0;
+	}
+};
+const computationStack = [];
+/**
+* Effect类 - 用于执行副作用
+*/
+var Effect = class {
+	effectFn;
+	cleanupFn = null;
+	disposed = false;
+	_deps = /* @__PURE__ */ new Set();
+	_depVersions = /* @__PURE__ */ new Map();
+	constructor(effectFn) {
+		this.effectFn = effectFn;
+	}
+	execute() {
+		if (this.disposed) return;
+		if (this.cleanupFn) {
+			try {
+				this.cleanupFn();
+			} catch (e) {
+				console.warn("Error in effect cleanup function:", e);
+			}
+			this.cleanupFn = null;
+		}
+		const prevReaction = currentReaction;
+		currentReaction = this;
+		try {
+			const result = this.effectFn();
+			if (typeof result === "function") this.cleanupFn = result;
+		} finally {
+			currentReaction = prevReaction;
+		}
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this._deps.forEach((dep) => {
+			const reactions = depMap.get(dep);
+			if (reactions) reactions.delete(this);
+		});
+		this._deps.clear();
+		this._depVersions.clear();
+		if (this.cleanupFn) {
+			try {
+				this.cleanupFn();
+			} catch (e) {
+				console.warn("Error in effect cleanup function:", e);
+			}
+			this.cleanupFn = null;
+		}
+	}
+	isActive() {
+		return !this.disposed;
+	}
+	track(source) {
+		if (this.disposed) return;
+		if (!this._deps.has(source)) {
+			this._deps.add(source);
+			if ("version" in source) this._depVersions.set(source, source.version);
+			let reactions = depMap.get(source);
+			if (!reactions) {
+				reactions = /* @__PURE__ */ new Set();
+				depMap.set(source, reactions);
+			}
+			reactions.add(this);
+		}
+	}
+	hasDepsChanged() {
+		for (const [dep, version] of this._depVersions) if ("version" in dep && dep.version !== version) return true;
+		return false;
+	}
+};
+function signal(initialValue) {
+	return new Signal(initialValue);
+}
+function computed(computeFn) {
+	return new Computed(computeFn);
+}
+function effect$1(effectFn) {
+	const effectInstance = new Effect(effectFn);
+	effectInstance.execute();
+	return effectInstance;
+}
+function untrack(fn) {
+	const prevReaction = currentReaction;
+	currentReaction = null;
+	try {
+		return fn();
+	} finally {
+		currentReaction = prevReaction;
+	}
+}
+
+//#endregion
+//#region src/h/utils.ts
+const isEvent = (eventName) => {
+	return eventName.startsWith("on");
+};
+const getEventName = (eventName) => {
+	return eventName.slice(2).toLocaleLowerCase();
+};
+const getChildren = (propChildren) => {
+	const arr = [];
+	for (let i = 0; i < propChildren.length; i++) {
+		const child = propChildren[i];
+		if (typeof child === "function") {
+			const el = child();
+			if (typeof el === "number" || typeof el === "string") {
+				let textNode = document.createTextNode("");
+				effect(() => {
+					textNode.nodeValue = child();
+				});
+				arr.push(textNode);
+			} else arr.push(el);
+		} else if (child != void 0) arr.push(child);
+	}
+	return arr;
+};
+let overflow = "";
+let count = 0;
+const generateId = () => {
+	if (count === Number.MAX_SAFE_INTEGER) {
+		overflow += count.toString(32);
+		count = 0;
+	}
+	return `${overflow}${(count++).toString(32)}`;
+};
+
+//#endregion
+//#region src/h/createDom.ts
+const update = (node, key, oldValue, newValue) => {
+	if (isEvent(key)) {
+		node.removeEventListener(getEventName(key), oldValue);
+		node.addEventListener(getEventName(key), newValue);
+	} else if (newValue === false || newValue == null) node.removeAttribute(key);
+	else node.setAttribute(key, newValue === true ? "" : newValue);
+};
+const unset = (node, key, oldValue) => {
+	if (isEvent(key)) node.removeEventListener(getEventName(key), oldValue);
+	else if (key === "ref") oldValue.current = null;
+	else node.removeAttribute(key);
+};
+const add = (node, key, newValue) => {
+	if (isEvent(key)) node.addEventListener(getEventName(key), newValue);
+	else if (key === "ref") {
+		getCurrentInstance()?.disposes.push(() => {
+			newValue.current = null;
+		});
+		newValue.current = node;
+	} else newValue !== false && newValue != null && node.setAttribute(key, newValue === true ? "" : newValue);
+};
+const createDom = (tag, props, children) => {
+	const node = tag;
+	let oldProps = {};
+	props && effect(() => {
+		const newProps = { ...props() };
+		const newKeys = Object.keys(newProps);
+		const oldKeys = Object.keys(oldProps);
+		const allKeys = new Set([...newKeys, ...oldKeys]);
+		for (const key of allKeys) oldKeys.includes(key) ? newKeys.includes(key) ? Object.is(oldProps[key], newProps[key]) || update(node, key, oldProps[key], newProps[key]) : unset(node, key, oldProps[key]) : add(node, key, newProps[key]);
+		oldProps = newProps;
+	});
+	node.lazyInit?.();
+	if (children && (node.lazyInit ? !node.shadowRoot ? false : true : true)) node.append(...getChildren([].concat(children())));
+	return node;
+};
+
+//#endregion
+//#region src/h/instance.ts
+const stack = [];
+const getCurrentInstance = () => stack.at(-1);
+const instanceInit = (parent) => {
+	const id = generateId();
+	const parentInstance = parent ?? getCurrentInstance();
+	const instance = {
+		parent: parentInstance,
+		id,
+		range: [document.createTextNode(""), document.createTextNode("")],
+		disposes: []
+	};
+	if (parentInstance) if (parentInstance.children) parentInstance.children.push(instance);
+	else parentInstance.children = [instance];
+	return instance;
+};
+const instanceCreateElement = (instance, runner) => {
+	stack.push(instance);
+	const fragment = createDom(document.createDocumentFragment(), void 0, () => runner());
+	fragment.prepend(instance.range[0]);
+	fragment.append(instance.range[1]);
+	stack.pop();
+	return fragment;
+};
+const instanceCreate = (runner, parent) => {
+	const instance = instanceInit(parent);
+	return [instance, instanceCreateElement(instance, runner)];
+};
+const instanceGetElements = (instance) => {
+	const [start, end] = instance.range;
+	const els = [start];
+	let index = start;
+	while (index = index.nextSibling) {
+		els.push(index);
+		if (index === end) break;
+	}
+	return els;
+};
+const instanceDestroy = (parent, instance) => {
+	const stack$1 = [instance];
+	while (stack$1.length) {
+		const instance$1 = stack$1.pop();
+		instance$1.disposes.forEach((dispose) => dispose());
+		if (instance$1.children) stack$1.push(...instance$1.children);
+	}
+};
+
+//#endregion
+//#region src/api/effect.ts
+const effect = (effectFn) => {
+	const effectInstance = effect$1(effectFn);
+	getCurrentInstance()?.disposes?.push(() => effectInstance.dispose());
+	return effectInstance;
+};
+
+//#endregion
+//#region src/api/ref.ts
+function ref(init) {
+	return { current: init ?? null };
+}
+
+//#endregion
+//#region src/brand.ts
+const BRAND = "j20";
+
+//#endregion
+//#region src/web-components.ts
+let host;
+const setHost = (h) => host = h;
+const getHost = () => host;
+const registerWebComponent = (Comp) => {
+	if (!Comp.customElement) throw new Error("Custom element options is not provided");
+	if (customElements.get(Comp.customElement.tag)) throw new Error("Custom element tag is already defined");
+	const NewClass = buildClass(Comp);
+	customElements.define(Comp.customElement.tag, NewClass);
+};
+const buildClass = (Comp) => {
+	const { customElement } = Comp;
+	const { a2p, a2v } = buildMap(customElement);
+	return class NewElementClass extends HTMLElement {
+		static get observedAttributes() {
+			return Object.entries(customElement.props ?? {}).map(([, value]) => value.attribute).filter((i) => i != void 0);
+		}
+		#shadow;
+		#props = {};
+		brand = BRAND;
+		customElement = customElement;
+		lazy;
+		constructor(lazy) {
+			super();
+			this.lazy = lazy;
+			if (customElement.tag && customElement.shadow) this.#shadow = this.attachShadow({ mode: customElement.shadow });
+			this.#props = Object.entries(customElement.props ?? {}).reduce((acc, [key, value]) => {
+				acc[key] = signal(value.attribute ? a2v[value.attribute](this.getAttribute(value.attribute)) : void 0);
+				return acc;
+			}, {});
+		}
+		lazyInit() {
+			setHost(this);
+			const host$1 = this;
+			const [, fragment] = instanceCreate(() => {
+				return Comp(computed(() => {
+					return new Proxy(this.#props, { get(target, p, receiver) {
+						if (typeof p === "string" && p.startsWith("on")) return (detail) => host$1.dispatchEvent(new CustomEvent(p.slice(2).toLocaleLowerCase(), { detail }));
+						else return Reflect.get(target, p, receiver)?.value;
+					} });
+				}));
+			}, getCurrentInstance());
+			setHost(void 0);
+			if (this.#shadow) this.#shadow.appendChild(fragment);
+			else this.appendChild(fragment);
+		}
+		appendToShadowDom(elements) {
+			if (this.#shadow && elements.length > 0) this.#shadow.append(...elements);
+		}
+		appendToLightDom(elements) {
+			if (this.#shadow && elements.length > 0) this.append(...elements);
+		}
+		appendToBody(elements) {
+			if (elements.length > 0) this.append(...elements);
+		}
+		attributeChangedCallback(name, oldValue, newValue) {
+			if (this.lazy) return;
+			const attrs = NewElementClass.observedAttributes;
+			const propSignal = this.#props[a2p[name]];
+			if (propSignal && attrs.includes(name)) propSignal.value = a2v[name](newValue);
+		}
+		#connectedCallbackArray = [];
+		addConnectedCallback(callback) {
+			this.#connectedCallbackArray.push(callback);
+		}
+		connectedCallback() {
+			this.#connectedCallbackArray.forEach((fn) => fn());
+		}
+		#disconnectedCallbackArray = [];
+		addDisconnectedCallback(callback) {
+			this.#disconnectedCallbackArray.push(callback);
+		}
+		disconnectedCallback() {
+			this.#disconnectedCallbackArray.forEach((fn) => fn());
+		}
+	};
+};
+const buildMap = (customElement) => {
+	const a2p = {};
+	const p2a = {};
+	const a2v = {};
+	Object.entries(customElement.props ?? {}).map(([key, value]) => [
+		value.attribute,
+		key,
+		value.type
+	]).filter(([attr]) => attr != void 0).forEach((i) => {
+		a2p[i[0]] = i[1];
+		p2a[i[1]] = i[0];
+		a2v[i[0]] = {
+			string: (v) => v ?? void 0,
+			number: (v) => v ? Number(v) : void 0,
+			boolean: (v) => v == null ? false : true
+		}[i[2]];
+	});
+	return {
+		a2p,
+		p2a,
+		a2v
+	};
+};
+
+//#endregion
+//#region src/api/wc.ts
+const wc = () => {
+	const host$1 = getHost();
+	if (!host$1) throw new Error("host not found, please use `wc` in web component");
+	const emit = (name, detail) => {
+		host$1.dispatchEvent(new CustomEvent(name, { detail }));
+	};
+	const onConnectedCallback = (callback) => {
+		host$1.addConnectedCallback(callback);
+	};
+	const onDisconnectedCallback = (callback) => {
+		host$1.addDisconnectedCallback(callback);
+	};
+	return {
+		host: host$1,
+		emit,
+		onConnectedCallback,
+		onDisconnectedCallback
+	};
+};
+
+//#endregion
+//#region src/api/dollar.ts
+const $ = (val) => val;
+
+//#endregion
+//#region src/api/utils.ts
+const isSignal = (a) => a?.brand === Symbol.for("preact-signals");
+
+//#endregion
+//#region src/api/context.ts
+const contextWeakMap = /* @__PURE__ */ new WeakMap();
+const context = (Context) => {
+	let index = getCurrentInstance()?.parent;
+	while (index) if (contextWeakMap.has(index)) {
+		const { ctx, value } = contextWeakMap.get(index);
+		if (ctx === Context) return value;
+	} else index = index.parent;
+	return Context.defaultValue;
+};
+const createContext = (defaultValue) => {
+	const Context = (p) => {
+		const props = p;
+		const instance = instanceInit(getCurrentInstance());
+		contextWeakMap.set(instance, {
+			ctx: Context,
+			value: { get value() {
+				return props.value.value;
+			} }
+		});
+		return instanceCreateElement(instance, () => props.value.children);
+	};
+	Context.isLogic = true;
+	const Consumer = (p) => {
+		const props = p;
+		const data = context(Context);
+		if (data) return props.value.children(data);
+		return props.value.children(isSignal(defaultValue) ? defaultValue : { get value() {
+			return defaultValue;
+		} });
+	};
+	Consumer.isLogic = true;
+	Context.Consumer = Consumer;
+	Context.defaultValue = defaultValue;
+	return Context;
+};
+const $useContext = (c) => context(c.value);
+
+//#endregion
+//#region src/control/For.ts
+function insertAfter(parentNode, newNode, targetNode) {
+	parentNode?.insertBefore(newNode, targetNode.nextSibling);
+}
+const isSame = (a, b, trait) => {
+	return Object.is(trait(a), trait(b));
+};
+const defaultTrait = (a) => a;
+const For = (p) => {
+	let initialized = false;
+	const currentInstance = getCurrentInstance();
+	let oldList = [];
+	let oldListItems = [];
+	let initElements = [];
+	effect(() => {
+		const props = p.value;
+		const trait = props.trait ?? defaultTrait;
+		const newList = props.of;
+		if (import.meta.env.DEV) {
+			const traitMap = /* @__PURE__ */ new Map();
+			const duplicates = [];
+			for (const item of newList) {
+				const traitValue = trait(item);
+				if (!traitMap.has(traitValue)) traitMap.set(traitValue, []);
+				traitMap.get(traitValue).push(item);
+				if (traitMap.get(traitValue).length === 2) duplicates.push(...traitMap.get(traitValue));
+			}
+			if (duplicates.length > 0) console.warn("[j20 For] Duplicate trait values detected in list. Each item should have a unique trait value for optimal performance. Duplicates found:", duplicates);
+		}
+		const newListItems = new Array(newList.length);
+		let i = 0;
+		const l2 = newList.length;
+		let e1 = oldList.length - 1;
+		let e2 = l2 - 1;
+		while (i <= e1 && i <= e2) if (isSame(oldList[i], newList[i], trait)) {
+			newListItems[i] = oldListItems[i];
+			i++;
+		} else break;
+		while (i <= e1 && i <= e2) if (isSame(oldList[e1], newList[e2], trait)) {
+			newListItems[e2] = oldListItems[e1];
+			e1--;
+			e2--;
+		} else break;
+		if (i > e1) {
+			if (i <= e2) for (; i <= e2; i++) {
+				const newIndex = signal(i);
+				const [newInstance, newInstanceFragment] = instanceCreate(() => {
+					return untrack(() => props.children)(newList[i], newIndex);
+				}, currentInstance);
+				if (!initialized) initElements.push(newInstanceFragment);
+				else if (i > 0) {
+					const prevEl = (newListItems[i - 1]?.instance)?.range[1] ?? currentInstance.range[0];
+					insertAfter(prevEl.parentNode, newInstanceFragment, prevEl);
+				} else currentInstance.range[0].parentNode?.insertBefore(newInstanceFragment, currentInstance.range[0]);
+				newListItems[i] = {
+					index: newIndex,
+					item: newList[i],
+					instance: newInstance
+				};
+			}
+		} else if (i > e2) while (i <= e1) {
+			instanceGetElements(oldListItems[i].instance).forEach((el) => {
+				el.parentNode?.removeChild(el);
+			});
+			instanceDestroy(currentInstance, oldListItems[i].instance);
+			i++;
+		}
+		else {
+			const s1 = i;
+			const s2 = i;
+			const keyToNewIndexMap = /* @__PURE__ */ new Map();
+			for (let i$1 = s2; i$1 <= e2; i$1++) keyToNewIndexMap.set(trait(newList[i$1]), i$1);
+			const toBePatched = e2 - s2 + 1;
+			const newIndexToOldIndexMap = new Array(toBePatched);
+			for (let i$1 = 0; i$1 < toBePatched; i$1++) newIndexToOldIndexMap[i$1] = 0;
+			let patched = 0;
+			let moved = false;
+			let maxNewIndexSoFar = 0;
+			for (let i$1 = s1; i$1 <= e1; i$1++) {
+				if (patched >= toBePatched) {
+					instanceGetElements(oldListItems[i$1].instance).forEach((el) => {
+						el.parentNode?.removeChild(el);
+					});
+					instanceDestroy(currentInstance, oldListItems[i$1].instance);
+					continue;
+				}
+				const oldItem = oldList[i$1];
+				const oldKey = trait(oldItem);
+				const newIndex = keyToNewIndexMap.get(oldKey);
+				if (newIndex === void 0) {
+					instanceGetElements(oldListItems[i$1].instance).forEach((el) => {
+						el.parentNode?.removeChild(el);
+					});
+					instanceDestroy(currentInstance, oldListItems[i$1].instance);
+				} else {
+					newIndexToOldIndexMap[newIndex - s2] = i$1 + 1;
+					if (newIndex >= maxNewIndexSoFar) maxNewIndexSoFar = newIndex;
+					else moved = true;
+					newListItems[newIndex] = oldListItems[i$1];
+					patched++;
+				}
+			}
+			const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : [];
+			let j = increasingNewIndexSequence.length - 1;
+			for (let i$1 = toBePatched - 1; i$1 >= 0; i$1--) {
+				const newIndex = s2 + i$1;
+				const newItem = newList[newIndex];
+				const anchor = newIndex + 1 < l2 ? newListItems[newIndex + 1].instance.range[0] : currentInstance.range[1];
+				if (newIndexToOldIndexMap[i$1] === 0) {
+					const newIdx = signal(newIndex);
+					const [newInstance, newInstanceFragment] = instanceCreate(() => {
+						return untrack(() => props.children)(newItem, newIdx);
+					}, currentInstance);
+					anchor.parentNode?.insertBefore(newInstanceFragment, anchor);
+					newListItems[newIndex] = {
+						index: newIdx,
+						item: newItem,
+						instance: newInstance
+					};
+				} else if (moved) if (j < 0 || i$1 !== increasingNewIndexSequence[j]) {
+					const nodeToMove = newListItems[newIndex];
+					instanceGetElements(nodeToMove.instance).forEach((el) => {
+						anchor.parentNode?.insertBefore(el, anchor);
+					});
+				} else j--;
+			}
+		}
+		oldList = newList;
+		oldListItems = newListItems;
+		currentInstance.children = newListItems.map((item, index) => {
+			item.index.value = index;
+			return item.instance;
+		});
+	});
+	initialized = true;
+	return initElements.splice(0, initElements.length);
+};
+function getSequence(arr) {
+	const p = arr.slice();
+	const result = [0];
+	let i, j, u, v, c;
+	const len = arr.length;
+	for (i = 0; i < len; i++) {
+		const arrI = arr[i];
+		if (arrI !== 0) {
+			j = result[result.length - 1];
+			if (arr[j] < arrI) {
+				p[i] = j;
+				result.push(i);
+				continue;
+			}
+			u = 0;
+			v = result.length - 1;
+			while (u < v) {
+				c = u + v >> 1;
+				if (arr[result[c]] < arrI) u = c + 1;
+				else v = c;
+			}
+			if (arrI < arr[result[u]]) {
+				if (u > 0) p[i] = result[u - 1];
+				result[u] = i;
+			}
+		}
+	}
+	u = result.length;
+	v = result[u - 1];
+	while (u-- > 0) {
+		result[u] = v;
+		v = p[v];
+	}
+	return result;
+}
+
+//#endregion
+//#region src/h/createComponent.ts
+const createComponent = (tag, props) => {
+	const runner = () => tag(computed(() => props ? props() : {}));
+	let [, fragment] = instanceCreate(runner);
+	return fragment;
+};
+
+//#endregion
+//#region src/control/If.ts
+const If = (p) => {
+	const props = p;
+	const arr = computed(() => !props.value.of ? [0] : [1]);
+	return createComponent(For, () => ({
+		get of() {
+			return arr.value;
+		},
+		get children() {
+			return (bool) => {
+				if (bool) {
+					const children = props.value.children;
+					if (typeof children === "function") return children(true);
+					else return children;
+				} else {
+					const elseCondition = props.value.else;
+					if (typeof elseCondition === "function") return elseCondition(false);
+					else return elseCondition;
+				}
+			};
+		}
+	}));
+};
+If.isLogic = true;
+
+//#endregion
+//#region src/control/Dynamic.ts
+const Dynamic = (p) => {
+	const props = p;
+	let count$1 = 0;
+	const list = computed(() => {
+		props.value.of;
+		return [count$1 = (count$1 + 1) % 2];
+	});
+	return createComponent(For, () => ({
+		of: list.value,
+		get children() {
+			return (item) => {
+				const children = props.value.children;
+				return typeof children === "function" ? children(item) : children;
+			};
+		}
+	}));
+};
+Dynamic.isLogic = true;
+
+//#endregion
+//#region src/control/Switch.ts
+const Switch = (p) => {
+	const children = p.value.children;
+	const res = computed(() => children.filter((i) => i.valid)[0]);
+	return createComponent(For, () => ({
+		of: res.value ? [res.value] : [],
+		trait: (item) => item.id,
+		get children() {
+			return (item) => item.children;
+		}
+	}));
+};
+Switch.isLogic = true;
+const Case = (p) => {
+	const props = p;
+	return {
+		id: generateId(),
+		get valid() {
+			return props.value.of;
+		},
+		get children() {
+			return props.value.children;
+		}
+	};
+};
+Case.isLogic = true;
+const Default = (p) => {
+	const props = p;
+	return {
+		id: generateId(),
+		get valid() {
+			return true;
+		},
+		get children() {
+			return props.value.children;
+		}
+	};
+};
+Default.isLogic = true;
+
+//#endregion
+//#region src/h/createLogicComponent.ts
+const createLogicComponent = (tag, props) => {
+	return tag(computed(() => props ? props() : {}));
+};
+
+//#endregion
+//#region src/h/createWebComponent.ts
+const createWebComponent = (tag, props) => {
+	const runner = () => {
+		const customElement = tag.customElement;
+		const Exist = customElements.get(customElement.tag);
+		let el;
+		if (Exist) if (Exist.brand !== BRAND) throw new Error(`Custom element [${customElement.tag}] is already registered`);
+		else el = new Exist(true);
+		else {
+			const NewClass = buildClass(tag);
+			customElements.define(customElement.tag, NewClass);
+			el = new NewClass(true);
+		}
+		let childrenGetter = () => untrack(() => props ? props().children : void 0);
+		setHost(el);
+		const ret = tag(computed(() => {
+			const retProps = props ? props() : {};
+			childrenGetter = Object.getOwnPropertyDescriptor(retProps, "children")?.get ?? (() => void 0);
+			delete retProps.children;
+			return retProps;
+		}));
+		setHost(void 0);
+		if (el.customElement.shadow) {
+			el.appendToShadowDom(getChildren([].concat(ret)));
+			childrenGetter && el.appendToLightDom(getChildren([].concat(childrenGetter())));
+		} else el.appendToBody(getChildren([].concat(ret)));
+		return el;
+	};
+	let [, fragment] = instanceCreate(runner);
+	return fragment;
+};
+
+//#endregion
+//#region src/h/createElement.ts
+const createElement = (tag, props, children) => {
+	return tag instanceof Node ? createDom(tag, props, children) : "isLogic" in tag ? createLogicComponent(tag, props) : "customElement" in tag ? createWebComponent(tag, props) : createComponent(tag, props);
+};
+
+//#endregion
+//#region src/h/createRoot.ts
+const creatRoot = (boot) => {
+	let [instance, fragment] = instanceCreate(() => boot());
+	return {
+		element: fragment,
+		instance
+	};
+};
+
+//#endregion
+//#region src/jsx-runtime.ts
+const h2 = (tag, props, children) => {
+	return createElement(tag, props, children);
+};
+const jsx = h2;
+const jsxs = h2;
+const Fragment = (props) => props.value.children;
+const template = (template$1) => {
+	let dom;
+	return (isSvg) => {
+		if (!dom) {
+			const templateEl = isSvg ? document.createElementNS("http://www.w3.org/2000/svg", "svg") : document.createElement("div");
+			templateEl.innerHTML = template$1;
+			dom = templateEl.firstChild;
+			return dom.cloneNode();
+		} else return dom.cloneNode();
+	};
+};
+
+//#endregion
+export { $, $useContext, Case, Computed, Default, Dynamic, Effect, For, Fragment, If, Signal, Switch, computed, creatRoot, createComponent, createContext, createDom, createElement, createLogicComponent, effect, getCurrentInstance, h2, instanceCreate, instanceCreateElement, instanceDestroy, instanceGetElements, instanceInit, jsx, jsxs, ref, registerWebComponent, signal, template, wc };