@potok-web-framework/core 0.1.0 → 0.3.0

package/dist/block.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from './signals';
+import { LibContext, LibHtmlElementNode, LibNode, LibProps } from './types';
+export declare abstract class LibBlock {
+    node: LibNode | null;
+    abstract context: LibContext;
+    abstract props: LibProps;
+    effects: Effect[];
+    children: (LibBlock | null)[];
+    get nearestParentElement(): LibHtmlElementNode | null;
+    get previousBlock(): LibBlock | null;
+    get nearestPreviousNode(): LibNode | null;
+    get previousNode(): LibNode | null;
+    addEffect(effect: Effect): void;
+    unmountChildren(): void;
+    insertNode(): void;
+    unmount(): void;
+}

package/dist/bootstrap-app.d.ts

@@ -0,0 +1,8 @@
+import { PotokElement } from './types';
+type App = (request: Request) => PotokElement;
+type BootstrapAppOptions = {
+    app: App;
+    port?: number;
+};
+export declare function bootstrapApp(options: BootstrapAppOptions): void;
+export {};

package/dist/client-only.d.ts

@@ -0,0 +1,3 @@
+import { PotokElement, WithChildren } from './types';
+export type ClientOnlyProps = WithChildren<{}>;
+export declare function ClientOnly(props: ClientOnlyProps): PotokElement;

package/dist/client.mjs

@@ -0,0 +1,133 @@
+import { a as objectKeys, c as createEffect, l as createSignal, p as untrack, u as deepTrack } from "./utils-CAe_kbSH.mjs";
+import { n as HTML_ELEMENT_STYLE_PX_PROPERTIES } from "./constants-BOAOReQ3.mjs";
+function renderToDOM(o) {
+	let s = o.root ?? document, c = /* @__PURE__ */ new Map(), l = createSignal({
+		portals: {},
+		listeners: {},
+		isHydrating: o.needToHydrate ?? !1
+	});
+	function u(e) {
+		let t = e.replace(/^on([A-Z])/, (e, t) => t.toLowerCase());
+		document.addEventListener(t, (t) => {
+			let n = !1, r = t.target, i = t.stopPropagation.bind(t), a = t.stopImmediatePropagation.bind(t);
+			for (t.stopPropagation = () => {
+				n = !0, i();
+			}, t.stopImmediatePropagation = () => {
+				n = !0, a();
+			}; r;) {
+				let i = l.listeners[e]?.get(r);
+				if (i && (Object.defineProperty(t, "currentTarget", {
+					configurable: !0,
+					enumerable: !0,
+					get: () => r
+				}), i(t), n)) break;
+				r = r.parentElement;
+			}
+		});
+	}
+	let d = /* @__PURE__ */ new Set();
+	createEffect(() => {
+		deepTrack(l.listeners, 1), untrack(() => {
+			objectKeys(l.listeners).forEach((e) => {
+				d.has(e) || (u(e), d.add(e));
+			});
+		});
+	}, !0);
+	let f = (e, t, n) => e.insertBefore(t, n ? n.nextSibling : e.firstChild), p = (e) => e instanceof HTMLElement;
+	if (!o.needToHydrate) for (; s.firstChild;) s.removeChild(s.firstChild);
+	o.app()({
+		parentBlock: null,
+		index: 0,
+		portals: l.portals,
+		contexts: {},
+		listeners: l.listeners,
+		isServer: !1,
+		promises: [],
+		get isHydrating() {
+			return l.isHydrating;
+		},
+		insertNode(e, t, n) {
+			if (l.isHydrating) {
+				if (e === null) c.set(t, document.querySelector("html"));
+				else {
+					let r = c.get(e);
+					if (!r) throw Error("Ошибка гидрации");
+					let i = null;
+					if (n) {
+						let e = c.get(n);
+						if (!e) throw Error("Ошибка гидрации");
+						i = e.nextSibling;
+					} else i = r.firstChild;
+					for (;;) {
+						if (!i) throw Error("Ошибка гидрации");
+						if (t.type === "text" && String(t.props.text) === i.textContent || t.type === "html-element" && p(i) && t.props.tag === i.tagName.toLowerCase()) {
+							c.set(t, i);
+							break;
+						} else {
+							let e = i;
+							i = i.nextSibling, e.parentElement?.removeChild(e);
+						}
+					}
+				}
+				return;
+			}
+			e && !c.has(e) && c.set(e, document.createElement(e.props.tag));
+			let r = e ? c.get(e) : s, i = (n && c.get(n)) ?? null;
+			if (t.type === "text") {
+				let e = document.createTextNode(String(t.props.text));
+				c.set(t, e), this.updateTextNode(t), f(r, e, i);
+			} else if (t.type === "html-element") {
+				c.has(t) || c.set(t, document.createElement(t.props.tag));
+				for (let [e, n] of Object.entries(Object.getOwnPropertyDescriptors(t.props))) {
+					if ([
+						"tag",
+						"children",
+						"ref"
+					].includes(e)) continue;
+					let r = n.get?.() ?? n.value;
+					this.updateHtmlElementNodeProp(t, e, r);
+				}
+				let e = c.get(t);
+				f(r, e, i), t.props.ref && (t.props.ref.element = e);
+			} else throw Error("Неверный тип ноды");
+		},
+		updateTextNode(e) {
+			let t = e.props.text, n = c.get(e);
+			n && (n.textContent = String(t));
+		},
+		updateHtmlElementNodeProp(e, t, n) {
+			let r = c.get(e);
+			if (!r) return;
+			let i = r;
+			if (((e) => e.startsWith("on"))(t)) {
+				n ? (this.listeners[t] ??= /* @__PURE__ */ new Map(), this.listeners[t].set(i, n)) : this.listeners[t]?.delete(i);
+				return;
+			}
+			if (t.startsWith("aria")) {
+				let e = t.toLowerCase().replace("aria", "aria-");
+				n ? i.setAttribute(e, n) : i.removeAttribute(e);
+				return;
+			}
+			if (t === "className") {
+				n ? i.className = n : i.removeAttribute("class");
+				return;
+			}
+			if (t === "style") {
+				n ? Object.keys(n).forEach((e) => {
+					let t = n[e];
+					if (t !== void 0) {
+						let n = String(HTML_ELEMENT_STYLE_PX_PROPERTIES.has(e) && typeof t == "number" ? `${t}px` : t);
+						i.style.setProperty(e, n);
+					} else i.style.removeProperty(e);
+				}) : i.removeAttribute("style");
+				return;
+			}
+			n == null ? i.removeAttribute(t) : i.setAttribute(t, String(n));
+		},
+		removeNode(e) {
+			let t = c.get(e);
+			t && (c.delete(e), p(t) ? t.remove() : t.parentElement?.removeChild(t));
+		}
+	}), o.needToHydrate && (l.isHydrating = !1);
+}
+export { renderToDOM };

package/dist/constants-BOAOReQ3.mjs

@@ -0,0 +1,26 @@
+const HTML_ELEMENT_STYLE_PX_PROPERTIES = new Set([
+	"width",
+	"height",
+	"top",
+	"left",
+	"right",
+	"bottom",
+	"margin",
+	"marginTop",
+	"marginBottom",
+	"marginLeft",
+	"marginRight",
+	"padding",
+	"paddingTop",
+	"paddingBottom",
+	"paddingLeft",
+	"paddingRight",
+	"fontSize",
+	"borderWidth",
+	"borderRadius",
+	"maxWidth",
+	"minWidth",
+	"maxHeight",
+	"minHeight"
+]), CLIENT_ENTRY_FILE_NAME = "client";
+export { HTML_ELEMENT_STYLE_PX_PROPERTIES as n, CLIENT_ENTRY_FILE_NAME as t };

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const HTML_ELEMENT_STYLE_PX_PROPERTIES: Set<string>;
+export declare const CLIENT_ENTRY_FILE_NAME = "client";

package/dist/context.d.ts

@@ -0,0 +1,12 @@
+import { MaybeArray, PotokElement, WithChildren } from './types';
+type ContextProviderProps<Value extends Record<string, unknown>> = WithChildren<{
+    value: Value;
+}>;
+type ContextConsumerProps<Value extends Record<string, unknown>> = {
+    children: MaybeArray<(value: Value) => PotokElement>;
+};
+export declare function createContext<Value extends Record<string, unknown>>(): {
+    provider(props: ContextProviderProps<Value>): PotokElement;
+    reader(props: ContextConsumerProps<Value>): PotokElement;
+};
+export {};

package/dist/detect-child.d.ts

@@ -0,0 +1,6 @@
+import { Child } from './types';
+type DetectChildProps = {
+    readonly value: Child;
+};
+export declare function detectChild(props: DetectChildProps): Child;
+export {};

package/dist/error-boundary.d.ts

@@ -0,0 +1,5 @@
+import { PotokElement, WithChildren } from './types';
+export type ErrorBoundaryProps = WithChildren<{
+    onError?: (error: Error) => void;
+}>;
+export declare function ErrorBoundary(props: ErrorBoundaryProps): PotokElement;

package/dist/exports/client.d.ts

@@ -0,0 +1 @@
+export { renderToDOM } from '../render-to-dom';

package/dist/exports/hmr.d.ts

@@ -0,0 +1 @@
+export { registerComponent } from '../hmr/register-component';

package/dist/exports/index.d.ts

@@ -0,0 +1,14 @@
+export { ClientOnly } from '../client-only';
+export { ErrorBoundary } from '../error-boundary';
+export { Lazy } from '../lazy';
+export { LibContextReader } from '../lib-context-reader';
+export { LibScripts } from '../lib-scripts';
+export { Lifecycle } from '../lifecycle';
+export { List } from '../list';
+export { PortalIn, PortalOut } from '../portal';
+export { createElementReference } from '../ref';
+export { Show } from '../show';
+export { createSignal, createEffect, batch, untrack, deepTrack, getSignal, } from '../signals';
+export { createStore } from '../store';
+export type { PotokElement, WithChildren } from '../types';
+export type * from '../jsx-types.ts';

package/dist/exports/jsx-runtime.d.ts

@@ -0,0 +1,4 @@
+export { fragment } from '../fragment';
+export { htmlElement } from '../html-element';
+export { text } from '../text';
+export { detectChild } from '../detect-child';

package/dist/exports/server.d.ts

@@ -0,0 +1 @@
+export { bootstrapApp } from '../bootstrap-app';

package/dist/fragment-BahmURhz.mjs

@@ -0,0 +1,17 @@
+import { _ as LibBlock, i as normalizeChildren, n as mergeContext } from "./utils-CAe_kbSH.mjs";
+var FragmentClass = class extends LibBlock {
+	constructor(e, n) {
+		super(), this.props = e, this.context = n, normalizeChildren(e.children).forEach((e, t) => {
+			this.children.push(e(mergeContext(n, {
+				parentBlock: this,
+				index: t
+			})));
+		});
+	}
+};
+function fragment(e) {
+	return function(t) {
+		return new FragmentClass(e, t);
+	};
+}
+export { fragment as t };

package/dist/fragment.d.ts

@@ -0,0 +1,4 @@
+import { PotokElement, WithChildren } from './types';
+type FragmentProps = WithChildren<{}>;
+export declare function fragment(props: FragmentProps): PotokElement;
+export {};

package/dist/hmr/hmr-dev.d.ts

@@ -0,0 +1,9 @@
+import { CachedInstanceState } from './registered-component';
+import { HMRRegistry } from './registry';
+export declare const HMR_DEV: {
+    registry: HMRRegistry;
+    currentInstance: {
+        states: CachedInstanceState[];
+        stateIndex: number;
+    } | null;
+};

package/dist/hmr/register-component.d.ts

@@ -0,0 +1,2 @@
+import { Component, ComponentProps, PotokElement } from '../types';
+export declare function registerComponent<Props extends ComponentProps>(component: (props: Props) => PotokElement, moduleId: string, componentId: string): Component<Props>;

package/dist/hmr/registered-component.d.ts

@@ -0,0 +1,23 @@
+import { Component, PotokElement } from '../types';
+import { HMRSubscriber } from './types';
+export type CachedInstanceState = {
+    current: unknown;
+    initial: unknown;
+};
+type CachedInstance = {
+    isRemovable: boolean;
+    element: PotokElement;
+    states: CachedInstanceState[];
+};
+export declare class RegisteredComponent {
+    component: Component<any>;
+    subscribers: Set<HMRSubscriber>;
+    private cachedInstances;
+    constructor(component: Component<any>);
+    getCachedInstance(instanceId: string): CachedInstance | undefined;
+    addCachedInstance(instanceId: string, element: PotokElement, states: CachedInstanceState[]): void;
+    markInstanceAsRemovable(instanceId: string): void;
+    unmarkInstanceAsRemovable(instanceId: string): void;
+    removeCachedInstance(instanceId: string): void;
+}
+export {};

package/dist/hmr/registry.d.ts

@@ -0,0 +1,12 @@
+import { Component } from '../types';
+import { ComponentId, HMRSubscriber, ModudeId } from './types';
+import { RegisteredComponent } from './registered-component';
+export declare class HMRRegistry {
+    private components;
+    private getModuleComponentsMap;
+    addComponent(moduleId: ModudeId, componentId: ComponentId, component: Component<any>): RegisteredComponent;
+    getRegisteredComponent(moduleId: ModudeId, componentId: ComponentId): RegisteredComponent | undefined;
+    subscribeToComponent(moduleId: ModudeId, componentId: ComponentId, subscriber: HMRSubscriber): () => void;
+    unsubscribeFromComponent(moduleId: ModudeId, componentId: ComponentId, subscriber: HMRSubscriber): void;
+    notifyComponentUpdate(moduleId: ModudeId, componentId: ComponentId): void;
+}

package/dist/hmr/types.d.ts

@@ -0,0 +1,4 @@
+import { RegisteredComponent } from './registered-component';
+export type HMRSubscriber = (component: RegisteredComponent | undefined) => void;
+export type ModudeId = string;
+export type ComponentId = string;

package/dist/hmr/utils.d.ts

@@ -0,0 +1,3 @@
+import { LibContext } from '../types';
+export declare function isWindowDefined(): boolean;
+export declare function getComponentInstanceId(context: LibContext): string;

package/dist/hmr.mjs

@@ -0,0 +1,42 @@
+import { g as HMR_DEV, h as isWindowDefined, l as createSignal, m as getComponentInstanceId } from "./utils-CAe_kbSH.mjs";
+import { n as Show, r as LibContextReader, t as Lifecycle } from "./lifecycle-4vjEuXGy.mjs";
+import { t as fragment } from "./fragment-BahmURhz.mjs";
+function registerComponent(o, s, c) {
+	if (!isWindowDefined()) return o;
+	let l = HMR_DEV.registry.addComponent(s, c, o);
+	HMR_DEV.registry.notifyComponentUpdate(s, c);
+	function u(e, t, n = !1) {
+		let r = getComponentInstanceId(t), i = l.getCachedInstance(r);
+		if (!n && i) return i.element;
+		HMR_DEV.currentInstance = {
+			states: i ? i.states : [],
+			stateIndex: 0
+		};
+		let a = l.component(e);
+		return l.addCachedInstance(r, a, HMR_DEV.currentInstance.states), HMR_DEV.currentInstance = null, a;
+	}
+	return (e) => LibContextReader({ children(r) {
+		let o = createSignal({ element: u(e, r) }), d = getComponentInstanceId(r);
+		return Lifecycle({
+			onMounted() {
+				let t = HMR_DEV.registry.subscribeToComponent(s, c, () => {
+					o.element = null, o.element = u(e, r, !0);
+				});
+				return l.unmarkInstanceAsRemovable(d), () => {
+					t(), l.markInstanceAsRemovable(d), setTimeout(() => {
+						l.getCachedInstance(d)?.isRemovable && l.removeCachedInstance(d);
+					});
+				};
+			},
+			children: [Show({
+				get when() {
+					return o.element !== null;
+				},
+				children: [fragment({ get children() {
+					return [o.element];
+				} })]
+			})]
+		});
+	} });
+}
+export { registerComponent };

package/dist/html-element-Cm0RtMkT.mjs

@@ -0,0 +1,42 @@
+import { _ as LibBlock, a as objectKeys, c as createEffect, i as normalizeChildren, n as mergeContext, t as extractListenersFromProps } from "./utils-CAe_kbSH.mjs";
+var LibHTMLElement = class extends LibBlock {
+	constructor(e, t) {
+		super(), this.props = e, this.context = t;
+		let a = {
+			type: "html-element",
+			context: t,
+			props: e
+		};
+		this.node = a;
+		let o = Object.getOwnPropertyDescriptors(e);
+		for (let [e, r] of Object.entries(o)) {
+			if ([
+				"tag",
+				"children",
+				"ref"
+			].includes(e)) continue;
+			r.value && t.updateHtmlElementNodeProp(a, e, r.value);
+			let i = r.get;
+			i && this.addEffect(createEffect(() => {
+				t.updateHtmlElementNodeProp(a, e, i());
+			}, !0));
+		}
+		t.isHydrating && this.insertNode(), normalizeChildren(e.children).forEach((e, n) => {
+			this.children.push(e(mergeContext(t, {
+				parentBlock: this,
+				index: n
+			})));
+		}), t.isHydrating || this.insertNode();
+	}
+	unmount() {
+		this.node && objectKeys(extractListenersFromProps(this.props)).forEach((e) => {
+			this.context.listeners[e]?.delete(this.node);
+		}), this.props.ref && (this.props.ref.element = null), super.unmount();
+	}
+};
+function htmlElement(e) {
+	return function(t) {
+		return new LibHTMLElement(e, t);
+	};
+}
+export { htmlElement as t };

package/dist/html-element.d.ts

@@ -0,0 +1,6 @@
+import { LibHTMLElementTagNameMap } from './prop-types';
+import { PotokElement } from './types';
+export type LibHTMLElementProps<Tag extends keyof LibHTMLElementTagNameMap> = {
+    tag: Tag;
+} & LibHTMLElementTagNameMap[Tag];
+export declare function htmlElement<Tag extends keyof LibHTMLElementTagNameMap>(props: LibHTMLElementProps<Tag>): PotokElement;

package/dist/index.mjs

@@ -0,0 +1,199 @@
+import { _ as LibBlock, c as createEffect, d as getSignal, f as isSignal, i as normalizeChildren, l as createSignal, n as mergeContext, p as untrack, r as normalizeArray, s as batch, u as deepTrack } from "./utils-CAe_kbSH.mjs";
+import { n as Show, r as LibContextReader, t as Lifecycle } from "./lifecycle-4vjEuXGy.mjs";
+import { t as fragment } from "./fragment-BahmURhz.mjs";
+import { n as PortalOut, t as PortalIn } from "./portal-CbcYOHLv.mjs";
+function ClientOnly(e) {
+	return LibContextReader({ children: (t) => Show({
+		get when() {
+			return !t.isServer && !t.isHydrating;
+		},
+		children: e.children
+	}) });
+}
+var ErrorBoundaryClass = class extends LibBlock {
+	constructor(e, t) {
+		super(), this.props = e, this.context = t;
+		try {
+			normalizeChildren(e.children).forEach((e, n) => {
+				this.children.push(e(mergeContext(t, {
+					parentBlock: this,
+					index: n
+				})));
+			});
+		} catch (t) {
+			e.onError?.(this.buildError(t));
+		}
+	}
+	unmount() {
+		try {
+			super.unmount();
+		} catch (e) {
+			this.props.onError?.(this.buildError(e));
+		}
+	}
+	buildError(e) {
+		return e instanceof Error ? e : Error(typeof e == "string" ? e : "Unknown error");
+	}
+};
+function ErrorBoundary(e) {
+	return function(t) {
+		return new ErrorBoundaryClass(e, t);
+	};
+}
+function Lazy(e) {
+	return LibContextReader({ children: (t) => {
+		let n = createSignal({ block: null });
+		return t.promises.push(e.import().then((t) => {
+			n.block = e.resolve(t);
+		})), fragment({ children: [Show({
+			get when() {
+				return n.block !== null;
+			},
+			children: [n.block]
+		}), Show({
+			get when() {
+				return n.block === null;
+			},
+			children: [e.fallback]
+		})] });
+	} });
+}
+function LibScripts() {
+	return PortalOut({ name: "lib-scripts" });
+}
+var ListClass = class extends LibBlock {
+	signals = [];
+	constructor(e, i) {
+		super(), this.props = e, this.context = i;
+		let c = [];
+		this.addEffect(createEffect(() => {
+			let t = e.items;
+			isSignal(t) && deepTrack(t, 1), untrack(() => {
+				this.diff(c, t).forEach((t) => {
+					if (t.type === "add") {
+						let r = createSignal({
+							item: t.item,
+							index: t.index
+						});
+						this.children.splice(t.index, 0, null), this.signals.splice(t.index, 0, getSignal(r));
+						let s = e.render(r)(mergeContext(i, {
+							parentBlock: this,
+							get index() {
+								return r.index;
+							}
+						}));
+						this.children[t.index] = s;
+					} else if (t.type === "replace") this.signals[t.index].proxy.item = t.newItem;
+					else if (t.type === "delete") {
+						let e = this.children[t.index];
+						this.children.splice(t.index, 1), this.signals.splice(t.index, 1), e?.unmount();
+					}
+				}), this.signals.forEach((e, t) => {
+					e.value.index !== t && (e.proxy.index = t);
+				}), c = [...t];
+			});
+		}, !0));
+	}
+	diff(e, t) {
+		let n = [];
+		for (let r = 0; r <= e.length; r++) {
+			n.push([r]);
+			for (let i = 1; i <= t.length; i++) if (r === 0) n[r].push(i);
+			else {
+				let a = n[r - 1][i] + 1, o = n[r][i - 1] + 1, s = n[r - 1][i - 1] + (e[r - 1] === t[i - 1] ? 0 : 1);
+				n[r].push(Math.min(a, o, s));
+			}
+		}
+		let r = [], i = t.length, a = e.length;
+		for (; i > 0 || a > 0;) {
+			let o = a > 0 ? n[a - 1][i] : Infinity, s = i > 0 ? n[a][i - 1] : Infinity, c = a > 0 && i > 0 ? n[a - 1][i - 1] : Infinity, l = Math.min(o, s, c);
+			l === c ? (e[a - 1] !== t[i - 1] && r.push({
+				type: "replace",
+				index: a - 1,
+				oldItem: e[a - 1],
+				newItem: t[i - 1]
+			}), i--, a--) : l === o ? (r.push({
+				type: "delete",
+				index: a - 1
+			}), a--) : (r.push({
+				type: "add",
+				index: a,
+				item: t[i - 1]
+			}), i--);
+		}
+		return r;
+	}
+	unmount() {
+		super.unmount(), this.signals = [];
+	}
+};
+function List(e) {
+	return function(t) {
+		return new ListClass(e, t);
+	};
+}
+function createElementReference() {
+	return createSignal({ element: null });
+}
+var ContextProvider = class extends LibBlock {
+	constructor(e, t, n) {
+		super(), this.props = e, this.context = n, normalizeChildren(e.children).forEach((r, i) => {
+			this.children.push(r(mergeContext(n, {
+				parentBlock: this,
+				index: i,
+				contexts: { [t]: e.value }
+			})));
+		});
+	}
+}, ContextConsumer = class extends LibBlock {
+	constructor(e, t, n) {
+		super(), this.props = e, this.context = n;
+		let r = n.contexts[t];
+		if (!r) throw Error("Контекст не найден");
+		normalizeArray(e.children).forEach((e, t) => {
+			this.children.push(e(r)(mergeContext(n, {
+				parentBlock: this,
+				index: t
+			})));
+		});
+	}
+};
+function createContext() {
+	let e = Symbol("context");
+	return {
+		provider(t) {
+			return function(n) {
+				return new ContextProvider(t, e, n);
+			};
+		},
+		reader(t) {
+			return function(n) {
+				return new ContextConsumer(t, e, n);
+			};
+		}
+	};
+}
+function createStore() {
+	return function(e) {
+		let t = createContext();
+		return {
+			provider(n) {
+				let r = createSignal(e.state({ props: n })), i = e.actions({
+					props: n,
+					state: r
+				}), o = Object.entries(i).reduce((e, [t, n]) => (e[t] = (...e) => batch(() => n.apply(i, e)), e), {});
+				return t.provider({
+					value: {
+						state: r,
+						actions: o
+					},
+					children: n.children
+				});
+			},
+			reader(e) {
+				return t.reader({ children: (t) => e.children(t) });
+			}
+		};
+	};
+}
+export { ClientOnly, ErrorBoundary, Lazy, LibContextReader, LibScripts, Lifecycle, List, PortalIn, PortalOut, Show, batch, createEffect, createElementReference, createSignal, createStore, deepTrack, getSignal, untrack };

package/dist/jsx-runtime.mjs

@@ -0,0 +1,10 @@
+import { o as text } from "./utils-CAe_kbSH.mjs";
+import { t as fragment } from "./fragment-BahmURhz.mjs";
+import { t as htmlElement } from "./html-element-Cm0RtMkT.mjs";
+function detectChild(e) {
+	let t = e.value, n = typeof t;
+	return n === "string" || n === "number" || n === "boolean" ? text({ get text() {
+		return e.value;
+	} }) : t;
+}
+export { detectChild, fragment, htmlElement, text };

package/dist/jsx-types.d.ts

@@ -0,0 +1,11 @@
+import { LibHTMLElementTagNameMap } from './prop-types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements extends LibHTMLElementTagNameMap {
+        }
+        interface ElementChildrenAttribute {
+            children: {};
+        }
+    }
+}
+export {};

package/dist/lazy.d.ts

@@ -0,0 +1,7 @@
+import { PotokElement } from './types';
+export type LazyProps<Module> = {
+    import: () => Promise<Module>;
+    resolve: (module: Module) => PotokElement;
+    fallback?: PotokElement;
+};
+export declare function Lazy<Module>(props: LazyProps<Module>): PotokElement;