elements-kit 0.18.2 → 0.20.0

package/dist/hydrate-6Qx4n4Su.mjs

@@ -0,0 +1,380 @@
+import { C as untracked, _ as onCleanup, d as effectScope, n as CLAIM, t as ASYNC_REGION, u as effect, v as setDeferAsyncRuns } from "./lib-DYypKhxk.mjs";
+import { isReactive, resolveProps } from "./signals/index.mjs";
+import { isReactivePromiseLike } from "./utilities/promise.mjs";
+import { flushDeferredAsyncRuns, isAsyncLike } from "./utilities/async.mjs";
+import { i as applyProps, o as resolveChild, r as setRenderer, t as createElement } from "./element-D3om9yA6.mjs";
+import { n as Slot } from "./slot-Dvf30O0B.mjs";
+import { For, isForComponent } from "./for.mjs";
+import { n as isFragmentComponent, r as parseHtml, t as Fragment } from "./fragment-ROPRBJQd.mjs";
+//#region src/hydrate/claim.ts
+let hydrationContext = null;
+function setHydrationContext(ctx) {
+	const prev = hydrationContext;
+	hydrationContext = ctx;
+	return prev;
+}
+const VNODE = Symbol.for("elements-kit.vnode");
+function isVNode(value) {
+	return typeof value === "object" && value !== null && VNODE in value;
+}
+const claimRenderer = { jsx(type, props) {
+	if (typeof type === "string") return {
+		[VNODE]: true,
+		kind: "el",
+		tag: type,
+		props
+	};
+	if (isFragmentComponent(type)) return {
+		[VNODE]: true,
+		kind: "frag",
+		children: props.children,
+		html: props.html === true
+	};
+	if (isForComponent(type)) return {
+		[VNODE]: true,
+		kind: "for",
+		props
+	};
+	if (typeof type === "function" && !type.prototype?.render) return type(resolveProps(props));
+	const name = typeof type === "function" ? type.name ?? "anonymous" : String(type);
+	throw new Error(`Hydration does not support class components ("${name}"); v1 supports intrinsic elements, function components, Fragment and For.`);
+} };
+function withClaimRenderer(fn) {
+	setRenderer(claimRenderer);
+	try {
+		return fn();
+	} finally {
+		setRenderer(null);
+	}
+}
+/** Claim `container`'s existing children against the evaluated tree. */
+function claimChildren(container, root, onMismatch) {
+	walkList({
+		node: container.firstChild,
+		parent: container
+	}, root, onMismatch);
+}
+function walkList(cur, raw, om) {
+	if (raw == null || typeof raw === "boolean") return;
+	if (Array.isArray(raw)) {
+		for (const c of raw.flat(Infinity)) walkChild(cur, c, om);
+		return;
+	}
+	walkChild(cur, raw, om);
+}
+function walkChild(cur, c, om) {
+	if (c == null || typeof c === "boolean") return;
+	if (isVNode(c)) {
+		if (c.kind === "frag") {
+			if (c.html) return claimRawRegion(cur, c.children, om);
+			return walkList(cur, c.children, om);
+		}
+		if (c.kind === "for") return claimFor(cur, c, om);
+		return claimElement(cur, c, om);
+	}
+	if (isReactivePromiseLike(c) || isAsyncLike(c)) return claimAsync(cur, c, om);
+	if (typeof c === "function") return claimDynamic(cur, c, om);
+	if (c instanceof Node) return fallback(cur, om, c.nodeName, () => c);
+	claimText(cur, String(c), om);
+}
+function claimText(cur, text, om) {
+	if (text === "") return;
+	const node = cur.node;
+	if (node && node.nodeType === Node.TEXT_NODE) {
+		const data = node.data;
+		if (data === text) {
+			cur.node = node.nextSibling;
+			return;
+		}
+		if (data.startsWith(text)) {
+			node.splitText(text.length);
+			cur.node = node.nextSibling;
+			return;
+		}
+	}
+	fallback(cur, om, text, () => document.createTextNode(text));
+}
+function claimElement(cur, v, om) {
+	const node = cur.node;
+	if (!(node !== null && node.nodeType === Node.ELEMENT_NODE && node.localName.toLowerCase() === v.tag.toLowerCase())) {
+		fallback(cur, om, `<${v.tag}>`, () => buildVNode(v));
+		return;
+	}
+	const el = node;
+	const { ref, children, live } = splitProps(v.props);
+	if (live) applyProps(el, live);
+	claimChildren(el, children, om);
+	if (typeof ref === "function") ref(el);
+	cur.node = el.nextSibling;
+}
+/**
+* Split claimed-element props: static values are already in the server HTML
+* and are skipped; `on:` handlers, reactive values and `prop:` assignments
+* still need to run — they route through the normal `applyProps` path.
+*/
+function splitProps(props) {
+	let ref;
+	let children;
+	let live = null;
+	for (const [key, value] of Object.entries(props)) {
+		if (key === "children") {
+			children = value;
+			continue;
+		}
+		if (key === "ref") {
+			ref = value;
+			continue;
+		}
+		if (key === "innerHTML") throw new Error("innerHTML is not supported in hydration — there is no raw HTML sink.");
+		const colonIdx = key.indexOf(":");
+		const ns = colonIdx > 0 ? key.slice(0, colonIdx) : "";
+		if (ns === "on" || ns === "prop" || isReactive(value)) (live ??= {})[key] = value;
+	}
+	return {
+		ref,
+		children,
+		live
+	};
+}
+function claimDynamic(cur, getter, om) {
+	const region = getter[ASYNC_REGION];
+	const claimed = cur.node?.nodeType === Node.COMMENT_NODE && cur.node.data === "{";
+	if (region && hydrationContext) hydrationContext.counter += region.ids;
+	const slot = claimSlot(cur, om);
+	const keepWhilePending = Boolean(region) && claimed;
+	effect(() => {
+		const value = getter();
+		if (keepWhilePending && region.pending()) return;
+		slot.set(resolveChild(value));
+	});
+	onCleanup(() => slot.clear());
+}
+function claimAsync(cur, p, om) {
+	const ctx = hydrationContext;
+	if (ctx) {
+		const record = ctx.data?.[String(ctx.counter++)];
+		const claim = p[CLAIM];
+		claim?.(record);
+	}
+	const slot = claimSlot(cur, om);
+	effect(() => {
+		if (p.state === "pending") return;
+		slot.set(resolveChild(p.result));
+	});
+	onCleanup(() => slot.clear());
+}
+function claimSlot(cur, om) {
+	const range = claimMarkerRange(cur, "{", "}");
+	if (range) return Slot.claim(range.start, range.end);
+	om?.({
+		expected: "<!--{-->",
+		found: cur.node
+	});
+	const slot = new Slot();
+	cur.parent.insertBefore(slot.render(), cur.node);
+	return slot;
+}
+function claimMarkerRange(cur, open, close) {
+	const start = cur.node;
+	if (!start || start.nodeType !== Node.COMMENT_NODE || start.data !== open) return null;
+	let depth = 0;
+	let node = start;
+	while (node) {
+		if (node.nodeType === Node.COMMENT_NODE) {
+			const data = node.data;
+			if (data === open) depth++;
+			else if (data === close && --depth === 0) {
+				cur.node = node.nextSibling;
+				return {
+					start,
+					end: node
+				};
+			}
+		}
+		node = node.nextSibling;
+	}
+	return null;
+}
+/** `<Fragment html>` region: adopt the server markup between the markers. */
+function claimRawRegion(cur, source, om) {
+	const claimed = cur.node?.nodeType === Node.COMMENT_NODE && cur.node.data === "{";
+	const slot = claimSlot(cur, om);
+	if (typeof source !== "function") {
+		if (!claimed && source != null) slot.set(parseHtml(String(source)));
+		return;
+	}
+	let first = claimed;
+	effect(() => {
+		const value = source();
+		if (first) {
+			first = false;
+			return;
+		}
+		slot.set(parseHtml(value == null ? "" : String(value)));
+	});
+	onCleanup(() => slot.clear());
+}
+function claimFor(cur, v, om) {
+	const inst = new For();
+	applyProps(inst, v.props);
+	const range = claimMarkerRange(cur, "<For>", "</For>");
+	if (!range) {
+		om?.({
+			expected: "<!--<For>-->",
+			found: cur.node
+		});
+		cur.parent.insertBefore(inst.render(), cur.node);
+		return;
+	}
+	const items = untracked(() => inst.each);
+	const entries = /* @__PURE__ */ new Map();
+	const order = [];
+	let node = range.start.nextSibling;
+	let index = 0;
+	while (node && node !== range.end && index < items.length) {
+		if (node.nodeType === Node.COMMENT_NODE && /^\[(?!\/)/.test(node.data)) {
+			const startC = node;
+			const keyStr = startC.data.slice(1, -1);
+			const endC = findEntryEnd(startC, range.end, keyStr);
+			if (!endC) break;
+			const item = items[index];
+			const key = inst.by(item, index);
+			if (encodeURIComponent(String(key)) !== keyStr) break;
+			let dispose;
+			untracked(() => {
+				dispose = effectScope(() => {
+					const rendered = withClaimRenderer(() => inst.children(item, index));
+					walkList({
+						node: startC.nextSibling,
+						parent: startC.parentNode
+					}, rendered, om);
+				});
+			});
+			entries.set(key, {
+				start: startC,
+				end: endC,
+				dispose
+			});
+			order.push(key);
+			index++;
+			node = endC.nextSibling;
+			continue;
+		}
+		node = node.nextSibling;
+	}
+	const keep = /* @__PURE__ */ new Set();
+	for (const entry of entries.values()) {
+		let kept = entry.start;
+		while (kept) {
+			keep.add(kept);
+			if (kept === entry.end) break;
+			kept = kept.nextSibling;
+		}
+	}
+	let stray = range.start.nextSibling;
+	while (stray && stray !== range.end) {
+		const next = stray.nextSibling;
+		if (!keep.has(stray)) stray.remove();
+		stray = next;
+	}
+	inst.hydrateRange(range.start, range.end, entries, order);
+}
+function findEntryEnd(start, boundary, key) {
+	let node = start.nextSibling;
+	while (node && node !== boundary) {
+		if (node.nodeType === Node.COMMENT_NODE && node.data === `[/${key}]`) return node;
+		node = node.nextSibling;
+	}
+	return null;
+}
+function fallback(cur, om, expected, build) {
+	om?.({
+		expected,
+		found: cur.node
+	});
+	const stale = cur.node;
+	const fresh = build();
+	cur.parent.insertBefore(fresh, stale);
+	if (stale) {
+		cur.node = stale.nextSibling;
+		cur.parent.removeChild(stale);
+	}
+}
+function buildVNode(v) {
+	if (v.kind === "el") {
+		const props = { ...v.props };
+		if ("children" in props) props.children = buildChildValue(props.children);
+		return createElement(v.tag, props);
+	}
+	if (v.kind === "frag") return Fragment({ children: (() => buildChildValue(v.children)) });
+	return createElement(For, v.props);
+}
+function buildChildValue(c) {
+	if (Array.isArray(c)) return c.map(buildChildValue);
+	if (isVNode(c)) return buildVNode(c);
+	return c;
+}
+//#endregion
+//#region src/hydrate/index.ts
+/**
+* Make server-rendered HTML interactive by re-executing the component tree
+* in claim mode: existing DOM nodes are adopted instead of rebuilt, `on:`
+* handlers attach to the claimed nodes, and dynamic children bind live to
+* the server-emitted slot markers.
+*
+* The component code runs once on the client (closures are recreated by
+* re-execution — no serialized handlers). Async children keep their
+* server-rendered content visible until the client-side value settles.
+*
+* Server/client trees must match; on mismatch the affected subtree is
+* rendered fresh and `options.onMismatch` is invoked.
+*
+* @example
+* ```tsx
+* const { dispose } = hydrate(document.getElementById("app")!, () => <App />);
+* ```
+*/
+function hydrate(container, app, options = {}) {
+	const data = readHydrationData(container);
+	let dispose;
+	untracked(() => {
+		dispose = effectScope(() => {
+			setRenderer(claimRenderer);
+			const prevDefer = setDeferAsyncRuns(true);
+			let root;
+			try {
+				root = app();
+			} finally {
+				setRenderer(null);
+				setDeferAsyncRuns(prevDefer);
+			}
+			const prevCtx = setHydrationContext({
+				counter: 0,
+				data
+			});
+			try {
+				claimChildren(container, root, options.onMismatch);
+			} finally {
+				setHydrationContext(prevCtx);
+				flushDeferredAsyncRuns();
+			}
+		});
+	});
+	return { dispose };
+}
+/**
+* Locate and parse the server's ek-data script. Malformed or absent data
+* degrades to no seeding — async values settle through their own client
+* execution instead.
+*/
+function readHydrationData(container) {
+	const script = container.querySelector("script[type=\"application/json\"]#ek-data") ?? container.ownerDocument?.getElementById("ek-data");
+	if (!script?.textContent) return null;
+	try {
+		return JSON.parse(script.textContent);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { hydrate as t };

package/dist/integrations/astro-client.d.mts

@@ -0,0 +1,17 @@
+//#region src/integrations/astro-client.d.ts
+/**
+ * Astro client entrypoint: hydrate an elements-kit island.
+ *
+ * Astro calls this as `hydrator(element)(Component, props, slots, { client })`
+ * once the island's client directive fires. `client:only` mounts fresh via
+ * `render`; every other directive adopts the server DOM via `hydrate` —
+ * handlers attach to existing nodes, nothing is rebuilt. The island's
+ * `astro:unmount` event tears everything down.
+ */
+declare const _default: (element: HTMLElement) => (Component: unknown, props: Record<string, unknown>, slots: Record<string, string>, {
+  client
+}: {
+  client: string;
+}) => Promise<void>;
+//#endregion
+export { _default as default };

package/dist/integrations/astro-client.mjs

@@ -0,0 +1,23 @@
+import { t as createElement } from "../element-D3om9yA6.mjs";
+import { render } from "../render.mjs";
+import { t as hydrate } from "../hydrate-6Qx4n4Su.mjs";
+import { withSlotProps } from "./astro-slots.mjs";
+//#region src/integrations/astro-client.ts
+/**
+* Astro client entrypoint: hydrate an elements-kit island.
+*
+* Astro calls this as `hydrator(element)(Component, props, slots, { client })`
+* once the island's client directive fires. `client:only` mounts fresh via
+* `render`; every other directive adopts the server DOM via `hydrate` —
+* handlers attach to existing nodes, nothing is rebuilt. The island's
+* `astro:unmount` event tears everything down.
+*/
+var astro_client_default = (element) => async (Component, props, slots, { client }) => {
+	if (!element.hasAttribute("ssr")) return;
+	const merged = withSlotProps(props, slots);
+	const app = () => createElement(Component, merged);
+	const dispose = client === "only" ? render(element, app) : hydrate(element, app).dispose;
+	element.addEventListener("astro:unmount", () => dispose(), { once: true });
+};
+//#endregion
+export { astro_client_default as default };

package/dist/integrations/astro-server.d.mts

@@ -0,0 +1,15 @@
+//#region src/integrations/astro-server.d.ts
+type RendererFn<T> = (Component: unknown, props: Record<string, unknown> | null | undefined, slots: Record<string, string>, metadata?: {
+  astroStaticSlot?: boolean;
+}) => Promise<T>;
+interface ElementsKitSSRRenderer {
+  name: string;
+  check: RendererFn<boolean>;
+  renderToStaticMarkup: RendererFn<{
+    html: string;
+  }>;
+  supportsAstroStaticSlot: boolean;
+}
+declare const renderer: ElementsKitSSRRenderer;
+//#endregion
+export { renderer as default };

package/dist/integrations/astro-server.mjs

@@ -0,0 +1,39 @@
+import { y as setInertEffects } from "../lib-DYypKhxk.mjs";
+import { resolveProps } from "../signals/index.mjs";
+import { r as setRenderer, t as createElement } from "../element-D3om9yA6.mjs";
+import { withSlotProps } from "./astro-slots.mjs";
+import { i as serverJsx, n as renderToString, r as SNode } from "../server-iFSng50i.mjs";
+//#region src/integrations/astro-server.ts
+/**
+* Decide whether `Component` is an elements-kit component. Invoked by Astro
+* for every candidate renderer, so this must reject foreign components: the
+* component body runs under the server renderer, and only elements-kit JSX
+* dispatches to it — the result is an `SNode`. A React component returns a
+* React element object (never `SNode`); components that throw (hooks outside
+* their framework, class components) are rejected by the catch.
+*/
+const check = async (Component, props) => {
+	if (typeof Component !== "function") return false;
+	const prevInert = setInertEffects(true);
+	setRenderer({ jsx: serverJsx });
+	try {
+		return Component(resolveProps(props ?? {})) instanceof SNode;
+	} catch {
+		return false;
+	} finally {
+		setRenderer(null);
+		setInertEffects(prevInert);
+	}
+};
+const renderToStaticMarkup = async (Component, props, slots, metadata) => {
+	const merged = withSlotProps(props, slots, metadata?.astroStaticSlot === true);
+	return { html: await renderToString(() => createElement(Component, merged)) };
+};
+const renderer = {
+	name: "elements-kit",
+	check,
+	renderToStaticMarkup,
+	supportsAstroStaticSlot: true
+};
+//#endregion
+export { renderer as default };

package/dist/integrations/astro-slots.d.mts

@@ -0,0 +1,12 @@
+//#region src/integrations/astro-slots.d.ts
+/**
+ * @internal Map Astro's pre-rendered slot HTML (`Record<name, html>`) into
+ * elements-kit props: the `default` slot becomes `children`, named slots
+ * become `slot:<name>` props. Each value is a thunk building Astro's slot
+ * wrapper element around a `<Fragment html>` region — deferred so the jsx
+ * dispatches to whichever renderer is active when the component reads the
+ * prop (string emission on the server, DOM on the client).
+ */
+declare function withSlotProps(props: Record<string, unknown> | null | undefined, slots: Record<string, string> | null | undefined, staticSlot?: boolean): Record<string, unknown>;
+//#endregion
+export { withSlotProps };

package/dist/integrations/astro-slots.mjs

@@ -0,0 +1,30 @@
+import { t as createElement } from "../element-D3om9yA6.mjs";
+import { t as Fragment } from "../fragment-ROPRBJQd.mjs";
+//#region src/integrations/astro-slots.ts
+/**
+* @internal Map Astro's pre-rendered slot HTML (`Record<name, html>`) into
+* elements-kit props: the `default` slot becomes `children`, named slots
+* become `slot:<name>` props. Each value is a thunk building Astro's slot
+* wrapper element around a `<Fragment html>` region — deferred so the jsx
+* dispatches to whichever renderer is active when the component reads the
+* prop (string emission on the server, DOM on the client).
+*/
+function withSlotProps(props, slots, staticSlot = false) {
+	const base = { ...props ?? {} };
+	if (!slots) return base;
+	const tag = staticSlot ? "astro-static-slot" : "astro-slot";
+	for (const [name, html] of Object.entries(slots)) {
+		const slot = () => createElement(tag, {
+			...name === "default" ? {} : { name },
+			children: createElement(Fragment, {
+				html: true,
+				children: html
+			})
+		});
+		if (name === "default") base.children = slot;
+		else base[`slot:${name}`] = slot;
+	}
+	return base;
+}
+//#endregion
+export { withSlotProps };

package/dist/integrations/astro.d.mts

@@ -0,0 +1,46 @@
+//#region src/integrations/astro.d.ts
+interface AstroRendererConfig {
+  name: string;
+  clientEntrypoint: string;
+  serverEntrypoint: string;
+}
+interface AstroConfigSetupApi {
+  addRenderer(renderer: AstroRendererConfig): void;
+  updateConfig(config: Record<string, unknown>): unknown;
+}
+interface ElementsKitAstroIntegration {
+  name: string;
+  hooks: {
+    "astro:config:setup": (api: AstroConfigSetupApi) => void;
+  };
+}
+/**
+ * Astro integration: use elements-kit components as Astro islands.
+ *
+ * Registers the elements-kit renderer pair — server rendering via
+ * `elements-kit/server`, client hydration via `elements-kit/hydrate` — and
+ * points Vite's JSX transform at `elements-kit`, so `.tsx` island components
+ * need no per-file pragma.
+ *
+ * ```tsx
+ * <Counter client:load />          // server-rendered, hydrated on load
+ * <Widget client:only="elements-kit" />  // client-rendered only
+ * ```
+ *
+ * Coexists with other framework renderers (React, etc.); scope their JSX
+ * transform with the framework integration's `include` option.
+ *
+ * @example
+ * ```ts
+ * // astro.config.mjs
+ * import { defineConfig } from "astro/config";
+ * import elementsKit from "elements-kit/integrations/astro";
+ *
+ * export default defineConfig({
+ *   integrations: [elementsKit()],
+ * });
+ * ```
+ */
+declare function elementsKit(): ElementsKitAstroIntegration;
+//#endregion
+export { ElementsKitAstroIntegration, elementsKit as default };

package/dist/integrations/astro.mjs

@@ -0,0 +1,64 @@
+//#region src/integrations/astro.ts
+/**
+* Astro integration: use elements-kit components as Astro islands.
+*
+* Registers the elements-kit renderer pair — server rendering via
+* `elements-kit/server`, client hydration via `elements-kit/hydrate` — and
+* points Vite's JSX transform at `elements-kit`, so `.tsx` island components
+* need no per-file pragma.
+*
+* ```tsx
+* <Counter client:load />          // server-rendered, hydrated on load
+* <Widget client:only="elements-kit" />  // client-rendered only
+* ```
+*
+* Coexists with other framework renderers (React, etc.); scope their JSX
+* transform with the framework integration's `include` option.
+*
+* @example
+* ```ts
+* // astro.config.mjs
+* import { defineConfig } from "astro/config";
+* import elementsKit from "elements-kit/integrations/astro";
+*
+* export default defineConfig({
+*   integrations: [elementsKit()],
+* });
+* ```
+*/
+function elementsKit() {
+	return {
+		name: "elements-kit",
+		hooks: { "astro:config:setup": ({ addRenderer, updateConfig }) => {
+			addRenderer({
+				name: "elements-kit",
+				clientEntrypoint: "elements-kit/integrations/astro-client",
+				serverEntrypoint: "elements-kit/integrations/astro-server"
+			});
+			updateConfig({ vite: {
+				esbuild: {
+					jsx: "automatic",
+					jsxImportSource: "elements-kit"
+				},
+				optimizeDeps: { include: [
+					"elements-kit",
+					"elements-kit/jsx-runtime",
+					"elements-kit/jsx-dev-runtime",
+					"elements-kit/signals",
+					"elements-kit/for",
+					"elements-kit/slot",
+					"elements-kit/render",
+					"elements-kit/hydrate",
+					"elements-kit/await",
+					"elements-kit/custom-elements",
+					"elements-kit/attributes",
+					"elements-kit/integrations/astro-client",
+					"elements-kit/utilities/*"
+				] },
+				resolve: { dedupe: ["elements-kit"] }
+			} });
+		} }
+	};
+}
+//#endregion
+export { elementsKit as default };

package/dist/integrations/react.d.mts

@@ -1,4 +1,4 @@
-import { y as Computed } from "../infer-B7T5hi_D.mjs";
+import { y as Computed } from "../types-ncUK9rki.mjs";
 
 //#region src/integrations/react.d.ts
 /**

package/dist/integrations/react.mjs

@@ -1,6 +1,6 @@
-import { m as signal, s as effect } from "../lib-Dkc7cV5F.mjs";
+import { u as effect, x as signal } from "../lib-DYypKhxk.mjs";
 import "../signals/index.mjs";
-import { t as scope } from "../scope-CnEvL9Nd.mjs";
+import { t as scope } from "../scope-zbEG299F.mjs";
 import { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
 //#region src/integrations/react.ts
 /**

package/dist/jsx-runtime/index.d.mts

@@ -1,2 +1,2 @@
-import { U as createElement, _ as SlotProps, a as RawProps, b as MaybeReactive, c as ResolveProps, d as ComponentClass, f as ComponentFn, g as JSX, h as Attrs, i as Props, l as Child, m as PropsTarget, n as ElementProps, o as ReactiveProps, p as ComponentInstance, r as MaybeReactiveProps, s as Require, t as ComponentProps, u as Component, v as Fragment } from "../infer-B7T5hi_D.mjs";
+import { G as createElement, _ as Require, a as ComponentInstance, b as MaybeReactive, c as JSX, d as ComponentProps, f as ElementProps, g as ReactiveProps, h as RawProps, i as ComponentFn, l as SlotProps, m as Props, n as Component, o as PropsTarget, p as MaybeReactiveProps, r as ComponentClass, s as Attrs, t as Child, u as Fragment, v as ResolveProps } from "../types-ncUK9rki.mjs";
 export { Attrs, type Child, type Component, type ComponentClass, type ComponentFn, type ComponentInstance, type ComponentProps, type ElementProps, Fragment, JSX, type MaybeReactive, type MaybeReactiveProps, type Props, type PropsTarget, type RawProps, type ReactiveProps, type Require, type ResolveProps, SlotProps, createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };

package/dist/jsx-runtime/index.mjs

@@ -1,21 +1,3 @@
-import { r as mountChild, t as createElement } from "../element-xQwq4ulc.mjs";
-//#region src/jsx-runtime/fragment.ts
-/**
-* Used by the JSX transform for `<>...</>` fragments.
-*
-* Each child is routed through `mountChild`, which handles Nodes, strings,
-* numbers, arrays, and reactive getters — matching the behavior of any other
-* JSX container. `mountChild` also wires each child's cleanup via its own
-* `effectScope`, which links to the enclosing `effectScope` created by
-* `createElement(Fragment, ...)` for disposal propagation.
-*/
-function Fragment(props) {
-	const fragment = document.createDocumentFragment();
-	const raw = props.children?.();
-	if (raw == null) return fragment;
-	const nodes = Array.isArray(raw) ? raw.flat(Infinity) : [raw];
-	for (const child of nodes) mountChild(fragment, child);
-	return fragment;
-}
-//#endregion
+import { t as createElement } from "../element-D3om9yA6.mjs";
+import { t as Fragment } from "../fragment-ROPRBJQd.mjs";
 export { Fragment, createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };