marko 6.3.19 → 6.3.21

package/dist/debug/html.mjs

@@ -19,6 +19,24 @@ function* attrTagIterator() {
 	yield* this[rest];
 }
 //#endregion
+//#region src/common/constants/accessor-prefix.debug.ts
+const BranchScopes = "BranchScopes:";
+const ConditionalRenderer = "ConditionalRenderer:";
+const ControlledHandler = "ControlledHandler:";
+const ControlledType = "ControlledType:";
+const ControlledValue = "ControlledValue:";
+const EventAttributes = "EventAttributes:";
+//#endregion
+//#region src/common/constants/accessor-prop.debug.ts
+const BranchAccessor = "#BranchAccessor";
+const CatchContent = "#CatchContent";
+const ClosestBranchId = "#ClosestBranchId";
+const LoopKey = "#LoopKey";
+const PlaceholderContent = "#PlaceholderContent";
+const Renderer = "#Renderer";
+const TagVariable = "#TagVariable";
+const Embed = "embed";
+//#endregion
 //#region src/common/helpers.ts
 const htmlAttrNameReg = /^[^a-z_]|[^a-z0-9._:-]/i;
 const knownWrongAttrs = {
@@ -521,14 +539,15 @@ var State$1 = class {
 	mutated = [];
 };
 var Reference = class {
+	assigns = null;
+	calls = null;
+	scopeId = void 0;
+	channel = void 0;
 	parent;
 	accessor;
 	flush;
 	pos;
 	id;
-	assigns = null;
-	scopeId = void 0;
-	channel = void 0;
 	constructor(parent, accessor, flush, pos = null, id = null) {
 		this.parent = parent;
 		this.accessor = accessor;
@@ -633,14 +652,31 @@ function writeScopesRoot(state, flushes) {
 function writeAssigned(state) {
 	let sep = state.buf.length ? "," : "";
 	if (state.assigned.size) {
+		const assigned = state.assigned;
+		state.assigned = /* @__PURE__ */ new Set();
 		let buf = "";
-		for (const ref of state.assigned) {
-			buf += sep + assignsToString(ref.assigns, ref.id);
-			ref.assigns = null;
-			sep = ",";
+		let hasCalls = false;
+		for (const ref of assigned) {
+			if (ref.assigns) {
+				buf += sep + assignsToString(ref.assigns, ref.id);
+				ref.assigns = null;
+				sep = ",";
+			}
+			hasCalls ||= ref.calls !== null;
+		}
+		if (buf) state.buf.push(buf);
+		if (hasCalls) for (const ref of assigned) {
+			if (!ref.calls) continue;
+			for (const { method, args } of ref.calls) {
+				state.buf.push((state.buf.length ? "," : "") + ref.id + "." + method + "(");
+				for (let a = 0; a < args.length; a++) {
+					if (a) state.buf.push(",");
+					writeCallArg(state, args[a]);
+				}
+				state.buf.push(")");
+			}
+			ref.calls = null;
 		}
-		state.buf.push(buf);
-		state.assigned = /* @__PURE__ */ new Set();
 	}
 	if (hasChannelMutations(state)) {
 		const remaining = [];
@@ -675,8 +711,14 @@ function writeAssigned(state) {
 			state.buf.push(")");
 		}
 		state.mutated = remaining;
-		if (state.assigned.size) writeAssigned(state);
 	}
+	if (state.assigned.size) writeAssigned(state);
+}
+function writeCallArg(state, val) {
+	if (val === void 0) {
+		state.wroteUndefined = true;
+		state.buf.push("$");
+	} else if (!writeProp(state, val, null, "")) state.buf.push("void 0");
 }
 function hasChannelMutations(state) {
 	return hasMatchingMutations(state.mutated, state.channel?.readyId);
@@ -871,6 +913,7 @@ function writeUnknownObject(state, val, ref) {
 		case Float64Array:
 		case BigInt64Array:
 		case BigUint64Array: return writeTypedArray(state, val, ref);
+		case DataView: return writeDataView(state, val, ref);
 		case WeakSet: return writeWeakSet(state);
 		case WeakMap: return writeWeakMap(state);
 		case globalThis.URL: return writeURL(state, val);
@@ -880,6 +923,24 @@ function writeUnknownObject(state, val, ref) {
 		case globalThis.ReadableStream: return writeReadableStream(state, val, ref);
 		case globalThis.Request: return writeRequest(state, val, ref);
 		case globalThis.Response: return writeResponse(state, val, ref);
+		case globalThis.Intl?.NumberFormat: return writeIntl(state, val, "NumberFormat", ref);
+		case globalThis.Intl?.DateTimeFormat: return writeIntl(state, val, "DateTimeFormat", ref);
+		case globalThis.Intl?.Collator: return writeIntl(state, val, "Collator", ref);
+		case globalThis.Intl?.PluralRules: return writeIntl(state, val, "PluralRules", ref);
+		case globalThis.Intl?.RelativeTimeFormat: return writeIntl(state, val, "RelativeTimeFormat", ref);
+		case globalThis.Intl?.ListFormat: return writeIntl(state, val, "ListFormat", ref);
+		case globalThis.Intl?.DisplayNames: return writeIntl(state, val, "DisplayNames", ref);
+		case globalThis.Intl?.Segmenter: return writeIntl(state, val, "Segmenter", ref);
+		case globalThis.Intl?.DurationFormat: return writeIntl(state, val, "DurationFormat", ref);
+		case globalThis.Intl?.Locale: return writeIntlLocale(state, val);
+		case globalThis.Temporal?.Instant: return writeTemporal(state, val, "Instant");
+		case globalThis.Temporal?.Duration: return writeTemporal(state, val, "Duration");
+		case globalThis.Temporal?.PlainDate: return writeTemporal(state, val, "PlainDate");
+		case globalThis.Temporal?.PlainDateTime: return writeTemporal(state, val, "PlainDateTime");
+		case globalThis.Temporal?.PlainMonthDay: return writeTemporal(state, val, "PlainMonthDay");
+		case globalThis.Temporal?.PlainTime: return writeTemporal(state, val, "PlainTime");
+		case globalThis.Temporal?.PlainYearMonth: return writeTemporal(state, val, "PlainYearMonth");
+		case globalThis.Temporal?.ZonedDateTime: return writeTemporal(state, val, "ZonedDateTime");
 	}
 	throwUnserializable(state, val, ref);
 	return false;
@@ -948,9 +1009,15 @@ function writeMap(state, val, ref) {
 	const items = [];
 	let assigns;
 	let needsId;
+	let deferring = false;
 	let i = 0;
 	if (val.size < 25) {
 		for (let [itemKey, itemValue] of val) {
+			if (!deferring && (itemKey !== val && isAncestorMember(state, ref, itemKey) || itemValue !== val && isAncestorMember(state, ref, itemValue))) deferring = true;
+			if (deferring) {
+				deferCall(state, ref, "set", [itemKey, itemValue]);
+				continue;
+			}
 			if (itemKey === val) {
 				itemKey = void 0;
 				(assigns ||= []).push("a[" + i + "][0]");
@@ -965,6 +1032,11 @@ function writeMap(state, val, ref) {
 		writeArrayArg(state, ref, items, assigns && "((m,a)=>(" + assignsToString(assigns, "m") + ",a.forEach(i=>m.set(i[0],i[1])),m))(new Map,", "new Map(", needsId);
 	} else {
 		for (let [itemKey, itemValue] of val) {
+			if (!deferring && (itemKey !== val && isAncestorMember(state, ref, itemKey) || itemValue !== val && isAncestorMember(state, ref, itemValue))) deferring = true;
+			if (deferring) {
+				deferCall(state, ref, "set", [itemKey, itemValue]);
+				continue;
+			}
 			if (itemKey === val) {
 				itemKey = 0;
 				(assigns ||= []).push("a[" + i + "]");
@@ -988,8 +1060,14 @@ function writeSet(state, val, ref) {
 	const items = [];
 	let assigns;
 	let needsId;
+	let deferring = false;
 	let i = 0;
 	for (let item of val) {
+		if (!deferring && item !== val && isAncestorMember(state, ref, item)) deferring = true;
+		if (deferring) {
+			deferCall(state, ref, "add", [item]);
+			continue;
+		}
 		if (item === val) {
 			item = 0;
 			(assigns ||= []).push("i[" + i + "]");
@@ -999,6 +1077,19 @@ function writeSet(state, val, ref) {
 	writeArrayArg(state, ref, items, assigns && "((s,i)=>(" + assignsToString(assigns, "s") + ",i.forEach(i=>s.add(i)),s))(new Set,", "new Set(", needsId);
 	return true;
 }
+function isAncestorMember(state, container, member) {
+	if (member === null || typeof member !== "object" && typeof member !== "function") return false;
+	const ref = state.refs.get(member);
+	return ref !== void 0 && isCircular(container, ref);
+}
+function deferCall(state, ref, method, args) {
+	ensureId(state, ref);
+	(ref.calls ||= []).push({
+		method,
+		args
+	});
+	state.assigned.add(ref);
+}
 function writeArrayArg(state, ref, items, assignsPrefix, plainPrefix, needsId) {
 	if (assignsPrefix || needsId) {
 		const arrayRef = new Reference(ref, null, state.flush, null, nextRefAccess(state));
@@ -1019,6 +1110,20 @@ function isDedupedMember(val) {
 		default: return false;
 	}
 }
+function canWriteBuffer(state, buffer, ref) {
+	if (Object.getPrototypeOf(buffer)?.constructor === ArrayBuffer) return true;
+	throwUnserializable(state, buffer, ref, "buffer");
+	return false;
+}
+function writeDataView(state, val, ref) {
+	const { buffer } = val;
+	if (!canWriteBuffer(state, buffer, ref)) return false;
+	const needsLength = val.byteOffset + val.byteLength < buffer.byteLength;
+	state.buf.push("new DataView(");
+	writeProp(state, buffer, ref, "buffer");
+	state.buf.push((val.byteOffset || needsLength ? "," + val.byteOffset + (needsLength ? "," + val.byteLength : "") : "") + ")");
+	return true;
+}
 function writeArrayBuffer(state, val) {
 	let result;
 	if (val.byteLength) {
@@ -1030,6 +1135,7 @@ function writeArrayBuffer(state, val) {
 }
 function writeTypedArray(state, val, ref) {
 	if (val.byteOffset || val.byteLength < val.buffer.byteLength || state.refs.has(val.buffer)) {
+		if (!canWriteBuffer(state, val.buffer, ref)) return false;
 		const needsLength = val.byteOffset + val.byteLength < val.buffer.byteLength;
 		state.buf.push("new " + val.constructor.name + "(");
 		writeProp(state, val.buffer, ref, "buffer");
@@ -1189,6 +1295,34 @@ function writeResponse(state, val, ref) {
 	}
 	return true;
 }
+function writeIntl(state, val, name, ref) {
+	const { locale, ...options } = val.resolvedOptions();
+	let needsId = false;
+	for (const key in options) if (isDedupedMember(options[key])) {
+		needsId = true;
+		break;
+	}
+	state.buf.push("new Intl." + name + "(" + quote(locale, 0) + ",");
+	let optionsRef;
+	if (needsId) {
+		optionsRef = new Reference(ref, null, state.flush, null, nextRefAccess(state));
+		state.buf.push(optionsRef.id + "={");
+	} else {
+		optionsRef = new Reference(ref, null, state.flush, state.buf.length);
+		state.buf.push("{");
+	}
+	writeObjectProps(state, options, optionsRef);
+	state.buf.push("})");
+	return true;
+}
+function writeIntlLocale(state, val) {
+	state.buf.push("new Intl.Locale(" + quote(val.toString(), 0) + ")");
+	return true;
+}
+function writeTemporal(state, val, name) {
+	state.buf.push("Temporal." + name + ".from(" + quote(val.toString(), 0) + ")");
+	return true;
+}
 function writeReadableStream(state, val, ref) {
 	const { boundary, channel } = state;
 	if (!boundary || val.locked) return false;
@@ -1343,6 +1477,7 @@ function throwUnserializable(state, cause, ref = null, accessor = "") {
 		if (accessor) access = toAccess(accessor) + access;
 		if (access[0] === ".") access = access.slice(1);
 		if (access) message += ` (reading ${access})`;
+		message += ". Values referenced in the browser must be serializable.";
 		const err = new TypeError(message, { cause });
 		err.stack = void 0;
 		state.boundary.abort(err);
@@ -1795,7 +1930,7 @@ function _sep(shouldResume) {
 }
 function _resume_branch(scopeId) {
 	const branchId = $chunk.context?.[kBranchId];
-	if (branchId !== void 0 && branchId !== scopeId) writeScope(scopeId, { ["#ClosestBranchId"]: branchId });
+	if (branchId !== void 0 && branchId !== scopeId) writeScope(scopeId, { [ClosestBranchId]: branchId });
 }
 function _attr_content(nodeAccessor, scopeId, content, serializeReason) {
 	const shouldResume = serializeReason !== 0;
@@ -1805,8 +1940,8 @@ function _attr_content(nodeAccessor, scopeId, content, serializeReason) {
 	else render();
 	if (_peek_scope_id() !== branchId) {
 		if (shouldResume) writeScope(scopeId, {
-			["BranchScopes:" + nodeAccessor]: writeScope(branchId, {}),
-			["ConditionalRenderer:" + nodeAccessor]: render?.["id"]
+			[BranchScopes + nodeAccessor]: writeScope(branchId, {}),
+			[ConditionalRenderer + nodeAccessor]: render?.["id"]
 		});
 	} else _scope_id();
 }
@@ -1817,8 +1952,8 @@ function normalizeServerRender(value) {
 }
 function _var(parentScopeId, scopeOffsetAccessor, childScopeId, registryId, nodeAccessor) {
 	writeScopePassive(parentScopeId, { [scopeOffsetAccessor]: _scope_id() });
-	const childScope = writeScopePassive(childScopeId, { ["#TagVariable"]: _resume({}, registryId, parentScopeId) });
-	if (nodeAccessor !== void 0) writeScope(parentScopeId, { ["BranchScopes:" + nodeAccessor]: childScope });
+	const childScope = writeScopePassive(childScopeId, { [TagVariable]: _resume({}, registryId, parentScopeId) });
+	if (nodeAccessor !== void 0) writeScope(parentScopeId, { [BranchScopes + nodeAccessor]: childScope });
 }
 function writeScopePassive(scopeId, partialScope) {
 	const target = $chunk.serializeState;
@@ -1894,11 +2029,11 @@ function forBranches(by, iterate, scopeId, accessor, serializeBranch, serializeM
 		}
 		withBranchId(branchId, () => {
 			render();
-			const branchScope = writeScope(branchId, resumeKeys && !sameAsIndex ? { ["#LoopKey"]: itemKey } : {});
+			const branchScope = writeScope(branchId, resumeKeys && !sameAsIndex ? { [LoopKey]: itemKey } : {});
 			if (!resumeMarker) loopScopes = push(loopScopes, branchScope);
 		});
 	});
-	if (loopScopes) writeScope(scopeId, { ["BranchScopes:" + accessor]: loopScopes });
+	if (loopScopes) writeScope(scopeId, { [BranchScopes + accessor]: loopScopes });
 	writeBranchEnd(scopeId, accessor, serializeStateful, serializeMarker, parentEndTag, singleNode, singleNode ? flushBranchIds : flushBranchIds ? " " + flushBranchIds : "");
 }
 function _if(cb, scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode) {
@@ -1910,8 +2045,8 @@ function _if(cb, scopeId, accessor, serializeBranch, serializeMarker, serializeS
 	const branchIndex = resumeBranch ? withBranchId(branchId, cb) : cb();
 	const shouldWriteBranch = resumeBranch && branchIndex !== void 0;
 	if (shouldWriteBranch && (branchIndex || !resumeMarker)) writeScope(scopeId, {
-		["ConditionalRenderer:" + accessor]: branchIndex || void 0,
-		["BranchScopes:" + accessor]: resumeMarker ? void 0 : writeScope(branchId, {})
+		[ConditionalRenderer + accessor]: branchIndex || void 0,
+		[BranchScopes + accessor]: resumeMarker ? void 0 : writeScope(branchId, {})
 	});
 	writeBranchEnd(scopeId, accessor, serializeStateful, serializeMarker, parentEndTag, singleNode, shouldWriteBranch ? " " + branchId : "");
 }
@@ -2044,9 +2179,9 @@ function _try(scopeId, accessor, content, input) {
 	else if (placeholderContent) tryPlaceholder(content, placeholderContent, branchId);
 	else content();
 	writeScope(branchId, {
-		["#BranchAccessor"]: accessor,
-		["#CatchContent"]: catchContent,
-		["#PlaceholderContent"]: placeholderContent
+		[BranchAccessor]: accessor,
+		[CatchContent]: catchContent,
+		[PlaceholderContent]: placeholderContent
 	});
 	$chunk.writeHTML($chunk.boundary.state.mark("]", scopeId + " " + accessor + " " + branchId));
 }
@@ -2119,7 +2254,6 @@ function tryCatch(content, catchContent) {
 }
 const NOOP$2 = () => {};
 var State = class {
-	$global;
 	tagId = 1;
 	scopeId = 1;
 	reorderId = 1;
@@ -2141,6 +2275,7 @@ var State = class {
 	writeScopes = {};
 	readyIds = null;
 	serializeReason;
+	$global;
 	constructor($global) {
 		this.$global = $global;
 		if ($global.cspNonce) this.nonceAttr = " nonce" + attrAssignment($global.cspNonce);
@@ -2183,10 +2318,10 @@ var State = class {
 	}
 };
 var Boundary = class extends AbortController {
-	state;
-	parent;
 	onNext = NOOP$2;
 	count = 0;
+	state;
+	parent;
 	constructor(state, signal, parent) {
 		super();
 		this.state = state;
@@ -2216,10 +2351,6 @@ var Boundary = class extends AbortController {
 	}
 };
 var Chunk = class Chunk {
-	boundary;
-	next;
-	context;
-	serializeState;
 	html = "";
 	scripts = "";
 	effects = "";
@@ -2230,6 +2361,10 @@ var Chunk = class Chunk {
 	reorderId = null;
 	deferredReady = null;
 	placeholder = null;
+	boundary;
+	next;
+	context;
+	serializeState;
 	constructor(boundary, next, context, serializeState) {
 		this.boundary = boundary;
 		this.next = next;
@@ -2725,7 +2860,7 @@ function _attrs(data, nodeAccessor, scopeId, tagName) {
 					if (isEventHandler(name)) {
 						if (!events) {
 							events = {};
-							writeScope(scopeId, { ["EventAttributes:" + nodeAccessor]: events });
+							writeScope(scopeId, { [EventAttributes + nodeAccessor]: events });
 						}
 						events[getEventHandlerName(name)] = value;
 					} else result += nonVoidAttr(name, value);
@@ -2754,12 +2889,12 @@ function _attrs_partial_content(data, skip, nodeAccessor, scopeId, tagName, seri
 function writeControlledScope(type, scopeId, nodeAccessor, value, valueChange, serializeType) {
 	assertHandlerIsFunction("valueChange", valueChange);
 	writeScope(scopeId, serializeType ? {
-		["ControlledType:" + nodeAccessor]: type,
-		["ControlledValue:" + nodeAccessor]: value,
-		["ControlledHandler:" + nodeAccessor]: valueChange
+		[ControlledType + nodeAccessor]: type,
+		[ControlledValue + nodeAccessor]: value,
+		[ControlledHandler + nodeAccessor]: valueChange
 	} : {
-		["ControlledValue:" + nodeAccessor]: value,
-		["ControlledHandler:" + nodeAccessor]: valueChange
+		[ControlledValue + nodeAccessor]: value,
+		[ControlledHandler + nodeAccessor]: valueChange
 	});
 }
 function stringAttr(name, value) {
@@ -2834,7 +2969,7 @@ let _dynamic_tag = (scopeId, accessor, tag, inputOrArgs, content, inputIsArgs, s
 			const childScope = getScopeById(branchId);
 			const needsScript = childScope && (childScope[`EventAttributes:#${renderer}/0`] || childScope[`ControlledHandler:#${renderer}/0`]);
 			if (needsScript) {
-				writeScope(branchId, { ["#Renderer"]: renderer });
+				writeScope(branchId, { [Renderer]: renderer });
 				_script(branchId, DYNAMIC_TAG_SCRIPT_REGISTER_ID);
 			}
 			if (shouldResume || needsScript) _html(state.mark("'", scopeId + " " + accessor + " " + branchId));
@@ -2859,7 +2994,7 @@ let _dynamic_tag = (scopeId, accessor, tag, inputOrArgs, content, inputIsArgs, s
 		if (shouldResume) _html(state.mark("]", scopeId + " " + accessor + (rendered ? " " + branchId : "")));
 	}
 	if (rendered) {
-		if (shouldResume) writeScope(scopeId, { ["ConditionalRenderer:" + accessor]: renderer?.["id"] || renderer });
+		if (shouldResume) writeScope(scopeId, { [ConditionalRenderer + accessor]: renderer?.["id"] || renderer });
 	} else _scope_id();
 	return result;
 };
@@ -2882,7 +3017,7 @@ const patchDynamicTag = ((originalDynamicTag) => (patch) => {
 const CONSUMED_RESULT_MESSAGE = "Cannot read from a consumed render result";
 const _template = (templateId, renderer, page) => {
 	renderer.render = render;
-	renderer["embed"] = !page;
+	renderer[Embed] = !page;
 	renderer._ = renderer;
 	renderer.mount = () => {
 		throw new Error(`mount() is not implemented for the HTML compilation of a Marko template`);
@@ -2936,7 +3071,9 @@ var ServerRendered = class {
 		const boundary = this.#read((html) => {
 			value += html;
 			if (resolve) {
-				resolve({
+				const settle = resolve;
+				resolve = reject = void 0;
+				settle({
 					value,
 					done
 				});
@@ -2945,11 +3082,17 @@ var ServerRendered = class {
 		}, (err) => {
 			aborted = true;
 			reason = err;
-			if (reject) reject(err);
+			if (reject) {
+				const settle = reject;
+				resolve = reject = void 0;
+				settle(err);
+			}
 		}, () => {
 			done = true;
 			if (resolve) {
-				resolve({
+				const settle = resolve;
+				resolve = reject = void 0;
+				settle({
 					value,
 					done: !value
 				});
@@ -3169,6 +3312,10 @@ function addAsset(g, id, triggers) {
 		id,
 		triggers
 	});
+	else {
+		const existing = assets.find((a) => a.id === id);
+		if (JSON.stringify(existing.triggers) !== JSON.stringify(triggers)) console.error(`The lazy asset "${id}" is imported with different \`load\` triggers; an asset must use one consistent trigger.`);
+	}
 }
 function writeTriggerScript(html, triggers) {
 	const htmlStr = _escape_script(JSON.stringify(html));
@@ -3258,7 +3405,7 @@ const compat = {
 	render(renderer, willRerender, classAPIOut, component, input, completeChunks, registerChildScope) {
 		const state = this.ensureState(classAPIOut.global);
 		const boundary = new Boundary(state);
-		let head = new Chunk(boundary, null, null, state);
+		let head = new Chunk(boundary, null, getChunk()?.context ?? null, state);
 		let normalizedInput = input;
 		if ("renderBody" in input) {
 			normalizedInput = {};

package/dist/dom/compat.d.ts

@@ -19,7 +19,7 @@ export declare const compat: {
         runtimeId: string;
         renderId: string;
     }): any;
-    createRenderer(params: NonNullable<Renderer[RendererProp.Params]>, clone: () => {
+    createRenderer(params: NonNullable<Renderer[typeof RendererProp.Params]>, clone: () => {
         startNode: ChildNode;
         endNode: ChildNode;
     }): Renderer;

package/dist/dom/control-flow.d.ts

@@ -15,7 +15,7 @@ export declare function patchDynamicTag(fn: <T extends typeof _dynamic_tag>(cond
 export declare let _dynamic_tag: (nodeAccessor: EncodedAccessor, getContent?: ((scope: Scope) => Renderer) | 0, getTagVar?: (() => Signal<unknown>) | 0, inputIsArgs?: 1) => Signal<Renderer | string | undefined>;
 export declare function _dynamic_tag_content(nodeAccessor: EncodedAccessor): Signal<Renderer | undefined>;
 export declare function _resume_dynamic_tag(): void;
-export declare function setConditionalRenderer<T>(scope: Scope, nodeAccessor: Accessor, newRenderer: T, createBranch: ($global: Scope[AccessorProp.Global], renderer: NonNullable<T>, parentScope: Scope, parentNode: ParentNode) => BranchScope): void;
+export declare function setConditionalRenderer<T>(scope: Scope, nodeAccessor: Accessor, newRenderer: T, createBranch: ($global: Scope[typeof AccessorProp.Global], renderer: NonNullable<T>, parentScope: Scope, parentNode: ParentNode) => BranchScope): void;
 export declare const _for_of: (nodeAccessor: EncodedAccessor, template?: string | 0, walks?: string | 0, setup?: SetupFn | 0, params?: Signal<unknown>) => (scope: Scope, value: [all: unknown[], by?: ((item: unknown, index: number) => unknown) | undefined]) => void;
 export declare const _for_in: (nodeAccessor: EncodedAccessor, template?: string | 0, walks?: string | 0, setup?: SetupFn | 0, params?: Signal<unknown>) => (scope: Scope, value: [obj: {}, by?: ((key: string, v: unknown) => unknown) | undefined]) => void;
 export declare const _for_to: (nodeAccessor: EncodedAccessor, template?: string | 0, walks?: string | 0, setup?: SetupFn | 0, params?: Signal<unknown>) => (scope: Scope, value: [to: number, from: number, step: number, by?: ((v: number) => unknown) | undefined]) => void;

package/dist/dom/renderer.d.ts

@@ -11,9 +11,9 @@ export type Renderer = {
     [RendererProp.LocalClosureValues]?: Record<Accessor, unknown>;
 };
 export type SetupFn = (scope: Scope) => void;
-export declare function createBranch($global: Scope[AccessorProp.Global], renderer: Renderer | string, parentScope: Scope | undefined, parentNode: ParentNode): BranchScope;
+export declare function createBranch($global: Scope[typeof AccessorProp.Global], renderer: Renderer | string, parentScope: Scope | undefined, parentNode: ParentNode): BranchScope;
 export declare function setParentBranch(branch: BranchScope, parentBranch: BranchScope | undefined): void;
-export declare function createAndSetupBranch($global: Scope[AccessorProp.Global], renderer: Renderer, parentScope: Scope | undefined, parentNode: ParentNode): BranchScope;
+export declare function createAndSetupBranch($global: Scope[typeof AccessorProp.Global], renderer: Renderer, parentScope: Scope | undefined, parentNode: ParentNode): BranchScope;
 export declare function setupBranch(renderer: Renderer, branch: BranchScope): BranchScope;
 export declare function _content(id: string, template?: string | 0, walks?: string | 0, setup?: {
     _: Signal<unknown>;

package/dist/dom/scope.d.ts

@@ -1,5 +1,5 @@
 import { AccessorProp, type BranchScope, type Scope } from "../common/types";
-export declare function createScope($global: Scope[AccessorProp.Global], closestBranch?: BranchScope): Scope;
+export declare function createScope($global: Scope[typeof AccessorProp.Global], closestBranch?: BranchScope): Scope;
 export declare function syncGen(scope: Scope): void;
 export declare function _assert_init(scope: Scope, accessor: string): any;
 export declare function collectScopes(fn: () => void): Scope[];

package/dist/dom.js

@@ -1314,12 +1314,14 @@ function insertLoaded(renderer, branch, marker, awaitCounter) {
 	let parent = marker.parentNode, values = branch.X, insert = () => {
 		insertBranchBefore(branch, parent, marker), marker.remove(), awaitCounter?.c();
 	}, remaining;
-	if (syncGen(branch), renderer.b(branch, parent.namespaceURI), branch.X = 0, remaining = values?.size) for (let [promise, entry] of values) promise.then((signal) => {
-		entry.b = signal, --remaining || queueAsyncRender(branch, (branch) => {
-			syncGen(branch), renderer.c?.(branch), values.forEach((e) => e.b._(branch, e.a)), insert();
-		});
-	}, () => 0);
-	else setupBranch(renderer, branch), insert();
+	if (syncGen(branch), renderer.b(branch, parent.namespaceURI), branch.X = 0, remaining = values?.size) {
+		let fail = loadFailed(branch, awaitCounter);
+		for (let [promise, entry] of values) promise.then((signal) => {
+			entry.b = signal, --remaining || queueAsyncRender(branch, (branch) => {
+				syncGen(branch), renderer.c?.(branch), values.forEach((e) => e.b._(branch, e.a)), insert();
+			});
+		}, (error) => remaining > 0 && (remaining = 0, fail(error)));
+	} else setupBranch(renderer, branch), insert();
 }
 function loadFailed(scope, awaitCounter) {
 	return (error) => {

package/dist/dom.mjs

@@ -1313,12 +1313,14 @@ function insertLoaded(renderer, branch, marker, awaitCounter) {
 	let parent = marker.parentNode, values = branch.X, insert = () => {
 		insertBranchBefore(branch, parent, marker), marker.remove(), awaitCounter?.c();
 	}, remaining;
-	if (syncGen(branch), renderer.b(branch, parent.namespaceURI), branch.X = 0, remaining = values?.size) for (let [promise, entry] of values) promise.then((signal) => {
-		entry.b = signal, --remaining || queueAsyncRender(branch, (branch) => {
-			syncGen(branch), renderer.c?.(branch), values.forEach((e) => e.b._(branch, e.a)), insert();
-		});
-	}, () => 0);
-	else setupBranch(renderer, branch), insert();
+	if (syncGen(branch), renderer.b(branch, parent.namespaceURI), branch.X = 0, remaining = values?.size) {
+		let fail = loadFailed(branch, awaitCounter);
+		for (let [promise, entry] of values) promise.then((signal) => {
+			entry.b = signal, --remaining || queueAsyncRender(branch, (branch) => {
+				syncGen(branch), renderer.c?.(branch), values.forEach((e) => e.b._(branch, e.a)), insert();
+			});
+		}, (error) => remaining > 0 && (remaining = 0, fail(error)));
+	} else setupBranch(renderer, branch), insert();
 }
 function loadFailed(scope, awaitCounter) {
 	return (error) => {

package/dist/html/constants/char.d.ts

@@ -0,0 +1,11 @@
+export declare const Dollar = 36;
+export declare const Digit0 = 48;
+export declare const Digit9 = 57;
+export declare const UpperA = 65;
+export declare const UpperZ = 90;
+export declare const Underscore = 95;
+export declare const LowerA = 97;
+export declare const LowerZ = 122;
+type Self = typeof import("./char");
+export type Value = Self[keyof Self];
+export {};

package/dist/html/constants/flush-status.d.ts

@@ -0,0 +1,6 @@
+export declare const complete = 0;
+declare const continue_ = 1;
+export { continue_ as continue };
+export declare const aborted = 2;
+type Self = typeof import("./flush-status");
+export type Value = Self[keyof Self];

package/dist/html/constants/mark.d.ts

@@ -0,0 +1,6 @@
+export declare const Placeholder = "!^";
+export declare const PlaceholderEnd = "!";
+export declare const ReorderMarker = "#";
+type Self = typeof import("./mark");
+export type Value = Self[keyof Self];
+export {};

package/dist/html/constants/runtime-key.d.ts

@@ -0,0 +1,7 @@
+export declare const Walk = ".w";
+export declare const Resume = ".r";
+export declare const Ready = ".b";
+export declare const Scripts = ".j";
+type Self = typeof import("./runtime-key");
+export type Value = Self[keyof Self];
+export {};