@kubb/renderer-jsx 5.0.0-beta.17 → 5.0.0-beta.18

package/dist/index.js

@@ -346,7 +346,7 @@ function Jsx({ children }) {
 Jsx.displayName = "Jsx";
 //#endregion
 //#region src/components/Root.tsx
-var import_react = require_react();
+var import_react = /* @__PURE__ */ __toESM(require_react());
 var ErrorBoundary = class extends import_react.Component {
 	state = { hasError: false };
 	static displayName = "ErrorBoundary";
@@ -454,20 +454,29 @@ var import_constants = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 * Name used for text-node entries in the virtual DOM.
 */
 const TEXT_NODE_NAME = "#text";
+const KUBB_FILE = "kubb-file";
+const KUBB_SOURCE = "kubb-source";
+const KUBB_EXPORT = "kubb-export";
+const KUBB_IMPORT = "kubb-import";
+const KUBB_FUNCTION = "kubb-function";
+const KUBB_ARROW_FUNCTION = "kubb-arrow-function";
+const KUBB_CONST = "kubb-const";
+const KUBB_TYPE = "kubb-type";
+const KUBB_JSX = "kubb-jsx";
 /**
 * Set of all element names recognized by the Kubb renderer.
 * Used to distinguish Kubb-owned elements from unrecognized or text nodes during tree traversal.
 */
 const nodeNames = new Set([
-	"kubb-export",
-	"kubb-file",
-	"kubb-source",
-	"kubb-import",
-	"kubb-function",
-	"kubb-arrow-function",
-	"kubb-const",
-	"kubb-type",
-	"kubb-jsx",
+	KUBB_EXPORT,
+	KUBB_FILE,
+	KUBB_SOURCE,
+	KUBB_IMPORT,
+	KUBB_FUNCTION,
+	KUBB_ARROW_FUNCTION,
+	KUBB_CONST,
+	KUBB_TYPE,
+	KUBB_JSX,
 	"kubb-text",
 	"kubb-root",
 	"kubb-app",
@@ -484,7 +493,7 @@ const nodeNames = new Set([
 const createNode = (nodeName) => {
 	return {
 		nodeName,
-		attributes: /* @__PURE__ */ new Map(),
+		attributes: Object.create(null),
 		childNodes: [],
 		parentNode: void 0
 	};
@@ -532,26 +541,22 @@ const removeChildNode = (node, removeNode) => {
 * Set an attribute on `node`, storing it in the node's `attributes` map.
 */
 const setAttribute = (node, key, value) => {
-	node.attributes.set(key, value);
+	node.attributes[key] = value;
 };
 /**
 * Create a new {@link TextNode} with the given text value.
 */
 const createTextNode = (text) => {
-	const node = {
+	return {
 		nodeName: TEXT_NODE_NAME,
 		nodeValue: text,
 		parentNode: void 0
 	};
-	setTextNodeValue(node, text);
-	return node;
 };
 /**
 * Update the `nodeValue` of an existing {@link TextNode}.
-* Non-string values are coerced to strings via `String(text)`.
 */
 const setTextNodeValue = (node, text) => {
-	if (typeof text !== "string") text = String(text);
 	node.nodeValue = text;
 };
 //#endregion
@@ -17820,7 +17825,7 @@ const Renderer = (0, import_react_reconciler.default)({
 		return false;
 	},
 	supportsMutation: true,
-	isPrimaryRenderer: true,
+	isPrimaryRenderer: false,
 	supportsPersistence: false,
 	supportsHydration: false,
 	scheduleTimeout: setTimeout,
@@ -17886,187 +17891,182 @@ const Renderer = (0, import_react_reconciler.default)({
 });
 //#endregion
 //#region src/utils.ts
+function toBool$1(val) {
+	return val ?? false;
+}
+__name(toBool$1, "toBool");
 /**
 * Collect the text and nested AST-node children of a single kubb-* element.
 *
-* `#text` children become raw {@link TextNode}s; nested `kubb-function`, `kubb-const`,
+* `#text` children become raw text nodes; nested `kubb-function`, `kubb-const`,
 * `kubb-type`, and similar elements are converted into their respective {@link CodeNode}s.
-* Any unrecognized DOM elements are silently skipped.
+* Any unrecognized element names are silently skipped.
 */
-function collectChildNodes(element) {
+function collectCodeNodes$1(element) {
 	const result = [];
 	for (const child of element.childNodes) {
 		if (!child) continue;
-		if (child.nodeName === "#text") {
-			const text = child.nodeValue;
-			if (text && text.trim().length > 0) result.push(createText(text));
-			continue;
-		}
-		if (child.nodeName === "br") {
-			result.push(createBreak());
-			continue;
-		}
-		if (child.nodeName === "kubb-function") {
-			const attrs = child.attributes;
-			result.push(createFunction({
-				name: attrs.get("name"),
-				params: attrs.get("params"),
-				export: attrs.get("export"),
-				default: attrs.get("default"),
-				async: attrs.get("async"),
-				generics: attrs.get("generics"),
-				returnType: attrs.get("returnType"),
-				JSDoc: attrs.get("JSDoc"),
-				nodes: collectChildNodes(child)
-			}));
-		} else if (child.nodeName === "kubb-arrow-function") {
-			const attrs = child.attributes;
-			result.push(createArrowFunction({
-				name: attrs.get("name"),
-				params: attrs.get("params"),
-				export: attrs.get("export"),
-				default: attrs.get("default"),
-				async: attrs.get("async"),
-				generics: attrs.get("generics"),
-				returnType: attrs.get("returnType"),
-				singleLine: attrs.get("singleLine"),
-				JSDoc: attrs.get("JSDoc"),
-				nodes: collectChildNodes(child)
-			}));
-		} else if (child.nodeName === "kubb-const") {
-			const attrs = child.attributes;
-			result.push(createConst({
-				name: attrs.get("name"),
-				type: attrs.get("type"),
-				export: attrs.get("export"),
-				asConst: attrs.get("asConst"),
-				JSDoc: attrs.get("JSDoc"),
-				nodes: collectChildNodes(child)
-			}));
-		} else if (child.nodeName === "kubb-type") {
-			const attrs = child.attributes;
-			result.push(createType({
-				name: attrs.get("name"),
-				export: attrs.get("export"),
-				JSDoc: attrs.get("JSDoc"),
-				nodes: collectChildNodes(child)
-			}));
-		} else if (child.nodeName === "kubb-jsx") {
-			const textChild = child.childNodes[0];
-			const value = textChild?.nodeName === "#text" ? textChild.nodeValue : "";
-			if (value) result.push(createJsx(value));
+		switch (child.nodeName) {
+			case TEXT_NODE_NAME: {
+				const text = child.nodeValue;
+				if (text && text.trim()) result.push(createText(text));
+				break;
+			}
+			case "br":
+				result.push(createBreak());
+				break;
+			case KUBB_FUNCTION: {
+				const attrs = child.attributes;
+				result.push(createFunction({
+					name: attrs["name"],
+					params: attrs["params"],
+					export: attrs["export"],
+					default: attrs["default"],
+					async: attrs["async"],
+					generics: attrs["generics"],
+					returnType: attrs["returnType"],
+					JSDoc: attrs["JSDoc"],
+					nodes: collectCodeNodes$1(child)
+				}));
+				break;
+			}
+			case KUBB_ARROW_FUNCTION: {
+				const attrs = child.attributes;
+				result.push(createArrowFunction({
+					name: attrs["name"],
+					params: attrs["params"],
+					export: attrs["export"],
+					default: attrs["default"],
+					async: attrs["async"],
+					generics: attrs["generics"],
+					returnType: attrs["returnType"],
+					singleLine: attrs["singleLine"],
+					JSDoc: attrs["JSDoc"],
+					nodes: collectCodeNodes$1(child)
+				}));
+				break;
+			}
+			case KUBB_CONST: {
+				const attrs = child.attributes;
+				result.push(createConst({
+					name: attrs["name"],
+					type: attrs["type"],
+					export: attrs["export"],
+					asConst: attrs["asConst"],
+					JSDoc: attrs["JSDoc"],
+					nodes: collectCodeNodes$1(child)
+				}));
+				break;
+			}
+			case KUBB_TYPE: {
+				const attrs = child.attributes;
+				result.push(createType({
+					name: attrs["name"],
+					export: attrs["export"],
+					JSDoc: attrs["JSDoc"],
+					nodes: collectCodeNodes$1(child)
+				}));
+				break;
+			}
+			case KUBB_JSX: {
+				const textChild = child.childNodes[0];
+				const value = textChild?.nodeName === "#text" ? textChild.nodeValue : "";
+				if (value) result.push(createJsx(value));
+				break;
+			}
 		}
 	}
 	return result;
 }
+__name(collectCodeNodes$1, "collectCodeNodes");
 /**
-* Traverse `node` and collect all `<kubb-source>` elements into a `Set<SourceNode>`.
-*
-* Elements whose `nodeName` is in `ignores` are skipped entirely (including their subtrees).
-* This is used to collect source blocks from a file node while excluding import/export subtrees.
+* Yields every {@link SourceNode}, {@link ExportNode}, and {@link ImportNode}
+* within a `<kubb-file>` subtree in a single tree walk.
 *
-* @example Collect sources while ignoring export and import elements
-* ```ts
-* const sources = squashSourceNodes(fileElement, ['kubb-export', 'kubb-import'])
-* ```
+* Import and export elements are leaf nodes. Once yielded, the walker does not
+* recurse into them, which also prevents source collection from descending into
+* their subtrees. Dispatch on `.kind` (`'Source'`, `'Export'`, `'Import'`) to
+* separate the results.
 */
-function squashSourceNodes(node, ignores) {
-	const ignoreSet = new Set(ignores);
-	const sources = /* @__PURE__ */ new Set();
-	const walk = (current) => {
-		for (const child of current.childNodes) {
-			if (!child) continue;
-			if (child.nodeName !== "#text" && ignoreSet.has(child.nodeName)) continue;
-			if (child.nodeName === "kubb-source") {
-				const source = createSource({
-					name: child.attributes.get("name")?.toString(),
-					isTypeOnly: child.attributes.get("isTypeOnly") ?? false,
-					isExportable: child.attributes.get("isExportable") ?? false,
-					isIndexable: child.attributes.get("isIndexable") ?? false,
-					nodes: collectChildNodes(child)
-				});
-				sources.add(source);
-				continue;
-			}
-			if (child.nodeName !== "#text" && nodeNames.has(child.nodeName)) walk(child);
+function* collectFileEntries(node) {
+	for (const child of node.childNodes) {
+		if (!child || child.nodeName === "#text") continue;
+		if (child.nodeName === "kubb-source") {
+			yield createSource({
+				name: child.attributes["name"]?.toString(),
+				isTypeOnly: toBool$1(child.attributes["isTypeOnly"]),
+				isExportable: toBool$1(child.attributes["isExportable"]),
+				isIndexable: toBool$1(child.attributes["isIndexable"]),
+				nodes: collectCodeNodes$1(child)
+			});
+			continue;
 		}
-	};
-	walk(node);
-	return sources;
+		if (child.nodeName === "kubb-export") {
+			yield createExport({
+				name: child.attributes["name"],
+				path: child.attributes["path"],
+				isTypeOnly: toBool$1(child.attributes["isTypeOnly"]),
+				asAlias: toBool$1(child.attributes["asAlias"])
+			});
+			continue;
+		}
+		if (child.nodeName === "kubb-import") {
+			yield createImport({
+				name: child.attributes["name"],
+				path: child.attributes["path"],
+				root: child.attributes["root"],
+				isTypeOnly: toBool$1(child.attributes["isTypeOnly"]),
+				isNameSpace: toBool$1(child.attributes["isNameSpace"])
+			});
+			continue;
+		}
+		if (nodeNames.has(child.nodeName)) yield* collectFileEntries(child);
+	}
 }
 /**
-* Traverse `node` and collect all `<kubb-export>` elements into a `Set<ExportNode>`.
+* Runs a single {@link collectFileEntries} pass over a `<kubb-file>` DOM element
+* and assembles the result into a {@link FileNode}, bucketing each yielded
+* node by its `.kind`.
 */
-function squashExportNodes(node) {
-	const exports = /* @__PURE__ */ new Set();
-	const walk = (current) => {
-		for (const child of current.childNodes) {
-			if (!child) continue;
-			if (child.nodeName !== "#text" && nodeNames.has(child.nodeName)) walk(child);
-			if (child.nodeName === "kubb-export") exports.add(createExport({
-				name: child.attributes.get("name"),
-				path: child.attributes.get("path"),
-				isTypeOnly: child.attributes.get("isTypeOnly") ?? false,
-				asAlias: child.attributes.get("asAlias") ?? false
-			}));
-		}
+function createFileNode(child) {
+	const sources = [];
+	const exports = [];
+	const imports = [];
+	for (const node of collectFileEntries(child)) if (node.kind === "Source") sources.push(node);
+	else if (node.kind === "Export") exports.push(node);
+	else imports.push(node);
+	return {
+		baseName: child.attributes["baseName"],
+		path: child.attributes["path"],
+		meta: child.attributes["meta"] || {},
+		footer: child.attributes["footer"],
+		banner: child.attributes["banner"],
+		sources,
+		exports,
+		imports
 	};
-	walk(node);
-	return exports;
 }
 /**
-* Traverse `node` and collect all `<kubb-import>` elements into a `Set<ImportNode>`.
+* Yields each {@link FileNode} as it is encountered during the tree walk,
+* without collecting into an intermediate array. Callers can begin processing
+* each file before the rest of the tree is traversed.
 */
-function squashImportNodes(node) {
-	const imports = /* @__PURE__ */ new Set();
-	const walk = (current) => {
-		for (const child of current.childNodes) {
-			if (!child) continue;
-			if (child.nodeName !== "#text" && nodeNames.has(child.nodeName)) walk(child);
-			if (child.nodeName === "kubb-import") imports.add(createImport({
-				name: child.attributes.get("name"),
-				path: child.attributes.get("path"),
-				root: child.attributes.get("root"),
-				isTypeOnly: child.attributes.get("isTypeOnly") ?? false,
-				isNameSpace: child.attributes.get("isNameSpace") ?? false
-			}));
-		}
-	};
-	walk(node);
-	return imports;
+function* streamFiles(node) {
+	for (const child of node.childNodes) {
+		if (!child) continue;
+		if (child.nodeName !== "#text" && child.nodeName !== "kubb-file" && nodeNames.has(child.nodeName)) yield* streamFiles(child);
+		if (child.nodeName === "kubb-file" && child.attributes["baseName"] !== void 0 && child.attributes["path"] !== void 0) yield createFileNode(child);
+	}
 }
 /**
 * Walk the virtual DOM tree rooted at `node` and convert every `<kubb-file>` element
 * into a {@link FileNode}, collecting its source blocks, imports, and exports.
 *
-* Returns the list of file nodes in document order. Nested files are supported —
+* Returns the list of file nodes in document order. Nested files are supported;
 * the walker descends into non-file elements and recurses through them.
 */
-function processFiles(node) {
-	const collected = [];
-	function walk(current) {
-		for (const child of current.childNodes) {
-			if (!child) continue;
-			if (child.nodeName !== "#text" && child.nodeName !== "kubb-file" && nodeNames.has(child.nodeName)) walk(child);
-			if (child.nodeName === "kubb-file") {
-				if (child.attributes.has("baseName") && child.attributes.has("path")) {
-					const sources = squashSourceNodes(child, ["kubb-export", "kubb-import"]);
-					collected.push({
-						baseName: child.attributes.get("baseName"),
-						path: child.attributes.get("path"),
-						meta: child.attributes.get("meta") || {},
-						footer: child.attributes.get("footer"),
-						banner: child.attributes.get("banner"),
-						sources: [...sources],
-						exports: [...squashExportNodes(child)],
-						imports: [...squashImportNodes(child)]
-					});
-				}
-			}
-		}
-	}
-	walk(node);
-	return collected;
+function collectFiles(node) {
+	return [...streamFiles(node)];
 }
 //#endregion
 //#region src/Runtime.tsx
@@ -18091,7 +18091,7 @@ var Runtime = class {
 			console.log(data);
 		};
 		const logRecoverableError = typeof reportError === "function" ? reportError : console.error;
-		const rootTag = import_constants.ConcurrentRoot;
+		const rootTag = import_constants.LegacyRoot;
 		this.#container = Renderer.createContainer(this.#rootNode, rootTag, null, false, false, "id", logRecoverableError, logRecoverableError, logRecoverableError, null);
 		this.unsubscribeExit = onProcessExit((code) => {
 			this.unmount(code);
@@ -18104,7 +18104,7 @@ var Runtime = class {
 	onRender = () => {
 		const task = this.#renderPromise.catch(() => {}).then(() => {
 			if (this.#isUnmounted) return;
-			const files = processFiles(this.#rootNode);
+			const files = collectFiles(this.#rootNode);
 			this.nodes.push(...files);
 			if (!this.#options?.debug) return;
 		});
@@ -18151,21 +18151,226 @@ var Runtime = class {
 	}
 };
 //#endregion
+//#region src/SyncRuntime.tsx
+/**
+* Walks `element`, resolving arrays, Fragments, and function components
+* transparently, then calls `onText` for primitive values and `onHost` for
+* every host element encountered. Pure function components are called
+* synchronously; hooks and class components are not supported.
+*/
+function walkElement(element, onText, onHost) {
+	if (element == null || typeof element === "boolean") return;
+	if (typeof element === "string" || typeof element === "number" || typeof element === "bigint") {
+		onText(String(element));
+		return;
+	}
+	if (Array.isArray(element)) {
+		for (const child of element) walkElement(child, onText, onHost);
+		return;
+	}
+	if (typeof element === "object" && "$$typeof" in element) {
+		const el = element;
+		const { type } = el;
+		const props = el.props;
+		if (type === import_react.Fragment) walkElement(props["children"], onText, onHost);
+		else if (typeof type === "function") walkElement(type(props), onText, onHost);
+		else if (typeof type === "string") onHost(type, props);
+	}
+}
+function toBool(val) {
+	return val ?? false;
+}
+function collectCodeNodes(props) {
+	const nodes = [];
+	collectCode(props["children"], nodes);
+	return nodes;
+}
+function collectCode(element, nodes) {
+	walkElement(element, (text) => {
+		if (text.trim()) nodes.push(createText(text));
+	}, (type, props) => resolveCodeNode(type, props, nodes));
+}
+function resolveCodeNode(type, props, nodes) {
+	if (type === "br") {
+		nodes.push(createBreak());
+		return;
+	}
+	if (type === "kubb-jsx") {
+		let value = "";
+		walkElement(props["children"], (t) => {
+			value += t;
+		}, () => {});
+		if (value) nodes.push(createJsx(value));
+		return;
+	}
+	if (type === "kubb-function") {
+		nodes.push(createFunction({
+			name: props["name"],
+			params: props["params"],
+			export: props["export"],
+			default: props["default"],
+			async: props["async"],
+			generics: props["generics"],
+			returnType: props["returnType"],
+			JSDoc: props["JSDoc"],
+			nodes: collectCodeNodes(props)
+		}));
+		return;
+	}
+	if (type === "kubb-arrow-function") {
+		nodes.push(createArrowFunction({
+			name: props["name"],
+			params: props["params"],
+			export: props["export"],
+			default: props["default"],
+			async: props["async"],
+			generics: props["generics"],
+			returnType: props["returnType"],
+			singleLine: props["singleLine"],
+			JSDoc: props["JSDoc"],
+			nodes: collectCodeNodes(props)
+		}));
+		return;
+	}
+	if (type === "kubb-const") {
+		nodes.push(createConst({
+			name: props["name"],
+			type: props["type"],
+			export: props["export"],
+			asConst: props["asConst"],
+			JSDoc: props["JSDoc"],
+			nodes: collectCodeNodes(props)
+		}));
+		return;
+	}
+	if (type === "kubb-type") {
+		nodes.push(createType({
+			name: props["name"],
+			export: props["export"],
+			JSDoc: props["JSDoc"],
+			nodes: collectCodeNodes(props)
+		}));
+		return;
+	}
+}
+function collectFileChildren(element) {
+	const sources = [];
+	const exports = [];
+	const imports = [];
+	walkElement(element, (text) => {
+		if (text.trim()) throw new Error(`[react] '${text}' should be part of <File.Source> component when using the <File/> component`);
+	}, (type, props) => {
+		if (type === "kubb-source") {
+			sources.push(createSource({
+				name: props["name"]?.toString(),
+				isTypeOnly: toBool(props["isTypeOnly"]),
+				isExportable: toBool(props["isExportable"]),
+				isIndexable: toBool(props["isIndexable"]),
+				nodes: collectCodeNodes(props)
+			}));
+			return;
+		}
+		if (type === "kubb-export") {
+			exports.push(createExport({
+				name: props["name"],
+				path: props["path"],
+				isTypeOnly: toBool(props["isTypeOnly"]),
+				asAlias: toBool(props["asAlias"])
+			}));
+			return;
+		}
+		if (type === "kubb-import") {
+			imports.push(createImport({
+				name: props["name"],
+				path: props["path"],
+				root: props["root"],
+				isTypeOnly: toBool(props["isTypeOnly"]),
+				isNameSpace: toBool(props["isNameSpace"])
+			}));
+			return;
+		}
+		const nested = collectFileChildren(props["children"]);
+		sources.push(...nested.sources);
+		exports.push(...nested.exports);
+		imports.push(...nested.imports);
+	});
+	return {
+		sources,
+		exports,
+		imports
+	};
+}
+function* walkFiles(element) {
+	const files = [];
+	function onHost(type, props) {
+		if (type === "kubb-file" && props["baseName"] !== void 0 && props["path"] !== void 0) {
+			const { sources, exports, imports } = collectFileChildren(props["children"]);
+			files.push({
+				baseName: props["baseName"],
+				path: props["path"],
+				meta: props["meta"] || {},
+				footer: props["footer"],
+				banner: props["banner"],
+				sources,
+				exports,
+				imports
+			});
+		} else walkElement(props["children"], () => {}, onHost);
+	}
+	walkElement(element, () => {}, onHost);
+	yield* files;
+}
+/**
+* Synchronous JSX renderer that walks the element tree in a single pass,
+* producing {@link FileNode} objects directly without an intermediate virtual
+* DOM. No React fiber, scheduler, or work loop is involved.
+*
+* All components must be pure functions; hooks and class components are not
+* supported. Produces identical output to the React-backed {@link Runtime} at
+* approximately 2–4× the speed and a fraction of the allocations.
+*/
+var SyncRuntime = class {
+	/**
+	* Accumulated {@link FileNode} results from every {@link render} call.
+	*/
+	nodes = [];
+	/**
+	* Walks `element` synchronously, converts every `<kubb-file>` subtree into
+	* a {@link FileNode} with no intermediate virtual DOM, and appends the results
+	* to {@link nodes}.
+	*/
+	render(element) {
+		for (const file of walkFiles(element)) this.nodes.push(file);
+	}
+	/**
+	* Walks `element` synchronously and yields each {@link FileNode} as it is
+	* produced, without buffering into an intermediate array first. Callers can
+	* begin processing each file before the rest of the element tree is traversed.
+	*
+	* @example
+	* ```ts
+	* for (const file of runtime.stream(element)) {
+	*   await writeFile(file)
+	* }
+	* ```
+	*/
+	*stream(element) {
+		yield* walkFiles(element);
+	}
+};
+//#endregion
 //#region src/createRenderer.tsx
 /**
-* A renderer factory for generators that produce JSX output.
+* Renderer factory for generators that produce JSX output.
 *
-* Pass this as the `renderer` property of a `defineGenerator` call so that
-* core can render the JSX element tree returned by your generator methods
+* Pass as the `renderer` property of `defineGenerator`. Core drives rendering
 * without a hard dependency on `@kubb/renderer-jsx`.
 *
 * @example
 * ```ts
 * import { jsxRenderer } from '@kubb/renderer-jsx'
-* import { defineGenerator } from '@kubb/core'
 *
 * export const myGenerator = defineGenerator<PluginTs>({
-*   name: 'my-generator',
 *   renderer: jsxRenderer,
 *   schema(node, options) {
 *     return <File baseName="output.ts" path="src/output.ts">...</File>
@@ -18187,7 +18392,48 @@ const jsxRenderer = () => {
 		}
 	};
 };
+/**
+* Lightweight renderer factory with no React fiber, scheduler, or work loop.
+*
+* Walks the JSX element tree in a single recursive pass. All components must be
+* pure functions; hooks and class components are not supported. Drop-in
+* replacement for {@link jsxRenderer} at approximately 2–4× the speed.
+*
+* @example Drop-in replacement
+* ```ts
+* import { jsxRendererSync } from '@kubb/renderer-jsx'
+*
+* export const myGenerator = defineGenerator<PluginTs>({
+*   renderer: jsxRendererSync,
+*   schema(node, options) {
+*     return <File baseName="output.ts" path="src/output.ts">...</File>
+*   },
+* })
+* ```
+*
+* @example Stream files as they are produced
+* ```ts
+* for await (const file of jsxRendererSync().stream(element)) {
+*   await writeFile(file)
+* }
+* ```
+*/
+const jsxRendererSync = () => {
+	const runtime = new SyncRuntime();
+	return {
+		async render(element) {
+			runtime.render(element);
+		},
+		get files() {
+			return runtime.nodes;
+		},
+		async *stream(element) {
+			yield* runtime.stream(element);
+		},
+		unmount(_error) {}
+	};
+};
 //#endregion
-export { Const, File, Function$1 as Function, Jsx, Root, Type, createContext, inject, jsxRenderer, provide, unprovide };
+export { Const, File, Function$1 as Function, Jsx, Root, Type, createContext, inject, jsxRenderer, jsxRendererSync, provide, unprovide };
 
 //# sourceMappingURL=index.js.map