@askrjs/askr 0.0.48 → 0.0.49

package/dist/ssr/index.js

@@ -1,741 +1,6 @@
-import { __CONTROL_BOUNDARY__ } from "../common/control.js";
-import { __ERROR_BOUNDARY__ } from "../common/vnode.js";
-import { logger } from "../dev/logger.js";
-import { ELEMENT_TYPE, Fragment } from "../common/jsx.js";
-import { isPromiseLike } from "../common/promise.js";
-import { getPublicAttributeName } from "../common/attr-names.js";
-import { cleanupComponent, createComponentInstance, getCurrentComponentInstance, setCurrentComponentInstance } from "../runtime/component.js";
-import { evaluateForState } from "../runtime/for.js";
-import { evaluateCaseState, evaluateShowState } from "../runtime/control.js";
 import { SSRDataMissingError } from "../common/ssr-errors.js";
-import { VOID_ELEMENTS, escapeText, styleObjToCss } from "./escape.js";
-import { createRenderContext, getRenderContext, throwSSRDataMissing, withRenderContext } from "./context.js";
-import { _resolveRouteMatchFromRoutes, resolveRouteFromRoutes, resolveRouteRequest } from "../router/route.js";
-import "../jsx/index.js";
-import { DefaultPortal, disposeDefaultPortalScope } from "../foundations/structures/portal.js";
-import { SSR_RENDER_DATA_ATTR, renderDocument } from "../common/ssr.js";
-import { getCurrentRenderData, getNextKey, startRenderPhase, stopRenderPhase } from "./render-keys.js";
-import { installSSRBridge } from "../runtime/ssr-bridge.js";
-import { renderAttrs, renderAttrsDirect } from "./attrs.js";
+import { resolveRequest } from "./route-render.js";
+import { renderToStringSync } from "./render-sync.js";
 import { renderResolvedToStringSync } from "./render-resolved.js";
-import { StreamSink, StringSink } from "./sink.js";
-//#region src/ssr/index.ts
-const __SSR_DEBUG = process.env.ASKR_SSR_DEBUG === "1" || process.env.ASKR_SSR_DEBUG === "true";
-function isSSRAttrEventHandler(key) {
-	return key.length >= 3 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) >= 65 && key.charCodeAt(2) <= 90;
-}
-function inheritRenderableKey(source, result) {
-	const inheritedKey = source.key;
-	if (inheritedKey === void 0 || inheritedKey === null) return result;
-	if (!result || typeof result !== "object" || !("type" in result)) return result;
-	const resultVNode = result;
-	if (resultVNode.key === void 0 || resultVNode.key === null) resultVNode.key = inheritedKey;
-	if (typeof resultVNode.type === "string") {
-		if (!resultVNode.props) resultVNode.props = {};
-		if (resultVNode.props["data-key"] === void 0) resultVNode.props["data-key"] = String(inheritedKey);
-	}
-	return result;
-}
-installSSRBridge({
-	getCurrentSSRContext: getRenderContext,
-	throwSSRDataMissing,
-	getCurrentRenderData,
-	getNextKey
-});
-const __ssrGuardStack = [];
-function pushSSRStrictPurityGuard() {
-	__ssrGuardStack.push({
-		random: Reflect.get(Math, "random"),
-		now: Reflect.get(Date, "now")
-	});
-	Reflect.set(Math, "random", () => {
-		throw new Error("SSR Strict Purity: Math.random is not allowed during synchronous SSR. Use the provided `ssr` context RNG instead.");
-	});
-	Reflect.set(Date, "now", () => {
-		throw new Error("SSR Strict Purity: Date.now is not allowed during synchronous SSR. Pass timestamps explicitly or use deterministic helpers.");
-	});
-}
-function popSSRStrictPurityGuard() {
-	const prev = __ssrGuardStack.pop();
-	if (prev) {
-		Reflect.set(Math, "random", prev.random);
-		Reflect.set(Date, "now", prev.now);
-	}
-}
-/**
-* Synchronous rendering helpers (used for strictly synchronous SSR)
-*/
-function renderRenderableSync(value, ctx) {
-	if (typeof value === "string") return escapeText(value);
-	if (typeof value === "number") return escapeText(String(value));
-	if (value === null || value === void 0 || value === false) return "";
-	if (Array.isArray(value)) return renderChildrenSync(value, ctx);
-	if (value && typeof value === "object" && "type" in value) return renderNodeSync(value, ctx);
-	return "";
-}
-function renderChildSync(child, ctx) {
-	return renderRenderableSync(child, ctx);
-}
-function renderRenderableSyncToSink(value, sink, ctx) {
-	if (value === null || value === void 0 || value === false) return;
-	if (typeof value === "string") {
-		sink.write(escapeText(value));
-		return;
-	}
-	if (typeof value === "number") {
-		sink.write(escapeText(String(value)));
-		return;
-	}
-	if (Array.isArray(value)) {
-		renderChildrenSyncToSink(value, sink, ctx);
-		return;
-	}
-	if (value && typeof value === "object" && "type" in value) renderNodeSyncToSink(value, sink, ctx);
-}
-function renderChildSyncToSink(child, sink, ctx) {
-	renderRenderableSyncToSink(child, sink, ctx);
-}
-function serializeHydrationRenderData(data) {
-	if (!data || Object.keys(data).length === 0) return "";
-	return `<script type="application/json" ${SSR_RENDER_DATA_ATTR}="true">${JSON.stringify(data).replace(/</g, "\\u003C").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")}<\/script>`;
-}
-function renderChildrenSync(children, ctx) {
-	if (!children || !Array.isArray(children) || children.length === 0) return "";
-	if (children.length === 1) return renderChildSync(children[0], ctx);
-	if (children.length <= 8) {
-		let result = "";
-		for (const child of children) result += renderChildSync(child, ctx);
-		return result;
-	}
-	return Array.from({ length: children.length }, (_, index) => renderChildSync(children[index], ctx)).join("");
-}
-function normalizeRenderableChildren(value) {
-	if (value === null || value === void 0 || value === false) return [];
-	return Array.isArray(value) ? value : [value];
-}
-function getErrorBoundaryState(node) {
-	return node.__instance?.errorBoundaryState ?? null;
-}
-function createDefaultErrorBoundaryFallbackVNode(error) {
-	const message = error instanceof Error ? error.stack || error.message || error.name : typeof error === "string" ? error : (() => {
-		try {
-			return JSON.stringify(error);
-		} catch {
-			return String(error);
-		}
-	})();
-	return {
-		$$typeof: ELEMENT_TYPE,
-		type: "div",
-		props: {
-			role: "alert",
-			"data-askr-error-boundary": "true",
-			style: {
-				boxSizing: "border-box",
-				padding: "1rem",
-				border: "1px solid currentColor",
-				borderRadius: "0.75rem",
-				display: "grid",
-				gap: "0.75rem",
-				maxWidth: "100%"
-			},
-			children: [
-				{
-					$$typeof: ELEMENT_TYPE,
-					type: "strong",
-					props: { children: ["Something went wrong while rendering this view."] }
-				},
-				{
-					$$typeof: ELEMENT_TYPE,
-					type: "p",
-					props: {
-						style: { margin: "0" },
-						children: ["The app recovered into a visible fallback so the error is not hidden in the console."]
-					}
-				},
-				{
-					$$typeof: ELEMENT_TYPE,
-					type: "details",
-					props: {
-						open: true,
-						children: [{
-							$$typeof: ELEMENT_TYPE,
-							type: "summary",
-							props: { children: ["Error details"] }
-						}, {
-							$$typeof: ELEMENT_TYPE,
-							type: "pre",
-							props: {
-								style: {
-									margin: "0",
-									whiteSpace: "pre-wrap",
-									wordBreak: "break-word"
-								},
-								children: [message]
-							}
-						}]
-					}
-				}
-			]
-		},
-		key: null
-	};
-}
-function resolveErrorBoundaryFallbackNode(fallback, error, reset) {
-	return typeof fallback === "function" ? fallback(error, reset) : fallback !== void 0 ? fallback : createDefaultErrorBoundaryFallbackVNode(error);
-}
-function renderErrorBoundaryFallbackValue(fallback, error, reset, ctx) {
-	const nextValue = resolveErrorBoundaryFallbackNode(fallback, error, reset);
-	return Array.isArray(nextValue) ? renderChildrenSync(normalizeRenderableChildren(nextValue), ctx) : renderChildSync(nextValue, ctx);
-}
-function renderErrorBoundaryFallbackValueToSink(fallback, error, reset, sink, ctx) {
-	sink.write(renderErrorBoundaryFallbackValue(fallback, error, reset, ctx));
-}
-function getControlBoundaryState(node) {
-	const boundaryNode = node;
-	return boundaryNode._controlState ?? boundaryNode._forState ?? null;
-}
-function evaluateControlBoundaryChildren(node) {
-	if (node.type !== __CONTROL_BOUNDARY__) return;
-	const controlState = getControlBoundaryState(node);
-	if (!controlState) return [];
-	if (controlState.kind === "for") return evaluateForState(controlState);
-	if (controlState.kind === "show") return evaluateShowState(controlState);
-	return evaluateCaseState(controlState);
-}
-function renderChildrenSyncToSink(children, sink, ctx) {
-	if (!children || !Array.isArray(children) || children.length === 0) return;
-	if (children.length >= 32) {
-		for (let i = 0; i < children.length; i++) renderRenderableSyncToSink(children[i], sink, ctx);
-		return;
-	}
-	for (let i = 0; i < children.length; i++) renderChildSyncToSink(children[i], sink, ctx);
-}
-function sinkWrite2(sink, a, b) {
-	if (typeof sink.write2 === "function") {
-		sink.write2(a, b);
-		return;
-	}
-	sink.write(a);
-	sink.write(b);
-}
-function sinkWrite3(sink, a, b, c) {
-	if (typeof sink.write3 === "function") {
-		sink.write3(a, b, c);
-		return;
-	}
-	sink.write(a);
-	sink.write(b);
-	sink.write(c);
-}
-/**
-* Render a VNode synchronously. Throws if an async component is encountered.
-*/
-function renderNodeSync(node, ctx) {
-	const { type, props } = node;
-	/* istanbul ignore if - dev-only debug */
-	if (__SSR_DEBUG) try {
-		logger.warn("[SSR] renderNodeSync type:", typeof type, type);
-	} catch {}
-	if (typeof type === "function") return renderRenderableSync(inheritRenderableKey(node, executeComponentSync(type, props, ctx)), ctx);
-	if (typeof type === "symbol") {
-		if (type === Fragment) {
-			const childrenArr = getRenderableChildren(node);
-			/* istanbul ignore if - dev-only debug */
-			if (__SSR_DEBUG) try {
-				logger.warn("[SSR] fragment children length:", childrenArr?.length);
-			} catch {}
-			return renderChildrenSync(childrenArr, ctx);
-		}
-		if (type === __CONTROL_BOUNDARY__) return renderChildrenSync(evaluateControlBoundaryChildren(node), ctx);
-		if (type === __ERROR_BOUNDARY__) {
-			const boundaryState = getErrorBoundaryState(node);
-			const fallback = props?.fallback;
-			const reset = () => {
-				const state = node.__instance?.errorBoundaryState;
-				if (state) {
-					state.error = null;
-					state.notified = false;
-				}
-			};
-			if (boundaryState?.error != null) return renderErrorBoundaryFallbackValue(fallback, boundaryState.error, reset, ctx);
-			try {
-				return renderChildrenSync(normalizeRenderableChildren(props?.children), ctx);
-			} catch (error) {
-				if (boundaryState) {
-					boundaryState.error = error;
-					boundaryState.notified = true;
-				}
-				logger.error("[Askr] ErrorBoundary caught render error:", error);
-				return renderErrorBoundaryFallbackValue(fallback, error, reset, ctx);
-			}
-		}
-		throw new Error(`renderNodeSync: unsupported VNode symbol type: ${String(type)}`);
-	}
-	const typeStr = type;
-	if (VOID_ELEMENTS.has(typeStr)) return `<${typeStr}${renderAttrs(props)} />`;
-	const maybeDangerous = props?.dangerouslySetInnerHTML;
-	if (maybeDangerous !== void 0 && maybeDangerous !== null) {
-		const { attrs, dangerousHtml } = renderAttrs(props, { returnDangerousHtml: true });
-		if (dangerousHtml !== void 0) return `<${typeStr}${attrs}>${dangerousHtml}</${typeStr}>`;
-		return `<${typeStr}${attrs}>${renderChildrenSync(getRenderableChildren(node), ctx)}</${typeStr}>`;
-	}
-	return `<${typeStr}${renderAttrs(props)}>${renderChildrenSync(getRenderableChildren(node), ctx)}</${typeStr}>`;
-}
-function renderNodeSyncToSink(node, sink, ctx) {
-	const { type, props } = node;
-	if (typeof type === "function") {
-		renderRenderableSyncToSink(inheritRenderableKey(node, executeComponentSync(type, props, ctx)), sink, ctx);
-		return;
-	}
-	if (typeof type === "symbol") {
-		if (type === Fragment) {
-			renderChildrenSyncToSink(getRenderableChildren(node), sink, ctx);
-			return;
-		}
-		if (type === __CONTROL_BOUNDARY__) {
-			renderChildrenSyncToSink(evaluateControlBoundaryChildren(node), sink, ctx);
-			return;
-		}
-		if (type === __ERROR_BOUNDARY__) {
-			const boundaryState = getErrorBoundaryState(node);
-			const fallback = props?.fallback;
-			const reset = () => {
-				const state = node.__instance?.errorBoundaryState;
-				if (state) {
-					state.error = null;
-					state.notified = false;
-				}
-			};
-			if (boundaryState?.error != null) {
-				renderErrorBoundaryFallbackValueToSink(fallback, boundaryState.error, reset, sink, ctx);
-				return;
-			}
-			try {
-				renderChildrenSyncToSink(normalizeRenderableChildren(props?.children), sink, ctx);
-			} catch (error) {
-				if (boundaryState) {
-					boundaryState.error = error;
-					boundaryState.notified = true;
-				}
-				logger.error("[Askr] ErrorBoundary caught render error:", error);
-				renderErrorBoundaryFallbackValueToSink(fallback, error, reset, sink, ctx);
-			}
-			return;
-		}
-		throw new Error(`renderNodeSyncToSink: unsupported VNode symbol type: ${String(type)}`);
-	}
-	const typeStr = type;
-	if (VOID_ELEMENTS.has(typeStr)) {
-		sinkWrite2(sink, "<", typeStr);
-		renderAttrsDirect(props, sink);
-		sink.write(" />");
-		return;
-	}
-	const maybeDangerous = props ? props?.dangerouslySetInnerHTML : void 0;
-	if (maybeDangerous !== void 0 && maybeDangerous !== null) {
-		const dangerousHtml = typeof maybeDangerous === "object" && "__html" in maybeDangerous ? String(maybeDangerous.__html) : void 0;
-		sinkWrite2(sink, "<", typeStr);
-		renderAttrsDirect(props, sink);
-		sink.write(">");
-		if (dangerousHtml !== void 0) sink.write(dangerousHtml);
-		else renderChildrenSyncToSink(getRenderableChildren(node), sink, ctx);
-		sinkWrite3(sink, "</", typeStr, ">");
-		return;
-	}
-	const children = getRenderableChildren(node);
-	if (!children || Array.isArray(children) && children.length === 0) {
-		sinkWrite2(sink, "<", typeStr);
-		renderAttrsDirect(props, sink);
-		sink.write(">");
-		sinkWrite3(sink, "</", typeStr, ">");
-		return;
-	}
-	if (Array.isArray(children) && children.length === 1) {
-		const only = children[0];
-		if (typeof only === "string") {
-			const content = escapeText(only);
-			sinkWrite2(sink, "<", typeStr);
-			renderAttrsDirect(props, sink);
-			sink.write(">");
-			sink.write(content);
-			sinkWrite3(sink, "</", typeStr, ">");
-			return;
-		}
-		if (typeof only === "number") {
-			const content = escapeText(String(only));
-			sinkWrite2(sink, "<", typeStr);
-			renderAttrsDirect(props, sink);
-			sink.write(">");
-			sink.write(content);
-			sinkWrite3(sink, "</", typeStr, ">");
-			return;
-		}
-	}
-	sinkWrite2(sink, "<", typeStr);
-	renderAttrsDirect(props, sink);
-	sink.write(">");
-	renderChildrenSyncToSink(children, sink, ctx);
-	sinkWrite3(sink, "</", typeStr, ">");
-}
-/**
-* Execute a component function (synchronously or async) and return VNode
-*/
-/**
-* Execute a component synchronously inside a render-only context.
-* This must not create or reuse runtime ComponentInstance objects. We pass
-* the render context explicitly as `context.ssr` in the second argument so
-* components can opt-in to deterministic randomness/time via the provided RNG.
-*/
-function executeComponentSync(component, props, ctx) {
-	try {
-		pushSSRStrictPurityGuard();
-		const prev = getCurrentComponentInstance();
-		const temp = createComponentInstance("ssr-temp", component, props || {}, null);
-		temp.ssr = true;
-		temp.portalScope = temp;
-		ctx.ssrCleanupFns.push(() => {
-			let cleanupError = null;
-			try {
-				cleanupComponent(temp);
-			} catch (error) {
-				cleanupError = error;
-			}
-			try {
-				disposeDefaultPortalScope(temp);
-			} catch (error) {
-				if (cleanupError) throw new AggregateError([cleanupError, error], "SSR temporary owner cleanup failed");
-				throw error;
-			}
-			if (cleanupError) throw cleanupError;
-		});
-		setCurrentComponentInstance(temp);
-		try {
-			const result = component(props || {}, { ssr: ctx });
-			if (isPromiseLike(result)) throwSSRDataMissing();
-			if (typeof result === "string" || typeof result === "number" || typeof result === "boolean" || result === null || result === void 0) {
-				const inner = result === null || result === void 0 || result === false ? "" : String(result);
-				return {
-					$$typeof: ELEMENT_TYPE,
-					type: Fragment,
-					props: { children: inner ? [inner] : [] }
-				};
-			}
-			return result;
-		} finally {
-			setCurrentComponentInstance(prev);
-		}
-	} finally {
-		popSSRStrictPurityGuard();
-	}
-}
-function disposeSSRTemporaryOwners(ctx) {
-	const cleanupFns = ctx.ssrCleanupFns;
-	ctx.ssrCleanupFns = [];
-	const cleanupErrors = [];
-	for (let index = cleanupFns.length - 1; index >= 0; index -= 1) try {
-		cleanupFns[index]();
-	} catch (error) {
-		cleanupErrors.push(error);
-	}
-	if (cleanupErrors.length === 1) throw cleanupErrors[0];
-	if (cleanupErrors.length > 1) throw new AggregateError(cleanupErrors, "SSR temporary owner cleanup failed");
-}
-function wrapWithDefaultPortal(out) {
-	if (isPromiseLike(out)) throwSSRDataMissing();
-	const portalVNode = {
-		$$typeof: ELEMENT_TYPE,
-		type: DefaultPortal,
-		props: {},
-		key: "__default_portal"
-	};
-	if (out == null) return {
-		$$typeof: ELEMENT_TYPE,
-		type: Fragment,
-		props: { children: [portalVNode] }
-	};
-	return {
-		$$typeof: ELEMENT_TYPE,
-		type: Fragment,
-		props: { children: [out, portalVNode] }
-	};
-}
-function renderSyncComponentRoot(component, props, ctx) {
-	const wrapped = (p, c) => wrapWithDefaultPortal(component(p ?? {}, c));
-	return executeComponentSync(wrapped, props || {}, ctx);
-}
-function getRenderableChildren(node) {
-	if (Array.isArray(node.children)) return node.children;
-	if (Array.isArray(node.props?.children)) return node.props.children;
-	if (node.props?.children !== void 0 && node.props.children !== null && node.props.children !== false) return [node.props.children];
-}
-function flushPendingText(state) {
-	if (state.pendingText.length === 0) return true;
-	if (!state.current || state.current.nodeType !== Node.TEXT_NODE) return false;
-	if (state.current.textContent !== state.pendingText) return false;
-	state.current = state.current.nextSibling;
-	state.pendingText = "";
-	return true;
-}
-function verifyRenderedAttrs(element, props) {
-	const matchedAttrs = /* @__PURE__ */ new Set();
-	let dangerousHtml;
-	if (!props || typeof props !== "object") return {
-		matched: element.attributes.length === 0,
-		dangerousHtml
-	};
-	const propsObj = props;
-	for (const key in propsObj) {
-		const value = propsObj[key];
-		if (key === "children" || key === "key" || key === "ref" || key === "dangerouslySetInnerHTML") {
-			if (key === "dangerouslySetInnerHTML" && value && typeof value === "object" && "__html" in value) dangerousHtml = String(value.__html);
-			continue;
-		}
-		if (isSSRAttrEventHandler(key) || key.charCodeAt(0) === 95) continue;
-		const attrName = key === "class" ? "class" : getPublicAttributeName(key);
-		if (attrName === "style") {
-			const css = typeof value === "string" ? value : styleObjToCss(value);
-			if (!css) continue;
-			if (element.getAttribute("style") !== css) return { matched: false };
-			matchedAttrs.add("style");
-			continue;
-		}
-		if (value === true) {
-			if (!element.hasAttribute(attrName)) return { matched: false };
-			matchedAttrs.add(attrName);
-			continue;
-		}
-		if (value === false || value === null || value === void 0) continue;
-		const stringValue = String(value);
-		if (element.getAttribute(attrName) !== stringValue) return { matched: false };
-		matchedAttrs.add(attrName);
-	}
-	if (element.attributes.length !== matchedAttrs.size) return { matched: false };
-	return {
-		matched: true,
-		dangerousHtml
-	};
-}
-function verifyExpectedNode(node, state, ctx) {
-	if (node === null || node === void 0 || node === false) return true;
-	if (typeof node === "string" || typeof node === "number") {
-		state.pendingText += String(node);
-		return true;
-	}
-	if (Array.isArray(node)) return verifyExpectedChildren(node, state, ctx);
-	if (!node || typeof node !== "object" || !("type" in node)) return true;
-	const vnode = node;
-	const { type, props } = vnode;
-	if (typeof type === "function") return verifyRenderableNode(inheritRenderableKey(vnode, executeComponentSync(type, props, ctx)), state, ctx);
-	if (typeof type === "symbol") {
-		if (type === __CONTROL_BOUNDARY__) {
-			const children = evaluateControlBoundaryChildren(vnode);
-			if (!children || children.length === 0) return true;
-			for (let index = 0; index < children.length; index += 1) if (!verifyExpectedNode(children[index], state, ctx)) return false;
-			return true;
-		}
-		if (type === __ERROR_BOUNDARY__) {
-			const boundaryState = getErrorBoundaryState(vnode);
-			const fallback = props?.fallback;
-			const reset = () => {
-				const stateRef = vnode.__instance?.errorBoundaryState;
-				if (stateRef) {
-					stateRef.error = null;
-					stateRef.notified = false;
-				}
-			};
-			const snapshot = {
-				current: state.current,
-				pendingText: state.pendingText
-			};
-			if (boundaryState?.error != null) return verifyRenderableNode(resolveErrorBoundaryFallbackNode(fallback, boundaryState.error, reset), state, ctx);
-			try {
-				if (verifyExpectedChildren(normalizeRenderableChildren(props?.children), state, ctx)) return true;
-			} catch (error) {
-				if (boundaryState) {
-					boundaryState.error = error;
-					boundaryState.notified = true;
-				}
-			}
-			state.current = snapshot.current;
-			state.pendingText = snapshot.pendingText;
-			return verifyRenderableNode(resolveErrorBoundaryFallbackNode(fallback, boundaryState?.error ?? /* @__PURE__ */ new Error("ErrorBoundary render failed"), reset), state, ctx);
-		}
-		if (type !== Fragment) throw new Error(`verifyHydrationSyncForUrl: unsupported VNode symbol type: ${String(type)}`);
-		const children = getRenderableChildren(vnode);
-		if (!children || children.length === 0) return true;
-		for (let index = 0; index < children.length; index += 1) if (!verifyExpectedNode(children[index], state, ctx)) return false;
-		return true;
-	}
-	if (!flushPendingText(state)) return false;
-	if (!state.current || state.current.nodeType !== Node.ELEMENT_NODE) return false;
-	const actualElement = state.current;
-	if (actualElement.tagName.toLowerCase() !== String(type).toLowerCase()) return false;
-	const attrMatch = verifyRenderedAttrs(actualElement, props);
-	if (!attrMatch.matched) return false;
-	if (VOID_ELEMENTS.has(String(type))) {
-		if (actualElement.firstChild !== null) return false;
-		state.current = actualElement.nextSibling;
-		return true;
-	}
-	if (attrMatch.dangerousHtml !== void 0) {
-		if (actualElement.innerHTML !== attrMatch.dangerousHtml) return false;
-		state.current = actualElement.nextSibling;
-		return true;
-	}
-	const childState = {
-		current: actualElement.firstChild,
-		pendingText: ""
-	};
-	const children = getRenderableChildren(vnode);
-	if (children && children.length > 0) {
-		for (let index = 0; index < children.length; index += 1) if (!verifyExpectedNode(children[index], childState, ctx)) return false;
-	}
-	if (!flushPendingText(childState) || childState.current !== null) return false;
-	state.current = actualElement.nextSibling;
-	return true;
-}
-function verifyExpectedChildren(children, state, ctx) {
-	if (!children || children.length === 0) return true;
-	for (let index = 0; index < children.length; index += 1) if (!verifyExpectedNode(children[index], state, ctx)) return false;
-	return true;
-}
-function verifyRenderableNode(value, state, ctx) {
-	return Array.isArray(value) ? verifyExpectedChildren(normalizeRenderableChildren(value), state, ctx) : verifyExpectedNode(value, state, ctx);
-}
-/**
-* Single synchronous SSR entrypoint: render a component to an HTML string.
-* This is strictly synchronous and deterministic. Optionally provide a seed
-* for deterministic randomness via `options.seed`.
-*/
-function renderToStringSync(component, props, options) {
-	const ctx = createRenderContext(options?.seed ?? 12345, { data: options?.data });
-	return withRenderContext(ctx, () => {
-		startRenderPhase(options?.data ?? null);
-		try {
-			const node = renderSyncComponentRoot(component, props || {}, ctx);
-			if (!node) throw new Error("renderToStringSync: wrapped component returned empty");
-			const sink = new StringSink();
-			renderNodeSyncToSink(node, sink, ctx);
-			sink.write(serializeHydrationRenderData(options?.data));
-			sink.end();
-			return sink.toString();
-		} finally {
-			try {
-				stopRenderPhase();
-			} finally {
-				disposeSSRTemporaryOwners(ctx);
-			}
-		}
-	});
-}
-async function resolveRequest(opts) {
-	const { url, manifest, routes, auth, signal } = opts;
-	if (manifest) return await resolveRouteRequest(url, {
-		manifest,
-		mode: "ssr",
-		auth,
-		signal
-	});
-	if (!routes) throw new Error("resolveRequest requires a route manifest or route table.");
-	const resolved = resolveRouteFromRoutes(new URL(url, "http://localhost").pathname, routes);
-	if (!resolved) return null;
-	return {
-		kind: "render",
-		handler: resolved.handler,
-		params: resolved.params
-	};
-}
-function resolveSSRRouteRender(opts) {
-	const { url, routes, seed = 12345, data, document } = opts;
-	const routeTable = routes.map((route) => ({ ...route }));
-	const requestUrl = new URL(url, "http://localhost");
-	const matched = _resolveRouteMatchFromRoutes(requestUrl.pathname, routeTable);
-	if (!matched) throw new Error(`SSR: no route found for url: ${url}`);
-	const ctx = createRenderContext(seed, {
-		url,
-		data,
-		params: matched.params,
-		routes: routeTable
-	});
-	return {
-		url,
-		requestUrl,
-		route: matched.route,
-		params: matched.params,
-		seed,
-		data,
-		ctx,
-		document
-	};
-}
-function buildDocumentRenderArgs(resolved, appHtml) {
-	return {
-		appHtml,
-		context: {
-			mode: "ssr",
-			url: resolved.url,
-			pathname: resolved.requestUrl.pathname,
-			search: resolved.requestUrl.search,
-			hash: resolved.requestUrl.hash,
-			params: resolved.params,
-			data: resolved.data,
-			seed: resolved.seed,
-			route: {
-				path: resolved.route.path,
-				namespace: resolved.route.namespace
-			}
-		}
-	};
-}
-function renderResolvedRouteAppToSink(resolved, sink) {
-	const { ctx, data, route, params } = resolved;
-	withRenderContext(ctx, () => {
-		startRenderPhase(data || null);
-		try {
-			renderRenderableSyncToSink(executeComponentSync(route.handler, params, ctx), sink, ctx);
-			sink.write(serializeHydrationRenderData(data));
-		} finally {
-			try {
-				stopRenderPhase();
-			} finally {
-				disposeSSRTemporaryOwners(ctx);
-			}
-		}
-	});
-}
-function renderToString(arg) {
-	if (typeof arg === "function") return renderToStringSync(arg);
-	const opts = arg;
-	const sink = new StringSink();
-	renderToSinkInternal({
-		...opts,
-		sink
-	});
-	sink.end();
-	return sink.toString();
-}
-function renderToStream(opts) {
-	const sink = new StreamSink(opts.onChunk, opts.onComplete);
-	renderToSinkInternal({
-		...opts,
-		sink
-	});
-	sink.end();
-}
-function renderToSinkInternal(opts) {
-	const { sink, ...renderOptions } = opts;
-	const resolved = resolveSSRRouteRender(renderOptions);
-	if (!resolved.document) {
-		renderResolvedRouteAppToSink(resolved, sink);
-		return;
-	}
-	const appSink = new StringSink();
-	renderResolvedRouteAppToSink(resolved, appSink);
-	appSink.end();
-	sink.write(renderDocument(resolved.document, buildDocumentRenderArgs(resolved, appSink.toString()), "renderToString()/renderToStream()"));
-}
-//#endregion
+import { renderToStream, renderToString } from "./index-internal.js";
 export { SSRDataMissingError, renderResolvedToStringSync, renderToStream, renderToString, renderToStringSync, resolveRequest };
-
-//# sourceMappingURL=index.js.map