@bgub/fig-server 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist-development/index.js

@@ -0,0 +1,1764 @@
+import { i as escapeText, n as escapeScriptJson, t as escapeAttribute } from "./escaping-DAot8sFu.js";
+import { a as componentStack, c as errorMessage, d as streamHighWaterMark, f as withContextValue, i as cloneContextValues, l as nonceAttribute, n as suppressesImagePreloads, o as createStaticDispatcher, r as STREAMED_METADATA_ATTRIBUTE, s as deferred, t as imagePreloadFromHostProps, u as streamFlowBlocked } from "./image-preloads-D3OBEaWp.js";
+import { Fragment, createElement, isValidElement } from "@bgub/fig";
+import { ACTIVITY_TEMPLATE_ATTRIBUTE, EARLY_EVENT_HANDLER_PROPERTY, EARLY_EVENT_QUEUE_PROPERTY, HYDRATION_SKIP_ATTRIBUTE, REPLAYABLE_EVENT_TYPES, SUSPENSE_CLIENT_MARKER, SUSPENSE_COMPLETED_MARKER, SUSPENSE_END_MARKER, SUSPENSE_MARKER_PREFIX, SUSPENSE_PENDING_PREFIX, TEXT_SEPARATOR_DATA, VIEW_TRANSITION_CLASS_ATTRIBUTE, VIEW_TRANSITION_NAME_ATTRIBUTE, VIEW_TRANSITION_PENDING_PROPERTY, VIEW_TRANSITION_TIMEOUT_MS, assetResourceFromHostProps, assetResourceHostAttributes, assetResourceKey, attachDataStore, collectChildren, createRendererDataStore, invalidChildError, isActivity, isAssets, isClientReference, isContext, isErrorBoundary, isFigAssetResource, isPortal, isSuspense, isThenable, isViewTransition, readThenable, setCurrentDataStore, setCurrentDispatcher, validateInstanceNesting, validateTextNesting } from "@bgub/fig/internal";
+//#region src/html.ts
+const voidElements = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+function writeText(value, sink) {
+	sink.write(escapeText(value));
+}
+function writeElementStart(type, props, sink, inheritedProps = {}) {
+	validateTagName(type);
+	sink.write(`<${type}${serializeAttributes(type, props, inheritedProps)}>`);
+}
+function writeElementEnd(type, sink) {
+	sink.write(`</${type}>`);
+}
+function isVoidElement(type) {
+	return voidElements.has(type);
+}
+function hasRenderableChild(node) {
+	if (Array.isArray(node)) return node.some(hasRenderableChild);
+	if (isPortal(node)) return false;
+	return !emptyChild(node);
+}
+function formTextContent(type, props) {
+	if (type !== "textarea") return null;
+	return formString(props.value !== void 0 ? props.value : props.defaultValue);
+}
+function unsafeHTMLContent(props) {
+	const value = props.unsafeHTML;
+	if (emptyValue(value)) return null;
+	if (typeof value === "string") return value;
+	throw new Error("The unsafeHTML prop must be a string during server render.");
+}
+function serializeAttributes(type, props, inheritedProps) {
+	let attributes = "";
+	for (const name of Object.keys(props)) {
+		const value = props[name];
+		if (reservedProp(name)) continue;
+		if (name === "value" && props.defaultValue !== void 0) continue;
+		if (name === "checked" && props.defaultChecked !== void 0) continue;
+		if (name === "style") {
+			const style = serializeStyle(value);
+			if (style !== "") attributes += serializeAttribute("style", style);
+			continue;
+		}
+		attributes += serializeProp(type, name, value);
+	}
+	if (type === "option" && props.selected === void 0 && optionSelected(optionValue(props), inheritedProps)) attributes += " selected";
+	return attributes;
+}
+function serializeProp(type, name, value) {
+	if ((type === "textarea" || type === "select") && valueProp(name)) return "";
+	let attributeName = name;
+	let attributeValue = value;
+	if (valueProp(name)) {
+		attributeName = "value";
+		if (serializableAttributeValue(value)) attributeValue = String(value);
+	} else if (name === "defaultChecked") {
+		attributeName = "checked";
+		attributeValue = value === true ? true : null;
+	} else if (type === "option" && name === "selected") attributeValue = value === true ? true : null;
+	if (emptyValue(attributeValue)) return "";
+	validateAttributeName(attributeName);
+	if (attributeValue === true) return ` ${attributeName}`;
+	if (serializableAttributeValue(attributeValue)) return serializeAttribute(attributeName, String(attributeValue));
+	throw new Error(`Cannot serialize prop "${name}" to HTML.`);
+}
+function optionSelected(value, selectProps) {
+	const selectValue = selectProps.value !== void 0 ? selectProps.value : selectProps.defaultValue;
+	if (emptyValue(selectValue)) return false;
+	const optionValue = formString(value);
+	if (optionValue === null) return false;
+	return selectedValueSet(selectValue).has(optionValue);
+}
+function optionValue(props) {
+	return props.value === void 0 ? optionTextValue(props.children) : formString(props.value);
+}
+function optionTextValue(node) {
+	if (typeof node === "string" || typeof node === "number") return String(node);
+	if (Array.isArray(node)) {
+		let text = "";
+		for (const child of node) {
+			const childText = optionTextValue(child);
+			if (childText === null) return null;
+			text += childText;
+		}
+		return text;
+	}
+	return null;
+}
+function formString(value) {
+	if (emptyValue(value)) return null;
+	if (serializableAttributeValue(value)) return String(value);
+	return null;
+}
+function selectedValueSet(value) {
+	return new Set(Array.isArray(value) ? value.map(String) : [String(value)]);
+}
+function serializableAttributeValue(value) {
+	return value === true || typeof value === "string" || typeof value === "number" || typeof value === "bigint";
+}
+function emptyValue(value) {
+	return value === null || value === void 0 || value === false;
+}
+function emptyChild(value) {
+	return value === null || value === void 0 || typeof value === "boolean";
+}
+function serializeAttribute(name, value) {
+	return ` ${name}="${escapeAttribute(value)}"`;
+}
+function serializeStyle(value) {
+	if (emptyValue(value)) return "";
+	if (typeof value !== "object" || value === null) throw new Error("The style prop must be an object during server render.");
+	let serialized = "";
+	for (const [name, item] of Object.entries(value)) {
+		if (emptyValue(item)) continue;
+		if (typeof item !== "string" && typeof item !== "number" && typeof item !== "bigint") throw new Error(`Cannot serialize style property "${name}" to HTML.`);
+		if (serialized !== "") serialized += ";";
+		serialized += `${styleName(name)}:${String(item)}`;
+	}
+	return serialized;
+}
+function reservedProp(name) {
+	return name === "children" || name === "key" || name === "mix" || name === "bind" || name === "suppressHydrationWarning" || name === "unsafeHTML" || /^on[A-Z]/.test(name);
+}
+function valueProp(name) {
+	return name === "value" || name === "defaultValue";
+}
+function styleName(name) {
+	if (name.startsWith("--")) return name;
+	return name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+function validateTagName(name) {
+	if (!/^[A-Za-z][A-Za-z0-9:._-]*$/.test(name)) throw new Error(`Invalid HTML tag name "${name}".`);
+}
+function validateAttributeName(name) {
+	if (/[\s"'<>/=]/.test(name)) throw new Error(`Invalid HTML attribute name "${name}".`);
+}
+//#endregion
+//#region src/preload-header.ts
+const DEFAULT_LENGTH = 2e3;
+const HEX_ESCAPE = /^[0-9A-Fa-f]{2}$/;
+const PARAMETER_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const URI_REFERENCE_PUNCTUATION = "-._~:/?#[]@!$&'()*+,;=";
+function createPreloadHeaderEntries(resources, isEarlyImage) {
+	const preconnects = [];
+	const criticalPreloads = [];
+	const stylesheets = [];
+	const remaining = [];
+	for (const resource of resources) {
+		if (!isServerPreloadHeaderResource(resource)) continue;
+		const value = preloadHeaderValue(resource);
+		if (value === null) continue;
+		const entry = {
+			resource,
+			value
+		};
+		if (resource.kind === "preconnect") preconnects.push(entry);
+		else if (resource.kind === "font" || resource.kind === "preload" && (resource.as === "font" || resource.as === "image" && (resource.fetchpriority === "high" || isEarlyImage?.(resource) === true))) criticalPreloads.push(entry);
+		else if (resource.kind === "stylesheet") stylesheets.push(entry);
+		else remaining.push(entry);
+	}
+	return [
+		...preconnects,
+		...criticalPreloads,
+		...stylesheets,
+		...remaining
+	];
+}
+function formatPreloadHeader(entries, options = {}) {
+	const maxLength = normalizedLength(options.maxLength);
+	if (maxLength === 0) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const values = [];
+	let length = 0;
+	for (const entry of entries) {
+		if (options.filter !== void 0 && !options.filter(entry.resource)) continue;
+		if (seen.has(entry.value)) continue;
+		const addedLength = entry.value.length + (values.length === 0 ? 0 : 2);
+		if (length + addedLength > maxLength) continue;
+		seen.add(entry.value);
+		values.push(entry.value);
+		length += addedLength;
+	}
+	return values.length === 0 ? void 0 : values.join(", ");
+}
+function preloadHeaderValue(resource) {
+	switch (resource.kind) {
+		case "stylesheet": return serializeLink(resource.href, [
+			["rel", "preload"],
+			["as", "style"],
+			["crossorigin", resource.crossorigin],
+			["media", resource.media]
+		]);
+		case "preload": return serializeLink(resource.href, [
+			["rel", "preload"],
+			["as", resource.as],
+			["crossorigin", resource.crossorigin],
+			["type", resource.type],
+			["fetchpriority", resource.fetchpriority],
+			["referrerpolicy", resource.referrerpolicy]
+		]);
+		case "modulepreload": return serializeLink(resource.href, [
+			["rel", "modulepreload"],
+			["as", "script"],
+			["crossorigin", resource.crossorigin],
+			["fetchpriority", resource.fetchpriority]
+		]);
+		case "font": return serializeLink(resource.href, [
+			["rel", "preload"],
+			["as", "font"],
+			["crossorigin", resource.crossorigin ?? "anonymous"],
+			["type", resource.type],
+			["fetchpriority", resource.fetchpriority]
+		]);
+		case "preconnect": return serializeLink(resource.href, [["rel", "preconnect"], ["crossorigin", resource.crossorigin]]);
+	}
+}
+function isServerPreloadHeaderResource(resource) {
+	if (resource.kind === "script") return false;
+	return resource.kind !== "preload" || resource.href !== void 0 && (resource.as !== "image" || !resource.imagesrcset);
+}
+function serializeLink(target, parameters) {
+	const encodedTarget = encodeLinkTarget(target);
+	if (encodedTarget === null) return null;
+	const parts = [`<${encodedTarget}>`];
+	for (const [name, value] of parameters) {
+		if (value === void 0) continue;
+		const parameter = serializeParameter(name, value);
+		if (parameter === null) return null;
+		parts.push(parameter);
+	}
+	return parts.join("; ");
+}
+function serializeParameter(name, value) {
+	if (value === "") return name;
+	if (hasInvalidParameterCharacter(value)) return null;
+	if (PARAMETER_TOKEN.test(value)) return `${name}=${value}`;
+	return `${name}="${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+function encodeLinkTarget(value) {
+	if (value === "") return null;
+	let encoded = "";
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code <= 32 || code === 127) return null;
+		const character = value[index];
+		if (character === "%" && HEX_ESCAPE.test(value.slice(index + 1, index + 3))) {
+			encoded += value.slice(index, index + 3);
+			index += 2;
+			continue;
+		}
+		if (code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || URI_REFERENCE_PUNCTUATION.includes(character)) {
+			encoded += character;
+			continue;
+		}
+		const codePoint = value.codePointAt(index);
+		if (codePoint === void 0) return null;
+		const symbol = String.fromCodePoint(codePoint);
+		if (symbol.length === 2) index += 1;
+		try {
+			encoded += encodeURIComponent(symbol);
+		} catch {
+			return null;
+		}
+	}
+	return encoded;
+}
+function hasInvalidParameterCharacter(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code < 32 || code === 127 || code > 255) return true;
+	}
+	return false;
+}
+function normalizedLength(value) {
+	if (value === void 0 || Number.isNaN(value)) return DEFAULT_LENGTH;
+	return Math.max(0, Math.floor(value));
+}
+//#endregion
+//#region src/asset-registry.ts
+var AssetResourceRegistry = class {
+	identifierPrefix;
+	earlyImageKeys = /* @__PURE__ */ new Set();
+	emittedResources = /* @__PURE__ */ new Set();
+	deliveryResources = /* @__PURE__ */ new Map();
+	metadataByOwner = /* @__PURE__ */ new Map();
+	stylesheetIds = /* @__PURE__ */ new Map();
+	nextStylesheetId = 0;
+	constructor(identifierPrefix) {
+		this.identifierPrefix = identifierPrefix;
+	}
+	register(resource) {
+		if (isMetadataResource(resource)) return;
+		this.canonical(resource);
+	}
+	registerAutomaticImage(resource) {
+		const { key, resource: current } = this.canonical(resource);
+		if (this.earlyImageKeys.size < 10 || current.kind === "preload" && current.as === "image" && current.fetchpriority === "high") this.earlyImageKeys.add(key);
+	}
+	isEarlyImage(resource) {
+		return this.earlyImageKeys.has(assetResourceKey(resource));
+	}
+	activateMetadata(owner, resources) {
+		const metadata = resources.filter(isMetadataResource);
+		if (metadata.length === 0) {
+			this.metadataByOwner.delete(owner);
+			return;
+		}
+		this.metadataByOwner.set(owner, metadata);
+	}
+	releaseMetadata(owner) {
+		this.metadataByOwner.delete(owner);
+	}
+	write(resource, sink) {
+		if (isMetadataResource(resource)) return null;
+		const { key, resource: current } = this.canonical(resource);
+		const id = this.revealBlockerId(key, current);
+		if (this.emittedResources.has(key)) return id;
+		this.emittedResources.add(key);
+		writeAssetTag(sink, current, id);
+		return id;
+	}
+	headHtml(nonce, streamMetadata = false) {
+		const { preamble, metadata } = this.headMetadataHtml(nonce, streamMetadata);
+		return preamble + metadata;
+	}
+	headMetadataHtml(nonce, streamMetadata = false) {
+		const buckets = {
+			charset: [],
+			parser: [],
+			viewport: [],
+			metadata: []
+		};
+		for (const resource of this.visibleMetadata().values()) {
+			const bucket = buckets[metadataPhase(resource)];
+			writeAssetTag({
+				nonce,
+				streamMetadata,
+				write: (chunk) => bucket.push(chunk)
+			}, resource, null);
+		}
+		return {
+			preamble: [
+				...buckets.charset,
+				...buckets.parser,
+				...buckets.viewport
+			].join(""),
+			metadata: buckets.metadata.join("")
+		};
+	}
+	metadataSnapshot() {
+		const snapshot = [];
+		for (const [key, resource] of this.visibleMetadata()) if (resource.kind === "title") snapshot.push([
+			key,
+			resource.kind,
+			resource.value
+		]);
+		else snapshot.push([
+			key,
+			resource.kind,
+			metadataAttributes(resource)
+		]);
+		return snapshot;
+	}
+	preloadHeaderEntries() {
+		return createPreloadHeaderEntries(this.deliveryResources.values(), (resource) => this.isEarlyImage(resource));
+	}
+	visibleMetadata() {
+		const visible = /* @__PURE__ */ new Map();
+		for (const metadata of this.metadataByOwner.values()) for (const resource of metadata) visible.set(assetResourceKey(resource), resource);
+		return visible;
+	}
+	canonical(resource) {
+		const key = assetResourceKey(resource);
+		const current = this.deliveryResources.get(key);
+		if (current !== void 0) {
+			if (assetSignature(current) !== assetSignature(resource)) {
+				const promoted = promoteCompatibleImagePreload(current, resource);
+				if (promoted === null) throw new AssetResourceConflictError(key, current, resource);
+				this.deliveryResources.set(key, promoted);
+				return {
+					key,
+					resource: promoted
+				};
+			}
+			return {
+				key,
+				resource: current
+			};
+		}
+		this.deliveryResources.set(key, resource);
+		return {
+			key,
+			resource
+		};
+	}
+	revealBlockerId(key, resource) {
+		if (resource.kind !== "stylesheet") return null;
+		if (resource.blocking === "none") return null;
+		return this.stylesheetIdFor(key);
+	}
+	stylesheetIdFor(key) {
+		const current = this.stylesheetIds.get(key);
+		if (current !== void 0) return current;
+		const id = this.identifierPrefix === "" ? `r-${this.nextStylesheetId}` : `${this.identifierPrefix}-r-${this.nextStylesheetId}`;
+		this.nextStylesheetId += 1;
+		this.stylesheetIds.set(key, id);
+		return id;
+	}
+};
+var AssetResourceConflictError = class extends Error {
+	constructor(key, current, incoming) {
+		super(`Conflicting Fig resource for key "${key}". Existing: ${JSON.stringify(current)}. Incoming: ${JSON.stringify(incoming)}.`);
+	}
+};
+function writeAssetTag(sink, resource, id) {
+	switch (resource.kind) {
+		case "title":
+			writeElementStart("title", {
+				[HYDRATION_SKIP_ATTRIBUTE]: true,
+				[STREAMED_METADATA_ATTRIBUTE]: sink.streamMetadata ? assetResourceKey(resource) : void 0
+			}, sink);
+			writeText(resource.value, sink);
+			writeElementEnd("title", sink);
+			return;
+		case "meta":
+			writeElementStart("meta", {
+				charset: resource.charset,
+				name: resource.name,
+				property: resource.property,
+				"http-equiv": resource["http-equiv"],
+				content: resource.content,
+				[HYDRATION_SKIP_ATTRIBUTE]: true,
+				[STREAMED_METADATA_ATTRIBUTE]: sink.streamMetadata ? assetResourceKey(resource) : void 0,
+				"data-fig-resource-key": resource.key
+			}, sink);
+			return;
+		default: {
+			const props = {
+				[HYDRATION_SKIP_ATTRIBUTE]: true,
+				...Object.fromEntries(assetResourceHostAttributes(resource))
+			};
+			if (resource.kind === "stylesheet" && id !== null) props.id = id;
+			const tag = resource.kind === "script" ? "script" : "link";
+			writeElementStart(tag, withNonce(sink, props), sink);
+			if (tag === "script") writeElementEnd("script", sink);
+		}
+	}
+}
+function isMetadataResource(resource) {
+	return resource.kind === "title" || resource.kind === "meta";
+}
+function metadataPhase(resource) {
+	if (resource.kind === "title") return "metadata";
+	if (resource.charset !== void 0) return "charset";
+	if (normalizedMetadataName(resource["http-equiv"]) === "content-security-policy") return "parser";
+	if (normalizedMetadataName(resource.name) === "viewport") return "viewport";
+	return "metadata";
+}
+function normalizedMetadataName(value) {
+	return value?.trim().toLowerCase();
+}
+function metadataAttributes(resource) {
+	return [
+		["charset", resource.charset],
+		["name", resource.name],
+		["property", resource.property],
+		["http-equiv", resource["http-equiv"]],
+		["content", resource.content],
+		["data-fig-resource-key", resource.key]
+	].filter((entry) => entry[1] !== void 0);
+}
+function withNonce(sink, props) {
+	return sink.nonce === void 0 ? props : {
+		...props,
+		nonce: sink.nonce
+	};
+}
+function assetSignature(resource) {
+	switch (resource.kind) {
+		case "stylesheet": return signature(resource.kind, resource.href, resource.media ?? "", resource.precedence ?? "", resource.crossorigin ?? "", resource.blocking ?? "reveal");
+		case "preload": {
+			const imagesrcset = resource.as === "image" ? resource.imagesrcset || void 0 : void 0;
+			return signature(resource.kind, imagesrcset === void 0 ? resource.href ?? "" : "", resource.as, resource.type ?? "", resource.crossorigin ?? "", resource.fetchpriority ?? "", imagesrcset ?? "", imagesrcset === void 0 ? "" : resource.imagesizes ?? "", resource.referrerpolicy ?? "");
+		}
+		case "modulepreload": return signature(resource.kind, resource.href, resource.crossorigin ?? "", resource.fetchpriority ?? "");
+		case "font": return signature("preload", resource.href, "font", resource.type, resource.crossorigin ?? "anonymous", resource.fetchpriority ?? "", "", "", "");
+		case "preconnect": return signature(resource.kind, resource.href, resource.crossorigin ?? "");
+		case "script": return signature(resource.kind, resource.src, resource.module === true, resource.async !== false, resource.defer === true, resource.crossorigin ?? "");
+		case "title": return signature(resource.kind, resource.value);
+		case "meta": return signature(resource.kind, resource.charset ?? "", resource.name ?? "", resource.property ?? "", resource["http-equiv"] ?? "", resource.content ?? "");
+	}
+	return unsupportedAssetResource(resource);
+}
+function promoteCompatibleImagePreload(current, incoming) {
+	if (current.kind !== "preload" || incoming.kind !== "preload" || current.as !== "image" || incoming.as !== "image" || assetSignature({
+		...current,
+		fetchpriority: incoming.fetchpriority
+	}) !== assetSignature(incoming)) return null;
+	const currentPriority = current.fetchpriority === "auto" ? void 0 : current.fetchpriority;
+	const incomingPriority = incoming.fetchpriority === "auto" ? void 0 : incoming.fetchpriority;
+	if (currentPriority === incomingPriority) return current;
+	if (currentPriority === "low" || incomingPriority === "low") return null;
+	return currentPriority === "high" ? current : {
+		...current,
+		fetchpriority: "high"
+	};
+}
+function unsupportedAssetResource(resource) {
+	throw new Error(`Unsupported asset resource kind: ${resource.kind}`);
+}
+function signature(...values) {
+	return JSON.stringify(values);
+}
+//#endregion
+//#region src/protocol.ts
+function serverRuntimeCodeFor(runtimeName) {
+	return `globalThis[${jsString(runtimeName)}]??={r(a,f){let n=0,d=()=>{--n||f()};for(let i of a){let e=document.getElementById(i);if(e&&e.tagName==='LINK'&&e.rel==='stylesheet'&&!e.sheet){n++;e.addEventListener('load',d,{once:true});e.addEventListener('error',d,{once:true})}}n||f()},q(e,a){if(e&&e.nodeType===1){if(e.hasAttribute&&e.hasAttribute('${VIEW_TRANSITION_NAME_ATTRIBUTE}'))a.push([e,e.getAttribute('${VIEW_TRANSITION_NAME_ATTRIBUTE}'),e.getAttribute('${VIEW_TRANSITION_CLASS_ATTRIBUTE}')]);if(e.querySelectorAll)for(let x of e.querySelectorAll('[${VIEW_TRANSITION_NAME_ATTRIBUTE}]'))a.push([x,x.getAttribute('${VIEW_TRANSITION_NAME_ATTRIBUTE}'),x.getAttribute('${VIEW_TRANSITION_CLASS_ATTRIBUTE}')])}},g(r){let a=[];this.q(r,a);return a},h(b){let a=[],d=0;for(let e=b;e;){if(e.nodeType===8){if(e.data.indexOf('${SUSPENSE_MARKER_PREFIX}')===0)d++;else if(e.data==='${SUSPENSE_END_MARKER}'){if(d===0)break;d--}}else this.q(e,a);e=e.nextSibling}return a},a(l){for(let x of l){let e=x[0],s=e.style;x[3]=s.viewTransitionName;x[4]=s.viewTransitionClass;s.viewTransitionName=x[1];if(x[2])s.viewTransitionClass=x[2]}},u(l){for(let x of l){let e=x[0],s=e.style;s.viewTransitionName=x[3]||'';s.viewTransitionClass=x[4]||'';!(e.getAttribute&&e.getAttribute('style'))&&e.removeAttribute&&e.removeAttribute('style')}},z(l){for(let f of l)f()},j(t,r){let p=t&&(t.ready||t.finished);p&&p.then?p.then(r,()=>{let f=t&&t.finished;f&&f.then?f.then(r,r):r()}):r()},v(b,s,f){let o=this.h(b),n=this.g(s);if(!o.length&&!n.length){f();return}let d=document,w=d.startViewTransition;if(typeof w!='function'){f();return}let p=d.${VIEW_TRANSITION_PENDING_PROPERTY},pw=p&&(p.finished||p.ready);if(pw&&pw.then){let q=0,i,g=()=>{if(q)return;q=1;clearTimeout(i);d.${VIEW_TRANSITION_PENDING_PROPERTY}===p&&(d.${VIEW_TRANSITION_PENDING_PROPERTY}=null);this.v(b,s,f)};i=setTimeout(g,${VIEW_TRANSITION_TIMEOUT_MS});pw.then(g,g);return}this.a(o);let m=0,l=[],r=()=>{this.u(o);this.u(n);this.z(l)};try{let t=w.call(d,()=>{m=1;f(l);this.a(n)});if(t){d.${VIEW_TRANSITION_PENDING_PROPERTY}=t;let c=()=>{d.${VIEW_TRANSITION_PENDING_PROPERTY}===t&&(d.${VIEW_TRANSITION_PENDING_PROPERTY}=null)},cw=t.finished||t.ready;cw&&cw.then?cw.then(c,c):c()}this.j(t,r)}catch(e){r();if(m)throw e;f()}},m(a){let h=document.head,e=new Map;for(let n of h.querySelectorAll('[${STREAMED_METADATA_ATTRIBUTE}]'))e.set(n.getAttribute('${STREAMED_METADATA_ATTRIBUTE}'),n);for(let d of a){let k=d[0],t=d[1],v=d[2],n=e.get(k);if(!n||n.tagName.toLowerCase()!==t){n&&n.remove();n=document.createElement(t);n.setAttribute('${STREAMED_METADATA_ATTRIBUTE}',k);n.setAttribute('${HYDRATION_SKIP_ATTRIBUTE}','');h.appendChild(n)}e.delete(k);if(t==='title')n.textContent=v;else{for(let x of Array.from(n.attributes))if(x.name!=='${STREAMED_METADATA_ATTRIBUTE}'&&x.name!=='${HYDRATION_SKIP_ATTRIBUTE}')n.removeAttribute(x.name);for(let x of v)n.setAttribute(x[0],x[1])}}for(let n of e.values())n.remove()},s(p,s){p=document.getElementById(p);s=document.getElementById(s);if(!p||!s)return;this.v(p,s,()=>{while(s.firstChild)p.parentNode.insertBefore(s.firstChild,p);p.remove();s.remove()})},f(r,i){if(!r)return null;if(r.id===i)return r;for(let e of r.querySelectorAll?r.querySelectorAll('[id]'):[])if(e.id===i)return e;return null},b(t,b){let e=document.getElementById(t),r=e&&(e.content||e);return this.f(r,b)||document.getElementById(b)},c(b,s,m){let x=document.getElementById(b),y=document.getElementById(s);this.v(x,y,r=>this.o(x,y,r,m))},o(b,s,l,m){if(!b||!s)return;let a=b.previousSibling||b,p=a.parentNode,c=s.content||s;if(!p)return;let r=a.nodeType===8&&a.__figRetry;if(!r&&m)this.m(m);while(c.firstChild)p.insertBefore(c.firstChild,b);for(let e=b,d=0;e;){if(e.nodeType===8){if(e.data.indexOf('${SUSPENSE_MARKER_PREFIX}')===0)d++;else if(e.data==='${SUSPENSE_END_MARKER}'){if(d===0)break;d--}}let x=e.nextSibling;e.remove();e=x}s.remove();if(a.nodeType===8){a.data='${SUSPENSE_COMPLETED_MARKER}';if(r){if(l)l.push(r);else r()}}},x(b,d,m){this.y(document.getElementById(b),d,m)},y(b,d,m){if(!b)return;let s=b.previousSibling;if(s&&s.nodeType===8){s.data='${SUSPENSE_CLIENT_MARKER}';if(d)b.dataset.dgst=d;if(m)b.dataset.msg=m;s.__figRetry&&s.__figRetry()}},ac(t,b,s,m){let x=this.b(t,b),y=document.getElementById(s);this.v(x,y,r=>this.o(x,y,r,m))},ax(t,b,d,m){this.y(this.b(t,b),d,m)}}`;
+}
+function writeRuntime$1(request, write) {
+	if (request.runtimeWritten) return;
+	request.runtimeWritten = true;
+	writeScript$1(request, serverRuntimeCodeFor(request.runtimeName), write);
+}
+function writeScript$1(request, code, write) {
+	write(`<script ${HYDRATION_SKIP_ATTRIBUTE}=""${nonceAttribute(request.nonce)}>${code}<\/script>`);
+}
+function earlyEventCaptureCode() {
+	return `(d=>{if(d.${EARLY_EVENT_QUEUE_PROPERTY})return;let q=d.${EARLY_EVENT_QUEUE_PROPERTY}=[],h=d.${EARLY_EVENT_HANDLER_PROPERTY}=e=>{q.push(e)};for(let t of [${REPLAYABLE_EVENT_TYPES.map((type) => `'${type}'`).join(",")}])d.addEventListener(t,h,!0)})(document)`;
+}
+function earlyEventCaptureMarkup(request) {
+	return `<script ${HYDRATION_SKIP_ATTRIBUTE}=""${nonceAttribute(request.nonce)}>${earlyEventCaptureCode()}<\/script>`;
+}
+function placeholderMarkup(request, id) {
+	return templateMarkup(placeholderId(request, id));
+}
+function boundaryPlaceholderMarkup(request, id) {
+	return templateMarkup(boundaryId(request, id));
+}
+function templateMarkup(id) {
+	return `<template id="${escapeAttribute(id)}"></template>`;
+}
+function segmentContainerStartMarkup(request, id) {
+	return `<div hidden id="${escapeAttribute(segmentId(request, id))}">`;
+}
+function activityId(request, id) {
+	return prefixedId(request, "a", id);
+}
+function placeholderId(request, id) {
+	return prefixedId(request, "p", id);
+}
+function segmentId(request, id) {
+	return prefixedId(request, "s", id);
+}
+function boundaryId(request, id) {
+	return prefixedId(request, "b", id);
+}
+function jsString(value) {
+	return escapeScriptJson(value);
+}
+function prefixedId(request, kind, id) {
+	return request.identifierPrefix === "" ? `${kind}-${id}` : `${request.identifierPrefix}-${kind}-${id}`;
+}
+//#endregion
+//#region src/renderer-flush.ts
+const documentHeadMarker = Symbol("fig.document-head");
+const leadingNewlineStartMarker = Symbol("fig.leading-newline-start");
+const leadingNewlineEndMarker = Symbol("fig.leading-newline-end");
+const RUNTIME_REF = "__figSSR";
+const textEncoder = new TextEncoder();
+function flushCompletedQueues(request) {
+	if (request.controller === null || request.status === "closed") return;
+	if (request.pendingRootTasks > 0) return;
+	if (request.prerender && request.pendingTasks > 0) return;
+	if (request.flushing) return;
+	request.flushing = true;
+	try {
+		sealHead(request);
+		if (request.completedRootSegment !== null) {
+			flushSegment(request, request.completedRootSegment);
+			request.completedRootSegment = null;
+			flushWriteBuffer(request);
+		}
+		if (!drainBoundaryQueue(request, request.clientRenderedBoundaries, flushClientRenderedBoundary) && !drainBoundaryQueue(request, request.completedBoundaries, flushCompletedBoundary)) drainBoundaryQueue(request, request.partialBoundaries, flushPartialBoundary);
+		flushWriteBuffer(request);
+	} finally {
+		request.flushing = false;
+	}
+	if (request.pendingTasks === 0 && request.completedBoundaries.size === 0 && request.clientRenderedBoundaries.size === 0 && request.partialBoundaries.size === 0) {
+		request.cleanupAbortListener();
+		request.status = "closed";
+		request.dataStore.dispose();
+		request.controller.close();
+	}
+}
+function sealHead(request) {
+	if (request.headSnapshot !== null) return;
+	activateVisibleMetadata(request, request.rootSegment);
+	const metadata = request.assetRegistry.headMetadataHtml(request.nonce, !request.prerender && request.pendingTasks > 0);
+	request.headSnapshot = {
+		...metadata,
+		preloadHeaderEntries: request.assetRegistry.preloadHeaderEntries()
+	};
+	request.headReady.resolve(metadata.preamble + metadata.metadata);
+}
+function flushSegment(request, segment) {
+	if (segment.status === "flushed") return;
+	if (segment.boundary !== null) {
+		flushSuspenseBoundary(request, segment, segment.boundary);
+		return;
+	}
+	flushSubtree(request, segment);
+}
+function flushSubtree(request, segment) {
+	segment.parentFlushed = true;
+	if (segment.status === "pending" || segment.status === "rendering") {
+		request.write(placeholderMarkup(request, ensureSegmentId(request, segment)));
+		return;
+	}
+	if (segment.status === "flushed") return;
+	segment.status = "flushed";
+	if (request.document === null || segment !== request.rootSegment) flushSegmentAssets(request, segment);
+	let chunkIndex = 0;
+	for (const child of segment.children) {
+		for (; chunkIndex < child.index; chunkIndex += 1) writeChunk(request, segment.chunks[chunkIndex], segment);
+		flushSegment(request, child);
+	}
+	for (; chunkIndex < segment.chunks.length; chunkIndex += 1) writeChunk(request, segment.chunks[chunkIndex], segment);
+}
+function flushSuspenseBoundary(request, segment, boundary) {
+	boundary.parentFlushed = true;
+	if (boundary.status === "completed") {
+		request.write(`<!--${SUSPENSE_COMPLETED_MARKER}-->`);
+		flushBoundaryContent(request, boundary);
+		request.write(`<!--${SUSPENSE_END_MARKER}-->`);
+		segment.status = "flushed";
+		return;
+	}
+	if (request.prerender && boundary.status === "client-rendered") {
+		request.write(`<!--${SUSPENSE_CLIENT_MARKER}-->`);
+		request.write(clientRenderedBoundaryPlaceholderMarkup(request, boundary));
+		flushSubtree(request, segment);
+		request.write(`<!--${SUSPENSE_END_MARKER}-->`);
+		return;
+	}
+	const boundaryIdValue = ensureBoundaryId(request, boundary);
+	flushSegmentAssets(request, boundary.contentSegment);
+	request.write(`<!--${SUSPENSE_PENDING_PREFIX}${boundaryIdValue}-->`);
+	request.write(boundaryPlaceholderMarkup(request, boundaryIdValue));
+	flushSubtree(request, segment);
+	request.write(`<!--${SUSPENSE_END_MARKER}-->`);
+	if (boundary.status === "client-rendered") request.clientRenderedBoundaries.add(boundary);
+	else if (boundary.completedSegments.length > 0) request.partialBoundaries.add(boundary);
+}
+function flushBoundaryContent(request, boundary) {
+	for (const segment of boundary.completedSegments) flushSegment(request, segment);
+	boundary.completedSegments = [];
+}
+function clientRenderedBoundaryPlaceholderMarkup(request, boundary) {
+	const id = escapeAttribute(boundaryId(request, ensureBoundaryId(request, boundary)));
+	const digest = boundary.error?.digest;
+	const message = boundary.error?.message;
+	return `<template id="${id}"${digest === void 0 || digest === "" ? "" : ` data-dgst="${escapeAttribute(digest)}"`}${message === void 0 || message === "" ? "" : ` data-msg="${escapeAttribute(message)}"`}></template>`;
+}
+function flushCompletedBoundary(request, boundary) {
+	flushPartialBoundary(request, boundary);
+	writeBoundaryRevealScript(request, boundary);
+}
+function flushPartialBoundary(request, boundary) {
+	for (const segment of boundary.completedSegments) flushBoundarySegment(request, boundary, segment);
+	boundary.completedSegments = [];
+}
+function flushBoundarySegment(request, boundary, segment) {
+	ensureBoundaryId(request, boundary);
+	const blockingIds = flushSegmentContainer(request, segment);
+	if (segment !== boundary.contentSegment) writeSegmentRevealScript(request, segment, blockingIds);
+}
+function writeSegmentRevealScript(request, segment, blockingIds) {
+	const id = ensureSegmentId(request, segment);
+	writeRuntime(request);
+	writeScript(request, withAssetGate(blockingIds, `${RUNTIME_REF}.s(${jsString(placeholderId(request, id))},${jsString(segmentId(request, id))})`));
+}
+function writeBoundaryRevealScript(request, boundary) {
+	const blockingIds = flushSegmentAssets(request, boundary.contentSegment);
+	const metadata = switchBoundaryMetadata(request, boundary);
+	const metadataArgument = metadata === null ? "" : `,${metadata}`;
+	writeRuntime(request);
+	const boundaryRef = jsString(boundaryId(request, ensureBoundaryId(request, boundary)));
+	const contentRef = jsString(segmentId(request, ensureSegmentId(request, boundary.contentSegment)));
+	writeScript(request, withAssetGate(blockingIds, boundary.activityId === null ? `${RUNTIME_REF}.c(${boundaryRef},${contentRef}${metadataArgument})` : `${RUNTIME_REF}.ac(${jsString(boundary.activityId)},${boundaryRef},${contentRef}${metadataArgument})`));
+}
+function switchBoundaryMetadata(request, boundary) {
+	if (!boundary.metadataVisible) return null;
+	const before = escapeScriptJson(request.assetRegistry.metadataSnapshot());
+	const fallback = boundary.fallbackSegment;
+	if (fallback !== null) {
+		request.assetRegistry.releaseMetadata(fallback);
+		for (const child of fallback.children) deactivateMetadataTree(request, child);
+	}
+	activateVisibleMetadata(request, boundary.contentSegment);
+	const after = escapeScriptJson(request.assetRegistry.metadataSnapshot());
+	return before === after ? null : after;
+}
+function activateVisibleMetadata(request, segment) {
+	if (segment.status === "pending" || segment.status === "rendering") return;
+	const boundary = segment.boundary;
+	if (boundary !== null) {
+		boundary.metadataVisible = true;
+		if (boundary.status === "completed") {
+			activateVisibleMetadata(request, boundary.contentSegment);
+			return;
+		}
+	}
+	request.assetRegistry.activateMetadata(segment, segment.assetResources);
+	for (const child of segment.children) activateVisibleMetadata(request, child);
+}
+function deactivateMetadataTree(request, segment) {
+	request.assetRegistry.releaseMetadata(segment);
+	for (const child of segment.children) deactivateMetadataTree(request, child);
+	const boundary = segment.boundary;
+	if (boundary === null) return;
+	boundary.metadataVisible = false;
+	deactivateMetadataTree(request, boundary.contentSegment);
+}
+function flushSegmentContainer(request, segment) {
+	if (segment.status === "flushed") return [];
+	const blockingIds = flushSegmentAssets(request, segment);
+	request.write(segmentContainerStartMarkup(request, ensureSegmentId(request, segment)));
+	flushSegment(request, segment);
+	request.write("</div>");
+	return blockingIds;
+}
+function flushSegmentAssets(request, segment) {
+	const blockingIds = /* @__PURE__ */ new Set();
+	collectSegmentAssets(request, segment, blockingIds);
+	return [...blockingIds];
+}
+function collectSegmentAssets(request, segment, blockingIds) {
+	if (segment.status !== "pending" && segment.status !== "rendering") flushAssetList(request, segment.assetResources, blockingIds);
+	for (const child of segment.children) collectSegmentAssets(request, child, blockingIds);
+}
+function flushAssetList(request, resources, blockingIds) {
+	for (const resource of resources) {
+		const id = request.assetRegistry.write(resource, request);
+		if (id !== null) blockingIds.add(id);
+	}
+}
+function withAssetGate(blockingIds, call) {
+	if (blockingIds.length === 0) return call;
+	return `${RUNTIME_REF}.r([${blockingIds.map(jsString).join(",")}],()=>{${call}})`;
+}
+function flushClientRenderedBoundary(request, boundary) {
+	if (boundary.id === null) return;
+	writeRuntime(request);
+	const boundaryRef = jsString(boundaryId(request, boundary.id));
+	const digest = jsString(boundary.error?.digest ?? "");
+	const message = jsString(boundary.error?.message ?? "");
+	writeScript(request, boundary.activityId === null ? `${RUNTIME_REF}.x(${boundaryRef},${digest},${message})` : `${RUNTIME_REF}.ax(${jsString(boundary.activityId)},${boundaryRef},${digest},${message})`);
+}
+function drainBoundaryQueue(request, queue, flush) {
+	for (;;) {
+		if (streamFlowBlocked(request.controller)) return true;
+		const first = queue.values().next();
+		if (first.done === true) return false;
+		flush(request, first.value);
+		queue.delete(first.value);
+		flushWriteBuffer(request);
+	}
+}
+function writeRuntime(request) {
+	writeRuntime$1(request, (chunk) => request.write(chunk));
+}
+function writeScript(request, code) {
+	writeScript$1(request, `(__figSSR=>{${code}})(globalThis[${jsString(request.runtimeName)}])`, (chunk) => request.write(chunk));
+}
+function writeChunk(request, chunk, segment) {
+	if (chunk === leadingNewlineStartMarker) {
+		request.leadingNewlineStack.push(false);
+		return;
+	}
+	if (chunk === leadingNewlineEndMarker) {
+		request.leadingNewlineStack.pop();
+		return;
+	}
+	if (typeof chunk === "object") {
+		request.write(request.leadingNewlineStack.at(-1) === false && chunk.value.startsWith("\n") ? `\n${chunk.value}` : chunk.value);
+		return;
+	}
+	if (chunk !== documentHeadMarker) {
+		request.write(chunk);
+		return;
+	}
+	if (request.document === null) return;
+	const metadata = request.headSnapshot ?? request.assetRegistry.headMetadataHtml(request.nonce);
+	const [beforeMetadata, afterMetadata] = partitionHeadAssets(request, segment.assetResources);
+	const blockingIds = /* @__PURE__ */ new Set();
+	request.write(metadata.preamble);
+	flushAssetList(request, beforeMetadata, blockingIds);
+	request.write(metadata.metadata);
+	flushAssetList(request, afterMetadata, blockingIds);
+}
+function partitionHeadAssets(request, resources) {
+	const preconnects = [];
+	const criticalPreloads = [];
+	const stylesheets = [];
+	const afterMetadata = [];
+	for (const resource of resources) if (resource.kind === "preconnect") preconnects.push(resource);
+	else if (resource.kind === "font" || resource.kind === "preload" && (resource.as === "font" || resource.as === "image" && (resource.fetchpriority === "high" || request.assetRegistry.isEarlyImage(resource)))) criticalPreloads.push(resource);
+	else if (resource.kind === "stylesheet") stylesheets.push(resource);
+	else afterMetadata.push(resource);
+	return [[
+		...preconnects,
+		...criticalPreloads,
+		...stylesheets
+	], afterMetadata];
+}
+function flushWriteBuffer(request) {
+	if (request.writeBuffer.length === 0 || request.controller === null) return;
+	request.controller.enqueue(textEncoder.encode(request.writeBuffer.join("")));
+	request.writeBuffer = [];
+}
+function ensureSegmentId(request, segment) {
+	segment.id ??= request.nextSegmentId++;
+	return segment.id;
+}
+function ensureBoundaryId(request, boundary) {
+	boundary.id ??= request.nextBoundaryId++;
+	return boundary.id;
+}
+//#endregion
+//#region src/renderer.ts
+const errorStacks = /* @__PURE__ */ new WeakMap();
+const TEXT_SEPARATOR = `<!--${TEXT_SEPARATOR_DATA}-->`;
+let nextRuntimeId = 0;
+function createServerRenderRequest(node, options = {}, mode = {}) {
+	throwIfAborted(options.signal);
+	const shellReady = deferred();
+	const headReady = deferred();
+	const allReady = deferred();
+	shellReady.promise.catch(() => void 0);
+	headReady.promise.catch(() => void 0);
+	allReady.promise.catch(() => void 0);
+	const rootSegment = createSegment(0, null);
+	const dataStoreHost = {
+		getLane: () => null,
+		partition: options.dataPartition,
+		schedule: () => void 0
+	};
+	const dataStore = options.dataStore === void 0 ? createRendererDataStore(dataStoreHost) : attachDataStore(options.dataStore, dataStoreHost, options.initialData);
+	const request = {
+		abortableTasks: /* @__PURE__ */ new Set(),
+		allReady,
+		cleanupAbortListener: () => void 0,
+		completedBoundaries: /* @__PURE__ */ new Set(),
+		completedRootSegment: null,
+		controller: null,
+		dataStore,
+		fatalError: null,
+		identifierPrefix: options.identifierPrefix ?? "",
+		leadingNewlineStack: [],
+		nextBoundaryId: 0,
+		nextSegmentId: 0,
+		nextActivityId: 0,
+		nextViewTransitionId: 0,
+		nonce: options.nonce,
+		onError: options.onError,
+		pendingRootTasks: 0,
+		pendingTasks: 0,
+		pingedTasks: [],
+		rootSegment,
+		runtimeName: createRuntimeName(options.identifierPrefix),
+		runtimeWritten: false,
+		headReady,
+		headSnapshot: null,
+		shellReady,
+		status: "open",
+		clientRenderedBoundaries: /* @__PURE__ */ new Set(),
+		clientReferenceFallback: options.clientReferenceFallback,
+		partialBoundaries: /* @__PURE__ */ new Set(),
+		prerender: mode.prerender === true,
+		componentAssets: options.assets,
+		document: mode.document === true ? { hasHead: false } : null,
+		assetRegistry: new AssetResourceRegistry(options.identifierPrefix ?? ""),
+		resolveAssetKey: options.resolveAssetKey,
+		workScheduled: false,
+		flushing: false,
+		writeBuffer: [],
+		write(chunk) {
+			if (chunk !== "" && this.leadingNewlineStack.length > 0) this.leadingNewlineStack[this.leadingNewlineStack.length - 1] = true;
+			this.writeBuffer.push(chunk);
+		}
+	};
+	if (options.dataStore === void 0 && options.initialData !== void 0) request.dataStore.hydrate(options.initialData);
+	rootSegment.parentFlushed = true;
+	const rootTask = createTask(request, node, rootSegment, {
+		abortSet: request.abortableTasks,
+		boundary: null,
+		contextValues: /* @__PURE__ */ new Map(),
+		hiddenActivityId: null,
+		hostAncestors: [],
+		hostNamespace: "html",
+		imagePreloadsSuppressed: false,
+		idPath: "",
+		pendingLeadingNewline: false,
+		selectProps: null,
+		stack: null,
+		treeParent: options.renderTree?.tree ?? null,
+		viewTransition: null
+	});
+	request.pingedTasks.push(rootTask);
+	const stream = new ReadableStream({
+		start(streamController) {
+			request.controller = streamController;
+			flushCompletedQueues(request);
+		},
+		pull() {
+			flushCompletedQueues(request);
+		},
+		cancel(reason) {
+			request.controller = null;
+			request.writeBuffer = [];
+			abort(request, reason);
+			request.status = "closed";
+		}
+	}, new ByteLengthQueuingStrategy({ highWaterMark: streamHighWaterMark(options.highWaterMark) }));
+	if (options.signal !== void 0) {
+		const signal = options.signal;
+		const abortListener = () => abort(request, signal.reason);
+		signal.addEventListener("abort", abortListener, { once: true });
+		request.cleanupAbortListener = () => {
+			signal.removeEventListener("abort", abortListener);
+			request.cleanupAbortListener = () => void 0;
+		};
+	}
+	request.workScheduled = true;
+	queueMicrotask(() => {
+		request.workScheduled = false;
+		performWork(request);
+	});
+	return {
+		abort: (reason) => abort(request, reason),
+		allReady: allReady.promise,
+		contentType: "text/html; charset=utf-8",
+		data: request.dataStore,
+		getData: () => request.dataStore.snapshot(),
+		getPreloadHeader: (headerOptions) => request.headSnapshot === null ? void 0 : formatPreloadHeader(request.headSnapshot.preloadHeaderEntries, headerOptions),
+		getHead: () => {
+			const snapshot = request.headSnapshot;
+			return snapshot === null ? request.assetRegistry.headHtml(request.nonce) : snapshot.preamble + snapshot.metadata;
+		},
+		headReady: headReady.promise,
+		shellReady: shellReady.promise,
+		stream
+	};
+}
+function createTask(request, node, segment, scope, childIndexBase = 0) {
+	request.pendingTasks += 1;
+	if (scope.boundary === null) request.pendingRootTasks += 1;
+	else scope.boundary.pendingTasks += 1;
+	const task = {
+		...scope,
+		childIndexBase,
+		node,
+		segment
+	};
+	request.abortableTasks.add(task);
+	scope.abortSet.add(task);
+	return task;
+}
+function forkScope(scope) {
+	return {
+		abortSet: scope.abortSet,
+		boundary: scope.boundary,
+		contextValues: cloneContextValues(scope.contextValues),
+		hiddenActivityId: scope.hiddenActivityId,
+		hostAncestors: scope.hostAncestors,
+		hostNamespace: scope.hostNamespace,
+		imagePreloadsSuppressed: scope.imagePreloadsSuppressed,
+		idPath: scope.idPath,
+		pendingLeadingNewline: scope.pendingLeadingNewline,
+		selectProps: scope.selectProps,
+		stack: scope.stack,
+		treeParent: scope.treeParent,
+		viewTransition: scope.viewTransition === null ? null : { ...scope.viewTransition }
+	};
+}
+function createSegment(index, boundary, textSeams = {
+	lastPushedText: false,
+	textEmbedded: false
+}) {
+	return {
+		boundary,
+		children: [],
+		chunks: [],
+		id: null,
+		index,
+		lastPushedText: textSeams.lastPushedText,
+		parentFlushed: false,
+		assetResources: [],
+		status: "pending",
+		textEmbedded: textSeams.textEmbedded,
+		write(chunk) {
+			this.lastPushedText = false;
+			this.chunks.push(chunk);
+		}
+	};
+}
+function createBoundary(fallbackAbortableTasks, contentSegment) {
+	return {
+		activityId: null,
+		completedSegments: [],
+		contentSegment,
+		error: null,
+		fallbackSegment: null,
+		fallbackAbortableTasks,
+		id: null,
+		parentFlushed: false,
+		pendingTasks: 0,
+		status: "pending",
+		metadataVisible: false
+	};
+}
+function performWork(request) {
+	if (request.status === "closed") return;
+	const tasks = request.pingedTasks;
+	request.pingedTasks = [];
+	for (const task of tasks) retryTask(request, task);
+	flushCompletedQueues(request);
+}
+function retryTask(request, task) {
+	if (task.segment.status !== "pending") return;
+	task.segment.status = "rendering";
+	const frame = createRenderFrame(request, task.segment, forkScope(task));
+	try {
+		renderChildSequence(collectChildren(task.node), frame, task.childIndexBase);
+		completeSegmentText(task.segment);
+		task.segment.status = "completed";
+		detachTask(request, task);
+		finishedTask(request, task);
+	} catch (error) {
+		detachTask(request, task);
+		task.segment.status = "completed";
+		erroredTask(request, task, error);
+	}
+}
+function createRenderFrame(request, segment, scope) {
+	return {
+		...scope,
+		dispatcher: null,
+		localIdCounter: 0,
+		request,
+		segment
+	};
+}
+function createServerDispatcher(frame) {
+	return createStaticDispatcher({
+		contextValues: frame.contextValues,
+		externalStoreError: "useSyncExternalStore requires getServerSnapshot during server render.",
+		readPromise(promise) {
+			throwIfAborting(frame.request);
+			return readThenable(promise);
+		},
+		readData(resource, args) {
+			throwIfAborting(frame.request);
+			return frame.request.dataStore.readData(resource, args, frame);
+		},
+		preloadData(resource, args) {
+			throwIfAborting(frame.request);
+			frame.request.dataStore.preloadData(resource, ...args);
+		},
+		useId() {
+			const id = `${frame.request.identifierPrefix}fig-${frame.idPath}-${frame.localIdCounter.toString(32)}`;
+			frame.localIdCounter += 1;
+			return id;
+		},
+		updateError: "State updates are not allowed during server render."
+	});
+}
+function renderNode(node, frame) {
+	if (Array.isArray(node)) {
+		renderChildren(node, frame);
+		return;
+	}
+	if (node === null || node === void 0 || typeof node === "boolean") return;
+	if (typeof node === "string" || typeof node === "number") {
+		const text = String(node);
+		if (frame.request.document !== null && !frame.request.document.hasHead) {
+			if (text.trim() !== "") throw invalidDocumentShellError();
+		}
+		if (frame.hostNamespace === "html") validateTextNesting(text, frame.hostAncestors);
+		if (text !== "") {
+			if (frame.treeParent !== null) frame.treeParent.children.push({
+				children: [],
+				key: null,
+				kind: "text",
+				name: "#text",
+				props: { nodeValue: text }
+			});
+			if (frame.segment.lastPushedText) frame.segment.write(TEXT_SEPARATOR);
+			if (consumePendingLeadingNewline(frame)) writeLeadingNewlineText(text, frame.segment);
+			else writeText(text, frame.segment);
+			frame.segment.lastPushedText = true;
+		}
+		return;
+	}
+	if (isPortal(node)) return;
+	if (isValidElement(node)) {
+		renderElement(node, frame);
+		return;
+	}
+	if (isThenable(node)) {
+		renderChildren(readThenable(node), frame);
+		return;
+	}
+	throw invalidChildError(node);
+}
+function renderChildren(node, frame) {
+	renderChildSequence(collectChildren(node), frame);
+}
+function renderChildSequence(children, frame, indexBase = 0) {
+	for (let index = 0; index < children.length; index += 1) {
+		const child = children[index];
+		try {
+			withIdSegment(frame, indexBase + index, () => renderNode(child, frame));
+		} catch (error) {
+			if (isThenable(error)) {
+				spawnSuspendedTask(frame, child, error, indexBase + index);
+				continue;
+			}
+			throw error;
+		}
+	}
+}
+function completeSegmentText(segment) {
+	if (segment.textEmbedded && segment.lastPushedText) segment.write(TEXT_SEPARATOR);
+}
+function withIdSegment(frame, index, callback) {
+	const previousIdPath = frame.idPath;
+	const segment = index.toString(32);
+	frame.idPath = previousIdPath === "" ? segment : `${previousIdPath}-${segment}`;
+	try {
+		return callback();
+	} finally {
+		frame.idPath = previousIdPath;
+	}
+}
+function renderElement(element, frame) {
+	if (frame.treeParent === null) {
+		renderElementKind(element, frame);
+		return;
+	}
+	const treeNode = collectedTreeNode(element);
+	frame.treeParent.children.push(treeNode);
+	const previousTreeParent = frame.treeParent;
+	frame.treeParent = treeNode;
+	try {
+		renderElementKind(element, frame);
+	} finally {
+		frame.treeParent = previousTreeParent;
+	}
+}
+function collectedTreeNode(element) {
+	const { children: _children, ...ownProps } = element.props;
+	const [name, kind] = collectedNameAndKind(element.type);
+	return {
+		children: [],
+		key: element.key ?? null,
+		kind,
+		name,
+		props: ownProps
+	};
+}
+function collectedNameAndKind(type) {
+	if (typeof type === "string") return [type, "host"];
+	if (type === Fragment) return ["Fragment", "fragment"];
+	if (isContext(type)) return ["Context.Provider", "context-provider"];
+	if (isAssets(type)) return ["Assets", "assets"];
+	if (isSuspense(type)) return ["Suspense", "suspense"];
+	if (isErrorBoundary(type)) return ["ErrorBoundary", "error-boundary"];
+	if (isActivity(type)) return ["Activity", "activity"];
+	if (isViewTransition(type)) return ["ViewTransition", "view-transition"];
+	if (isClientReference(type)) return [type.id.slice(type.id.lastIndexOf("#") + 1) || "ClientReference", "client-reference"];
+	if (typeof type === "function") return [type.name === "" ? "Anonymous" : type.name, "function"];
+	return ["Anonymous", "function"];
+}
+function renderElementKind(element, frame) {
+	const type = element.type;
+	if (typeof type === "string") {
+		renderHostElement(type, element.props, frame);
+		return;
+	}
+	if (type === Fragment) {
+		renderChildren(element.props.children, frame);
+		return;
+	}
+	if (isContext(type)) {
+		renderContextProvider(type, element.props, frame);
+		return;
+	}
+	if (isAssets(type)) {
+		renderAssets(element.props, frame);
+		return;
+	}
+	if (isSuspense(type)) {
+		renderSuspense(element.props, frame);
+		return;
+	}
+	if (isErrorBoundary(type)) {
+		renderChildren(element.props.children, frame);
+		return;
+	}
+	if (isClientReference(type)) {
+		renderClientReference(type, element.props, frame);
+		return;
+	}
+	if (isActivity(type)) {
+		renderActivity(element.props, frame);
+		return;
+	}
+	if (isViewTransition(type)) {
+		renderViewTransition(element.props, frame);
+		return;
+	}
+	if (typeof type === "function") {
+		renderFunctionComponent(type, element.props, frame);
+		return;
+	}
+	throw new Error(`Unsupported Fig element type: ${describeElementType(type)}.`);
+}
+function renderFunctionComponent(type, props, frame) {
+	frame.dispatcher ??= createServerDispatcher(frame);
+	const previousDispatcher = setCurrentDispatcher(frame.dispatcher);
+	const previousDataStore = setCurrentDataStore(frame.request.dataStore);
+	const previousStack = frame.stack;
+	const previousLocalIdCounter = frame.localIdCounter;
+	frame.stack = {
+		name: type.name || "Anonymous",
+		parent: previousStack
+	};
+	frame.localIdCounter = 0;
+	try {
+		renderComponentAssets(type, frame);
+		renderChildren(type(props), frame);
+	} catch (error) {
+		recordErrorStack(error, frame.stack);
+		throw error;
+	} finally {
+		frame.stack = previousStack;
+		frame.localIdCounter = previousLocalIdCounter;
+		setCurrentDataStore(previousDataStore);
+		setCurrentDispatcher(previousDispatcher);
+	}
+}
+function renderClientReference(type, props, frame) {
+	if (type.ssr !== void 0) {
+		renderComponentAssets(type, frame);
+		renderElement(createElement(type.ssr, props), frame);
+		return;
+	}
+	const fallback = frame.request.clientReferenceFallback;
+	if (fallback === void 0) {
+		renderFunctionComponent(type, props, frame);
+		return;
+	}
+	renderComponentAssets(type, frame);
+	renderChildren(fallback(type, props), frame);
+}
+function renderComponentAssets(type, frame) {
+	const key = isClientReference(type) ? type.id : frame.request.resolveAssetKey?.(type);
+	if (key !== void 0) renderAssetValue(frame.request.componentAssets?.[key], frame);
+}
+function renderContextProvider(context, props, frame) {
+	withContextValue(frame.contextValues, context, props.value, () => renderChildren(props.children, frame));
+}
+function renderAssets(props, frame) {
+	renderAssetValue(props.assets, frame);
+	renderChildren(props.children, frame);
+}
+function renderAssetValue(value, frame) {
+	if (value === void 0 || value === null || value === false) return;
+	for (const resource of Array.isArray(value) ? value : [value]) {
+		if (!isFigAssetResource(resource)) throw new Error("The assets prop must contain Fig asset resources.");
+		try {
+			frame.request.assetRegistry.register(resource);
+		} catch (error) {
+			recordErrorStack(error, frame.stack);
+			throw error;
+		}
+		frame.segment.assetResources.push(resource);
+	}
+}
+function renderAutomaticImagePreload(resource, frame) {
+	try {
+		frame.request.assetRegistry.registerAutomaticImage(resource);
+	} catch (error) {
+		recordErrorStack(error, frame.stack);
+		throw error;
+	}
+	frame.segment.assetResources.push(resource);
+}
+function renderSuspense(props, frame) {
+	consumePendingLeadingNewline(frame);
+	const fallbackAbortableTasks = /* @__PURE__ */ new Set();
+	const contentSegment = createSegment(0, null);
+	const boundary = createBoundary(fallbackAbortableTasks, contentSegment);
+	boundary.activityId = frame.hiddenActivityId;
+	const parentSegment = frame.segment;
+	const boundarySegment = createSegment(parentSegment.chunks.length, boundary);
+	boundary.fallbackSegment = boundarySegment;
+	parentSegment.children.push(boundarySegment);
+	parentSegment.lastPushedText = false;
+	contentSegment.parentFlushed = true;
+	const contentFrame = createRenderFrame(frame.request, contentSegment, {
+		...forkScope(frame),
+		boundary
+	});
+	try {
+		renderChildren(props.children, contentFrame);
+		contentSegment.status = "completed";
+		boundary.completedSegments.push(contentSegment);
+		if (boundary.pendingTasks === 0) boundary.status = "completed";
+	} catch (error) {
+		contentSegment.status = "completed";
+		markBoundaryClientRendered(frame.request, boundary, error, frame.stack);
+	}
+	const advanceSurfaceWatermark = (branch) => {
+		if (frame.viewTransition !== null && branch.viewTransition !== null) frame.viewTransition.index = Math.max(frame.viewTransition.index, branch.viewTransition.index);
+	};
+	advanceSurfaceWatermark(contentFrame);
+	if (boundary.status === "completed") return;
+	const fallbackFrame = createRenderFrame(frame.request, boundarySegment, {
+		...forkScope(frame),
+		abortSet: fallbackAbortableTasks
+	});
+	try {
+		renderChildren(props.fallback, fallbackFrame);
+		boundarySegment.status = "completed";
+	} catch (error) {
+		if (boundary.pendingTasks > 0) for (const task of Array.from(boundary.fallbackAbortableTasks)) abortTask(frame.request, task);
+		throw error;
+	} finally {
+		advanceSurfaceWatermark(fallbackFrame);
+	}
+}
+function renderViewTransition(props, frame) {
+	const previousViewTransition = frame.viewTransition;
+	frame.viewTransition = createServerViewTransition(props, frame.request);
+	try {
+		renderChildren(props.children, frame);
+	} finally {
+		frame.viewTransition = previousViewTransition;
+	}
+}
+function createServerViewTransition(props, request) {
+	return {
+		className: serverViewTransitionClass(props),
+		index: 0,
+		name: props.name === void 0 || props.name === "auto" ? `fig-vt-${request.nextViewTransitionId++}` : props.name
+	};
+}
+function serverViewTransitionClass(props) {
+	const className = props.default;
+	if (className === void 0 || className === "auto" || className === "none") return null;
+	return className;
+}
+function renderActivity(props, frame) {
+	if (props.mode !== "hidden") {
+		renderChildren(props.children, frame);
+		return;
+	}
+	const id = activityId(frame.request, frame.request.nextActivityId++);
+	frame.segment.write(`<template ${ACTIVITY_TEMPLATE_ATTRIBUTE}="" id="${escapeAttribute(id)}">`);
+	const previousHiddenActivityId = frame.hiddenActivityId;
+	frame.hiddenActivityId = id;
+	try {
+		renderChildren(props.children, frame);
+	} finally {
+		frame.hiddenActivityId = previousHiddenActivityId;
+	}
+	frame.segment.write("</template>");
+}
+function renderHostElement(type, props, frame) {
+	const namespace = hostElementNamespace(type, frame.hostNamespace);
+	if (namespace === "html" && renderHostAsset(type, props, frame)) return;
+	if (namespace === "html") validateInstanceNesting(type, frame.hostAncestors);
+	const document = frame.request.document;
+	if (document !== null && !document.hasHead) {
+		if (type !== "html" && type !== "head") throw invalidDocumentShellError();
+	}
+	if (document !== null && type === "html") frame.segment.write("<!doctype html>");
+	if (document !== null && type === "head") document.hasHead = true;
+	const isVoid = namespace === "html" && isVoidElement(type);
+	const unsafeHTML = unsafeHTMLContent(props);
+	if (isVoid && hasRenderableChild(props.children)) throw new Error(`Void element <${type}> cannot have children.`);
+	if (isVoid && unsafeHTML !== null) throw new Error(`Void element <${type}> cannot have unsafeHTML.`);
+	if (unsafeHTML !== null && hasRenderableChild(props.children)) throw new Error("Host elements cannot have both unsafeHTML and children.");
+	if (namespace === "html") {
+		const imagePreload = imagePreloadFromHostProps(type, props, frame.imagePreloadsSuppressed);
+		if (imagePreload !== null) renderAutomaticImagePreload(imagePreload, frame);
+	}
+	consumePendingLeadingNewline(frame);
+	const viewTransition = frame.viewTransition;
+	writeElementStart(type, viewTransition === null ? props : viewTransitionHostProps(props, viewTransition), frame.segment, frame.selectProps ?? {});
+	if (document !== null && type === "head") frame.segment.write(earlyEventCaptureMarkup(frame.request));
+	if (isVoid) return;
+	const previousPendingLeadingNewline = frame.pendingLeadingNewline;
+	const tracksLeadingNewline = leadingNewlineStrippedHost(type);
+	frame.pendingLeadingNewline = tracksLeadingNewline;
+	if (unsafeHTML !== null) {
+		frame.segment.write(consumePendingLeadingNewline(frame) ? preserveParserStrippedLeadingNewline(unsafeHTML) : unsafeHTML);
+		frame.pendingLeadingNewline = previousPendingLeadingNewline;
+		writeElementEnd(type, frame.segment);
+		return;
+	}
+	const formText = namespace === "html" ? formTextContent(type, props) : null;
+	if (formText !== null) {
+		writeText(consumePendingLeadingNewline(frame) ? preserveParserStrippedLeadingNewline(formText) : formText, frame.segment);
+		frame.pendingLeadingNewline = previousPendingLeadingNewline;
+		writeElementEnd(type, frame.segment);
+		return;
+	}
+	const previousSelectProps = frame.selectProps;
+	if (namespace === "html" && type === "select") frame.selectProps = props;
+	const previousHostAncestors = frame.hostAncestors;
+	const previousHostNamespace = frame.hostNamespace;
+	const previousImagePreloadsSuppressed = frame.imagePreloadsSuppressed;
+	const previousViewTransition = frame.viewTransition;
+	if (viewTransition !== null) frame.viewTransition = null;
+	frame.hostAncestors = [type, ...previousHostAncestors];
+	frame.hostNamespace = childHostNamespace(type, namespace);
+	frame.imagePreloadsSuppressed = previousImagePreloadsSuppressed || namespace === "html" && suppressesImagePreloads(type);
+	if (tracksLeadingNewline) frame.segment.chunks.push(leadingNewlineStartMarker);
+	try {
+		renderChildren(props.children, frame);
+	} finally {
+		frame.selectProps = previousSelectProps;
+		frame.hostAncestors = previousHostAncestors;
+		frame.hostNamespace = previousHostNamespace;
+		frame.imagePreloadsSuppressed = previousImagePreloadsSuppressed;
+		frame.viewTransition = previousViewTransition;
+		frame.pendingLeadingNewline = previousPendingLeadingNewline;
+	}
+	if (tracksLeadingNewline) frame.segment.chunks.push(leadingNewlineEndMarker);
+	if (document !== null && type === "head") writeDocumentHeadMarker(frame.segment);
+	writeElementEnd(type, frame.segment);
+}
+function hostElementNamespace(type, parent) {
+	const normalizedType = type.toLowerCase();
+	if (normalizedType === "svg") return "svg";
+	if (normalizedType === "math") return "mathml";
+	return parent;
+}
+function childHostNamespace(type, namespace) {
+	return namespace === "svg" && type.toLowerCase() === "foreignobject" ? "html" : namespace;
+}
+function renderHostAsset(type, props, frame) {
+	const resource = assetResourceFromHostProps(type, props);
+	if (resource === null) return false;
+	renderAssetValue(resource, frame);
+	return true;
+}
+function viewTransitionHostProps(props, viewTransition) {
+	const index = viewTransition.index++;
+	const name = index === 0 ? viewTransition.name : `${viewTransition.name}_${index}`;
+	const nextProps = {
+		...props,
+		[VIEW_TRANSITION_NAME_ATTRIBUTE]: name
+	};
+	if (viewTransition.className !== null) nextProps[VIEW_TRANSITION_CLASS_ATTRIBUTE] = viewTransition.className;
+	return nextProps;
+}
+function spawnSuspendedTask(frame, node, thenable, childIndexBase) {
+	const request = frame.request;
+	const segment = createSegment(frame.segment.chunks.length, null, {
+		lastPushedText: frame.segment.lastPushedText,
+		textEmbedded: true
+	});
+	frame.segment.lastPushedText = false;
+	frame.segment.children.push(segment);
+	const task = createTask(request, node, segment, forkScope(frame), childIndexBase);
+	thenable.then(() => pingTask(request, task), () => pingTask(request, task));
+}
+function pingTask(request, task) {
+	if (request.status === "closed" || request.status === "aborting") return;
+	request.pingedTasks.push(task);
+	if (request.workScheduled) return;
+	request.workScheduled = true;
+	queueMicrotask(() => {
+		request.workScheduled = false;
+		performWork(request);
+	});
+}
+function finishedTask(request, task) {
+	request.pendingTasks -= 1;
+	const boundary = task.boundary;
+	if (boundary === null) {
+		request.pendingRootTasks -= 1;
+		if (task.segment === request.rootSegment || request.completedRootSegment === null) request.completedRootSegment = request.rootSegment;
+		if (request.pendingRootTasks === 0) finishRootShell(request);
+	} else {
+		boundary.pendingTasks -= 1;
+		if (task.segment.parentFlushed) enqueueUnique(boundary.completedSegments, task.segment);
+		if (!completeBoundaryIfReady(request, boundary) && boundary.parentFlushed) request.partialBoundaries.add(boundary);
+	}
+	if (request.pendingTasks === 0) request.allReady.resolve(void 0);
+}
+function erroredTask(request, task, error) {
+	request.pendingTasks -= 1;
+	const boundary = task.boundary;
+	if (boundary === null) {
+		request.pendingRootTasks -= 1;
+		fatalError(request, error);
+		return;
+	}
+	boundary.pendingTasks -= 1;
+	markBoundaryClientRendered(request, boundary, error, task.stack);
+	if (request.pendingTasks === 0) request.allReady.resolve(void 0);
+}
+function detachTask(request, task) {
+	task.abortSet.delete(task);
+	request.abortableTasks.delete(task);
+}
+function abortTask(request, task) {
+	if (!request.abortableTasks.delete(task)) return;
+	task.segment.status = "completed";
+	task.abortSet.delete(task);
+	request.pendingTasks -= 1;
+	const boundary = task.boundary;
+	if (boundary === null) {
+		request.pendingRootTasks -= 1;
+		if (request.pendingRootTasks === 0) finishRootShell(request);
+	} else {
+		boundary.pendingTasks -= 1;
+		completeBoundaryIfReady(request, boundary);
+	}
+	if (request.pendingTasks === 0) request.allReady.resolve(void 0);
+}
+function completeBoundaryIfReady(request, boundary) {
+	if (boundary.pendingTasks !== 0 || boundary.status !== "pending") return false;
+	boundary.status = "completed";
+	abortFallbackTasks(request, boundary);
+	if (boundary.parentFlushed) request.completedBoundaries.add(boundary);
+	return true;
+}
+function abortFallbackTasks(request, boundary) {
+	for (const fallbackTask of Array.from(boundary.fallbackAbortableTasks)) abortTask(request, fallbackTask);
+}
+function markBoundaryClientRendered(request, boundary, error, stack, payload) {
+	if (boundary.status !== "client-rendered") {
+		boundary.status = "client-rendered";
+		boundary.error = payload ?? reportBoundaryError(request, error, stack);
+	}
+	boundary.completedSegments = [];
+	request.completedBoundaries.delete(boundary);
+	request.partialBoundaries.delete(boundary);
+	for (const task of Array.from(request.abortableTasks)) if (task.boundary === boundary) abortTask(request, task);
+	for (const task of Array.from(boundary.fallbackAbortableTasks)) abortTask(request, task);
+	if (boundary.parentFlushed) request.clientRenderedBoundaries.add(boundary);
+}
+function abort(request, reason) {
+	if (request.status === "closed") return;
+	request.cleanupAbortListener();
+	request.status = "aborting";
+	request.dataStore.dispose();
+	const error = abortError(reason);
+	request.fatalError = error;
+	if (request.pendingRootTasks > 0) {
+		fatalError(request, error);
+		return;
+	}
+	for (const task of Array.from(request.abortableTasks)) {
+		const boundary = task.boundary;
+		if (boundary !== null) markBoundaryClientRendered(request, boundary, error, task.stack, {});
+	}
+	request.abortableTasks.clear();
+	request.pendingTasks = 0;
+	request.allReady.resolve(void 0);
+	flushCompletedQueues(request);
+}
+function fatalError(request, error) {
+	if (request.status === "closed") return;
+	request.cleanupAbortListener();
+	request.status = "closed";
+	request.dataStore.dispose();
+	request.fatalError = error;
+	request.headReady.reject(error);
+	request.shellReady.reject(error);
+	request.allReady.reject(error);
+	request.controller?.error(error);
+}
+function finishRootShell(request) {
+	if (request.document !== null && !request.document.hasHead) {
+		fatalError(request, invalidDocumentShellError());
+		return;
+	}
+	if (!request.prerender) sealHead(request);
+	request.shellReady.resolve(void 0);
+}
+function enqueueUnique(queue, item) {
+	if (!queue.includes(item)) queue.push(item);
+}
+function reportBoundaryError(request, error, stack) {
+	const info = { componentStack: componentStack(stackForError(error, stack)) };
+	if (request.onError === void 0) return { message: errorMessage(error) };
+	try {
+		return request.onError(error, info) ?? {};
+	} catch {
+		return {};
+	}
+}
+function recordErrorStack(error, stack) {
+	if (stack === null) return;
+	if (typeof error !== "object" && typeof error !== "function") return;
+	if (error === null || isThenable(error)) return;
+	if (!errorStacks.has(error)) errorStacks.set(error, stack);
+}
+function stackForError(error, fallback) {
+	if (typeof error !== "object" && typeof error !== "function" || error === null) return fallback;
+	return errorStacks.get(error) ?? fallback;
+}
+function createRuntimeName(identifierPrefix) {
+	const id = nextRuntimeId.toString(36);
+	nextRuntimeId += 1;
+	const prefix = identifierPrefix?.replace(/[^A-Za-z0-9_$]/g, "_") ?? "";
+	return prefix === "" ? `__figSSR_${id}` : `__figSSR_${prefix}_${id}`;
+}
+function writeDocumentHeadMarker(segment) {
+	segment.lastPushedText = false;
+	segment.chunks.push(documentHeadMarker);
+}
+function consumePendingLeadingNewline(frame) {
+	const pending = frame.pendingLeadingNewline;
+	frame.pendingLeadingNewline = false;
+	return pending;
+}
+function leadingNewlineStrippedHost(type) {
+	return type === "pre" || type === "textarea";
+}
+function writeLeadingNewlineText(text, segment) {
+	writeText(text, { write(value) {
+		segment.write({ value });
+	} });
+}
+function preserveParserStrippedLeadingNewline(text) {
+	return text.startsWith("\n") ? `\n${text}` : text;
+}
+function invalidDocumentShellError() {
+	return /* @__PURE__ */ new Error("renderToDocumentStream requires the root to render an <html> document with a <head>.");
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted === true) throw abortReason(signal.reason);
+}
+function throwIfAborting(request) {
+	if (request.status === "aborting") throw abortReason(request.fatalError);
+}
+function abortError(reason) {
+	if (reason instanceof Error) return reason;
+	return new Error(typeof reason === "string" ? reason : "Server render was aborted.");
+}
+function abortReason(reason) {
+	return reason ?? /* @__PURE__ */ new Error("Server render was aborted.");
+}
+function describeElementType(type) {
+	if (typeof type === "symbol") return String(type);
+	if (typeof type === "function") return type.name || "anonymous function";
+	return typeof type;
+}
+//#endregion
+//#region src/render-tree.ts
+function createRenderTreeCollector() {
+	return { tree: {
+		children: [],
+		key: null,
+		kind: "root",
+		name: "Root",
+		props: {}
+	} };
+}
+//#endregion
+//#region src/index.ts
+function renderToStream(node, options = {}) {
+	return createServerRenderRequest(node, options);
+}
+function renderToDocumentStream(node, options = {}) {
+	const request = createServerRenderRequest(node, options, { document: true });
+	return {
+		abort: (reason) => request.abort(reason),
+		allReady: request.allReady,
+		contentType: request.contentType,
+		data: request.data,
+		getData: () => request.getData(),
+		getPreloadHeader: (headerOptions) => request.getPreloadHeader(headerOptions),
+		shellReady: request.shellReady,
+		stream: request.stream
+	};
+}
+/**
+* The streamed output, buffered: awaits `allReady` and concatenates exactly
+* the bytes a streaming client would have received — including the inline
+* streaming runtime and boundary-reveal scripts when the tree suspends past
+* the shell. Right for caching responses and snapshotting wire output; it is
+* NOT React's `renderToString` (use `prerender` for settled, script-free
+* static markup).
+*/
+async function renderToHtml(node, options = {}) {
+	const result = renderToStream(node, options);
+	await result.allReady;
+	return readStreamToString(result.stream);
+}
+/** Document-mode {@link renderToHtml}: the streamed document, buffered. */
+async function renderToDocumentHtml(node, options = {}) {
+	const result = renderToDocumentStream(node, options);
+	await result.allReady;
+	return readStreamToString(result.stream);
+}
+/**
+* Settled static HTML: waits for all async work before flushing, so completed
+* Suspense content is emitted in logical position without streaming scripts.
+*/
+async function prerender(node, options = {}) {
+	const { document = false, ...renderOptions } = options;
+	const result = createServerRenderRequest(node, renderOptions, {
+		document,
+		prerender: true
+	});
+	await result.allReady;
+	const html = await readStreamToString(result.stream);
+	return {
+		data: result.getData(),
+		head: document ? "" : result.getHead(),
+		html
+	};
+}
+async function readStreamToString(stream) {
+	const reader = stream.getReader();
+	const textDecoder = new TextDecoder();
+	let output = "";
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) return output + textDecoder.decode();
+		output += textDecoder.decode(value, { stream: true });
+	}
+}
+//#endregion
+export { createRenderTreeCollector, prerender, renderToDocumentHtml, renderToDocumentStream, renderToHtml, renderToStream };
+
+//# sourceMappingURL=index.js.map