@marko/runtime-tags 6.4.7 → 6.4.8

package/dist/translator/index.js

@@ -2015,7 +2015,7 @@ function finalizeRegistrations() {
 	const programExtra = (0, _marko_compiler_babel_utils.getProgram)().node.extra;
 	for (const fnExtra of getReferencesByFn().keys()) if (fnExtra.reason) {
 		registerFunction(fnExtra);
-		programExtra.isInteractive ||= isUnconditionalReason(fnExtra.reason);
+		programExtra.isInteractive ||= !isGuardedReason(fnExtra.reason);
 	}
 	for (const [{ node, local, registered, fnRoots }, exprExtras] of getReferencesByImport()) {
 		const reason = fnRoots ? resolveTemplateReason(exprExtras) : resolveReason(exprExtras);
@@ -2025,7 +2025,7 @@ function finalizeRegistrations() {
 				extra.registeredImports ??= /* @__PURE__ */ new Map();
 				extra.registeredImports.set(local, registered);
 			}
-			programExtra.isInteractive ||= isUnconditionalReason(reason);
+			programExtra.isInteractive ||= !isGuardedReason(reason);
 		}
 	}
 }
@@ -2276,7 +2276,8 @@ function getBranchExprReason(section) {
 	const { derives, branchExpr } = section;
 	if (derives) {
 		let reason = mergeSources(getRendererReason(section) || void 0, getSourcesForDerived(derives));
-		forEach(section.callSections, (callSection) => {
+		forEach(section.calls, (call) => {
+			const callSection = call.childScopeBinding.section;
 			reason = mergeSources(reason, getBranchExprReasonUntil(callSection, isSameOrAncestorSection(section, callSection) ? section : section.parent));
 		});
 		return reason;
@@ -2304,7 +2305,8 @@ function addClosureReasons(section) {
 	});
 }
 function addCallOwnerReasons(body) {
-	if (body.readsOwner) forEach(body.callSections, (callSection) => {
+	if (body.readsOwner) forEach(body.calls, (call) => {
+		const callSection = call.childScopeBinding.section;
 		addOwnerReason(callSection, body.parent, getBranchExprReasonUntil(callSection, body.parent));
 	});
 }
@@ -2338,13 +2340,17 @@ function getReasonForBinding(binding, properties) {
 function getReasonForExpr(extra) {
 	return extra.isEffect ? ALWAYS : extraReaders(extra).reason;
 }
+function bindingLandsRetained(binding, properties) {
+	return someRead(bindingReaders(binding, properties), isRetainedInput);
+}
 function landsRetained(extra) {
 	if (extra.retained) return true;
-	if (!extra.isEffect) {
-		const { reads } = extraReaders(extra);
-		if (reads) {
-			for (const read of reads) if (read.retained) return true;
-		}
+	if (!extra.isEffect) return someRead(extraReaders(extra), isRetained);
+	return false;
+}
+function someRead({ reads }, leaf) {
+	if (reads) {
+		for (const [read, tagNameOnly] of reads) if (leaf(read, tagNameOnly)) return true;
 	}
 	return false;
 }
@@ -2398,7 +2404,7 @@ function computeBindingReaders(binding, properties) {
 			if (!(head === "content" && expr.rendersContent && bindingUtil.has(expr.spreadFrom, binding))) readers = mergeReaders(readers, ALWAYS_READ);
 			continue;
 		}
-		readers = mergeReaders(withLandingRead(readers, expr), readersOfDerives(expr, binding, properties));
+		readers = mergeReaders(withLandingRead(readers, expr, binding), readersOfDerives(expr, binding, properties));
 	}
 	for (const alias of binding.aliases) readers = mergeReaders(readers, bindingReaders(alias, properties));
 	if (properties === void 0) return readers;
@@ -2428,16 +2434,31 @@ function mergeReaders(a, b) {
 		reads
 	};
 }
-function withLandingRead(readers, read) {
-	return readers.reads?.has(read) ? readers : {
+function withLandingRead(readers, read, binding) {
+	const had = readers.reads?.get(read);
+	const tagNameOnly = (had ?? true) && every(binding.reads.get(read), isTagNameRead);
+	return had === tagNameOnly ? readers : {
 		reason: readers.reason,
-		reads: new Set(readers.reads).add(read)
+		reads: new Map(readers.reads).set(read, tagNameOnly)
 	};
 }
+function isRetainedInput(read, tagNameOnly) {
+	return !tagNameOnly && isRetained(read);
+}
+function isRetained(read) {
+	return !!read.retained;
+}
+function isTagNameRead({ extra }) {
+	return !!extra.exprRoot?.tagName;
+}
 function unionReads(a, b) {
 	if (!a || !b || a === b) return a || b;
 	let result;
-	for (const read of b) if (!a.has(read)) (result ??= new Set(a)).add(read);
+	for (const [read, tagNameOnly] of b) {
+		const had = a.get(read);
+		const merged = (had ?? true) && tagNameOnly;
+		if (had !== merged) (result ??= new Map(a)).set(read, merged);
+	}
 	return result || a;
 }
 //#endregion
@@ -3001,6 +3022,191 @@ function isMarkoPlaceholder(node) {
 	return _marko_compiler.types.isMarkoPlaceholder(node);
 }
 //#endregion
+//#region src/translator/util/with-comment.ts
+function withLeadingComment(node, value) {
+	if (value) {
+		const comment = {
+			type: "CommentBlock",
+			value: ` ${value} `
+		};
+		node.leadingComments = node.leadingComments ? [...node.leadingComments, comment] : [comment];
+	}
+	return node;
+}
+//#endregion
+//#region src/translator/util/write-guard.ts
+function isSameReason(a, b) {
+	return a === b || (a && b ? a.always && b.always || compareSources(a, b) === 0 : false);
+}
+const groupCheckPrefixes = {
+	_write_guard: "wg",
+	_write_if: "wi"
+};
+const [getSectionGuards] = createOutputSectionState((section) => ({
+	hoists: /* @__PURE__ */ new Map(),
+	declarators: [_marko_compiler.types.variableDeclarator(scopeReasonIdentifier(section), callRuntime("_scope_reason"))]
+}));
+function buildGroupMask(groups) {
+	let mask = 0;
+	let maskNames = "";
+	let dynamic;
+	const props = [];
+	let needsObject = false;
+	let any = false;
+	for (let i = 0; i < groups.length; i++) {
+		const { value, names } = groups[i];
+		if (value === void 0) continue;
+		any = true;
+		if (value === 0) continue;
+		if (i >= 15) needsObject = true;
+		else if (typeof value === "number") {
+			mask |= value << 1 + 2 * i;
+			if (names) maskNames += maskNames ? ` | ${names}` : names;
+		} else {
+			const shifted = _marko_compiler.types.binaryExpression("<<", value, withLeadingComment(_marko_compiler.types.numericLiteral(1 + 2 * i), names));
+			dynamic = dynamic ? _marko_compiler.types.binaryExpression("|", dynamic, shifted) : shifted;
+		}
+		props.push(_marko_compiler.types.objectProperty(withLeadingComment(_marko_compiler.types.numericLiteral(i), names), typeof value === "number" ? _marko_compiler.types.numericLiteral(value) : value));
+	}
+	if (needsObject) return _marko_compiler.types.objectExpression(props);
+	if (!any) return;
+	const literal = mask ? withLeadingComment(_marko_compiler.types.numericLiteral(mask), maskNames) : void 0;
+	return literal && dynamic ? _marko_compiler.types.binaryExpression("|", literal, dynamic) : literal || dynamic || _marko_compiler.types.numericLiteral(0);
+}
+function getScopeReasonStatement(section) {
+	return hasGuardedReason(section) ? _marko_compiler.types.variableDeclaration("const", getSectionGuards(section).declarators) : _marko_compiler.types.expressionStatement(callRuntime("_scope_reason"));
+}
+function getWriteReason(binding) {
+	return findSlot(binding)?.reason;
+}
+function getBranchWriteReason(section) {
+	return findSectionSlot(section, 9)?.reason;
+}
+function getWriteGuard(section, reason, omitUnconditional) {
+	if (!isDynamicWriteGuard(section, reason)) {
+		if (!reason) return _marko_compiler.types.numericLiteral(0);
+		return omitUnconditional ? void 0 : withLeadingComment(_marko_compiler.types.numericLiteral(1), getDebugNames(reason.always ? void 0 : reason.state));
+	}
+	const bit = getGroupsBit(reason.param);
+	if (bit !== void 0) return bit && omitUnconditional ? void 0 : _marko_compiler.types.numericLiteral(bit);
+	return orEachParamGroup(reason.param, "_write_guard");
+}
+function getWriteGuardForAny(section, reasons, omitUnconditional) {
+	if (!Array.isArray(reasons)) return getWriteGuard(section, reasons, omitUnconditional);
+	for (const reason of reasons) if (getWriteBit(section, reason) === 1) return omitUnconditional ? void 0 : withLeadingComment(_marko_compiler.types.numericLiteral(1), getDebugNames(reason.state));
+	let expr;
+	for (const reason of reasons) if (getWriteBit(section, reason) !== 0) expr = orGuard(expr, getWriteGuard(section, reason, false));
+	return expr || _marko_compiler.types.numericLiteral(0);
+}
+function getExprIfWritten(section, reason, expr) {
+	const ownReason = mapBodyParams(section, reason);
+	if (!isGuardedReason(ownReason)) return ownReason && expr;
+	const bit = getGroupsBit(ownReason.param);
+	if (bit !== void 0) return bit ? expr : void 0;
+	return andGuard(orEachParamGroup(ownReason.param, "_write_if"), expr);
+}
+function isEverWritten(section, reason) {
+	const ownReason = mapBodyParams(section, reason);
+	return isGuardedReason(ownReason) ? getGroupsBit(ownReason.param) !== 0 : !!ownReason;
+}
+function getWriteBit(section, reason) {
+	return isDynamicWriteGuard(section, reason) ? getGroupsBit(reason.param) : reason ? 1 : 0;
+}
+function getGroupsBit(params) {
+	return reduceParamGroups(params, addGroupBit, 0);
+}
+function addGroupBit(bit, section, group) {
+	const groupBit = getStaticGroupBit(section, group);
+	return bit === 1 || groupBit === 1 ? 1 : bit === 0 && groupBit === 0 ? 0 : void 0;
+}
+function orEachParamGroup(params, check) {
+	return reduceParamGroups(params, orGroupChecks[check], void 0);
+}
+const orGroupChecks = {
+	_write_guard: orGroupCheck("_write_guard"),
+	_write_if: orGroupCheck("_write_if")
+};
+function orGroupCheck(check) {
+	return (expr, section, group) => getStaticGroupBit(section, group) === 0 ? expr : orGuard(expr, getOrHoistSectionGuard(section, group, check));
+}
+function orGuard(guard, other) {
+	return guard ? _marko_compiler.types.logicalExpression("||", guard, other) : other;
+}
+function andGuard(guard, expr) {
+	return guard ? _marko_compiler.types.logicalExpression("&&", guard, expr) : expr;
+}
+function getOrHoistSectionGuard(section, params, check) {
+	if (!section.paramReasonGroups) return scopeReasonIdentifier(section);
+	const state = getSectionGuards(section);
+	let tracking = state.hoists.get(check);
+	if (!tracking) state.hoists.set(check, tracking = createGuardHoists());
+	const index = getParamReasonGroupIndex(section, params);
+	const name = tracking.names.get(index);
+	if (name) return _marko_compiler.types.identifier(name);
+	const guard = callRuntime(check, scopeReasonIdentifier(section), withLeadingComment(_marko_compiler.types.numericLiteral(index), getDebugNames(params)));
+	const pending = tracking.pending.get(index);
+	if (!pending) {
+		const expr = _marko_compiler.types.parenthesizedExpression(guard);
+		tracking.pending.set(index, expr);
+		return expr;
+	}
+	const hoisted = generateUid(`${groupCheckPrefixes[check]}__${getDebugNamesAsIdentifier(params)}`);
+	tracking.names.set(index, hoisted);
+	tracking.pending.delete(index);
+	state.declarators.push(_marko_compiler.types.variableDeclarator(_marko_compiler.types.identifier(hoisted), guard));
+	pending.expression = _marko_compiler.types.identifier(hoisted);
+	return _marko_compiler.types.parenthesizedExpression(_marko_compiler.types.identifier(hoisted));
+}
+function isDynamicWriteGuard(section, reason) {
+	return isGuardedReason(reason) && !isCrossSection(section, reason);
+}
+function isCrossSection(section, reason) {
+	return some(reason.param, (param) => !isSameOrAncestorSection(param.section, section));
+}
+const [getStaticGroupBits] = createAnalysisSectionState(() => /* @__PURE__ */ new Map());
+function getStaticGroupBit(body, group) {
+	const bits = getStaticGroupBits(body);
+	const index = getParamReasonGroupIndex(body, group);
+	if (!bits.has(index)) {
+		bits.set(index, void 0);
+		bits.set(index, isOnlyCalled(body) ? getCallsBit(body, group) : void 0);
+	}
+	return bits.get(index);
+}
+function getCallsBit(body, group) {
+	const calls = body.calls;
+	let bit;
+	for (const call of Array.isArray(calls) ? calls : [calls]) {
+		const callSection = call.childScopeBinding.section;
+		const callBit = getWriteBit(callSection, findSlot(call.childScopeBinding, 5, callSection, group)?.reason);
+		if (callBit === void 0 || bit !== void 0 && bit !== callBit) return;
+		bit = callBit;
+	}
+	return bit;
+}
+function isOnlyCalled(body) {
+	return !!body.calls && !!body.derives && !some(body.derives.binding, isUsed);
+}
+function isUsed(binding) {
+	return !!binding.reads.size || !!binding.aliases.size || !!binding.propertyAliases.size;
+}
+function createGuardHoists() {
+	return {
+		names: /* @__PURE__ */ new Map(),
+		pending: /* @__PURE__ */ new Map()
+	};
+}
+function hasGuardedReason(section) {
+	if (section.paramReasonGroups || isGuardedReason(mapBodyParams(section, section.reason))) return true;
+	return some(section.slots, isConditionalSlot);
+}
+function isConditionalSlot(slot) {
+	return isGuardedReason(mapBodyParams(slot.section, slot.reason));
+}
+function scopeReasonIdentifier(section) {
+	return _marko_compiler.types.identifier(ensureSharedUid(`scope${section.id}_reason`, section));
+}
+//#endregion
 //#region src/translator/util/sections.ts
 const sectionUtil = new Sorted(function compareSections(a, b) {
 	return a.id - b.id;
@@ -3036,7 +3242,7 @@ function ensureBodySection(path) {
 			returnValueExpr: void 0,
 			content: getContentInfo(path),
 			branchExpr: void 0,
-			callSections: void 0,
+			calls: void 0,
 			knownTags: void 0,
 			derives: void 0,
 			dropped: !!extra.dropped,
@@ -3081,11 +3287,23 @@ function forEachSection(fn) {
 	sections?.forEach(fn);
 }
 function getDynamicTagContentClosures(section) {
-	if (section.branchExpr?.tagNameType === 2) return getClosuresFromAbove(section, section);
+	const { derives } = section;
+	if (section.branchExpr?.tagNameType === 2 || derives && some(derives.binding, (binding) => bindingLandsRetained(binding, derives.properties))) return bindingUtil.filter(getClosuresFromAbove(section, section, /* @__PURE__ */ new Set()), mayBeUnwritten);
+}
+function mayBeUnwritten(closure) {
+	const reason = getWriteReason(closure);
+	return !reason || isGuardedReason(reason);
 }
-function getClosuresFromAbove(section, top) {
+function getClosuresFromAbove(section, top, seen) {
 	let closures = bindingUtil.leadingRun(section.referencedClosures, bindingToSection, sectionUtil.compare, top);
-	for (const child of section.children) closures = bindingUtil.union(closures, getClosuresFromAbove(child, top));
+	for (const child of section.children) closures = bindingUtil.union(closures, getClosuresFromAbove(child, top, seen));
+	for (const tagExtra of section.knownTags || []) {
+		const body = tagExtra.childSection;
+		if (!seen.has(body)) {
+			seen.add(body);
+			closures = bindingUtil.union(closures, getClosuresFromAbove(body, isSameOrAncestorSection(top, body) ? top : body, seen));
+		}
+	}
 	return closures;
 }
 function forEachAncestorSection(from, to, fn, arg) {
@@ -3197,7 +3415,7 @@ function ensureSlotReasonGroups(slot) {
 }
 function ensureReasonGroups(section, reason) {
 	const ownReason = mapBodyParams(section, reason);
-	if (isConditionalReason(ownReason)) forEachParamGroup(ownReason.param, ensureParamReasonGroup);
+	if (isGuardedReason(ownReason)) forEachParamGroup(ownReason.param, ensureParamReasonGroup);
 }
 function ensureParamReasonGroup(section, group) {
 	const { paramReasonGroups } = section;
@@ -3527,7 +3745,8 @@ function finalizeSetupWork() {
 	});
 }
 function setCallSectionsSetup(body) {
-	forEach(body.callSections, (callSection) => {
+	forEach(body.calls, (call) => {
+		const callSection = call.childScopeBinding.section;
 		if (!callSection.hasSetupWork) {
 			callSection.hasSetupWork = true;
 			setCallSectionsSetup(callSection);
@@ -3840,139 +4059,6 @@ function getDestructurePattern(id) {
 	}
 }
 //#endregion
-//#region src/translator/util/with-comment.ts
-function withLeadingComment(node, value) {
-	if (value) {
-		const comment = {
-			type: "CommentBlock",
-			value: ` ${value} `
-		};
-		node.leadingComments = node.leadingComments ? [...node.leadingComments, comment] : [comment];
-	}
-	return node;
-}
-//#endregion
-//#region src/translator/util/write-guard.ts
-function isSameReason(a, b) {
-	return a === b || (a && b ? a.always && b.always || compareSources(a, b) === 0 : false);
-}
-const groupCheckPrefixes = {
-	_write_guard: "wg",
-	_write_if: "wi"
-};
-const [getSectionGuards] = createOutputSectionState((section) => ({
-	hoists: /* @__PURE__ */ new Map(),
-	declarators: [_marko_compiler.types.variableDeclarator(scopeReasonIdentifier(section), callRuntime("_scope_reason"))]
-}));
-function buildGroupMask(groups) {
-	let mask = 0;
-	let maskNames = "";
-	let dynamic;
-	const props = [];
-	let needsObject = false;
-	let any = false;
-	for (let i = 0; i < groups.length; i++) {
-		const { value, names } = groups[i];
-		if (value === void 0) continue;
-		any = true;
-		if (value === 0) continue;
-		if (i >= 15) needsObject = true;
-		else if (typeof value === "number") {
-			mask |= value << 1 + 2 * i;
-			if (names) maskNames += maskNames ? ` | ${names}` : names;
-		} else {
-			const shifted = _marko_compiler.types.binaryExpression("<<", value, withLeadingComment(_marko_compiler.types.numericLiteral(1 + 2 * i), names));
-			dynamic = dynamic ? _marko_compiler.types.binaryExpression("|", dynamic, shifted) : shifted;
-		}
-		props.push(_marko_compiler.types.objectProperty(withLeadingComment(_marko_compiler.types.numericLiteral(i), names), typeof value === "number" ? _marko_compiler.types.numericLiteral(value) : value));
-	}
-	if (needsObject) return _marko_compiler.types.objectExpression(props);
-	if (!any) return;
-	const literal = mask ? withLeadingComment(_marko_compiler.types.numericLiteral(mask), maskNames) : void 0;
-	return literal && dynamic ? _marko_compiler.types.binaryExpression("|", literal, dynamic) : literal || dynamic || _marko_compiler.types.numericLiteral(0);
-}
-function getScopeReasonStatement(section) {
-	return hasConditionalReason(section) ? _marko_compiler.types.variableDeclaration("const", getSectionGuards(section).declarators) : _marko_compiler.types.expressionStatement(callRuntime("_scope_reason"));
-}
-function getWriteReason(binding) {
-	return findSlot(binding)?.reason;
-}
-function getBranchWriteReason(section) {
-	return findSectionSlot(section, 9)?.reason;
-}
-function getWriteGuard(section, reason, omitUnconditional) {
-	if (!isDynamicWriteGuard(section, reason)) {
-		if (!reason) return _marko_compiler.types.numericLiteral(0);
-		return omitUnconditional ? void 0 : withLeadingComment(_marko_compiler.types.numericLiteral(1), getDebugNames(reason.always ? void 0 : reason.state));
-	}
-	return orEachParamGroup(reason.param, "_write_guard");
-}
-function getWriteGuardForAny(section, reasons, omitUnconditional) {
-	if (!Array.isArray(reasons)) return getWriteGuard(section, reasons, omitUnconditional);
-	for (const reason of reasons) if (!isConditionalReason(reason)) return omitUnconditional ? void 0 : withLeadingComment(_marko_compiler.types.numericLiteral(1), getDebugNames(reason.state));
-	let expr;
-	for (const reason of reasons) expr = orGuard(expr, getWriteGuard(section, reason, false));
-	return expr;
-}
-function getExprIfWritten(section, reason, expr) {
-	const ownReason = mapBodyParams(section, reason);
-	if (!isConditionalReason(ownReason)) return ownReason && expr;
-	return andGuard(orEachParamGroup(ownReason.param, "_write_if"), expr);
-}
-function orEachParamGroup(params, check) {
-	return reduceParamGroups(params, (expr, section, group) => orGuard(expr, getOrHoistSectionGuard(section, group, check)), void 0);
-}
-function orGuard(guard, other) {
-	return guard ? _marko_compiler.types.logicalExpression("||", guard, other) : other;
-}
-function andGuard(guard, expr) {
-	return guard ? _marko_compiler.types.logicalExpression("&&", guard, expr) : expr;
-}
-function getOrHoistSectionGuard(section, params, check) {
-	if (!section.paramReasonGroups) return scopeReasonIdentifier(section);
-	const state = getSectionGuards(section);
-	let tracking = state.hoists.get(check);
-	if (!tracking) state.hoists.set(check, tracking = createGuardHoists());
-	const index = getParamReasonGroupIndex(section, params);
-	const name = tracking.names.get(index);
-	if (name) return _marko_compiler.types.identifier(name);
-	const guard = callRuntime(check, scopeReasonIdentifier(section), withLeadingComment(_marko_compiler.types.numericLiteral(index), getDebugNames(params)));
-	const pending = tracking.pending.get(index);
-	if (!pending) {
-		const expr = _marko_compiler.types.parenthesizedExpression(guard);
-		tracking.pending.set(index, expr);
-		return expr;
-	}
-	const hoisted = generateUid(`${groupCheckPrefixes[check]}__${getDebugNamesAsIdentifier(params)}`);
-	tracking.names.set(index, hoisted);
-	tracking.pending.delete(index);
-	state.declarators.push(_marko_compiler.types.variableDeclarator(_marko_compiler.types.identifier(hoisted), guard));
-	pending.expression = _marko_compiler.types.identifier(hoisted);
-	return _marko_compiler.types.parenthesizedExpression(_marko_compiler.types.identifier(hoisted));
-}
-function isDynamicWriteGuard(section, reason) {
-	return isConditionalReason(reason) && !isCrossSection(section, reason);
-}
-function isCrossSection(section, reason) {
-	return some(reason.param, (param) => !isSameOrAncestorSection(param.section, section));
-}
-function createGuardHoists() {
-	return {
-		names: /* @__PURE__ */ new Map(),
-		pending: /* @__PURE__ */ new Map()
-	};
-}
-function hasConditionalReason(section) {
-	if (section.paramReasonGroups || isConditionalReason(mapBodyParams(section, section.reason))) return true;
-	return some(section.slots, isConditionalSlot);
-}
-function isConditionalSlot(slot) {
-	return isConditionalReason(mapBodyParams(slot.section, slot.reason));
-}
-function scopeReasonIdentifier(section) {
-	return _marko_compiler.types.identifier(ensureSharedUid(`scope${section.id}_reason`, section));
-}
-//#endregion
 //#region src/translator/util/build-string-expression.ts
 function buildStringExpression(parts, useIife) {
 	const strs = [""];
@@ -4090,7 +4176,7 @@ function setSectionOwnerResumedByMarker(section) {
 	setOwnerResumedByMarker(section, true);
 }
 function getContentClosureValues(bodySection) {
-	const contentClosures = bindingUtil.filter(getDynamicTagContentClosures(bodySection), mayBeUnwritten);
+	const contentClosures = getDynamicTagContentClosures(bodySection);
 	if (!contentClosures) return;
 	const scope = generateUidIdentifier("scope");
 	const closures = Array.isArray(contentClosures) ? contentClosures : [contentClosures];
@@ -4111,9 +4197,6 @@ function getContentClosureValues(bodySection) {
 		levels: levels.reverse()
 	};
 }
-function mayBeUnwritten(closure) {
-	return !isUnconditionalReason(getWriteReason(closure));
-}
 const [getScopeProperties] = createOutputSectionState(() => /* @__PURE__ */ new Map());
 function writeSlot(slot, expression) {
 	const reason = slot?.reason;
@@ -4537,9 +4620,9 @@ function writeHTMLResumeStatements(path) {
 				const closureIndex = getDynamicClosureIndex(closure, section);
 				if (closureIndex) writeSlot(findSlot(closure, 3, section), _marko_compiler.types.numericLiteral(closureIndex));
 				const closureScopesReason = findSlot(closure, 2)?.reason;
-				const subscribeArg = isConditionalReason(closureScopesReason) && !isSameReason(closureScopesReason, sectionReason) ? getExprIfWritten(closure.section, closureScopesReason, identifier) : identifier;
+				const subscribeArg = isGuardedReason(closureScopesReason) && !isSameReason(closureScopesReason, sectionReason) ? getExprIfWritten(closure.section, closureScopesReason, identifier) : identifier;
 				const changeable = isChangeableDynamicClosure(section, closure);
-				addWriteScopeBuilder(section, (expr) => {
+				if (subscribeArg) addWriteScopeBuilder(section, (expr) => {
 					const resumeId = changeable && _marko_compiler.types.stringLiteral(getResumeRegisterId(section, closure, "subscribe"));
 					return callRuntime("_subscribe", subscribeArg, expr, resumeId, resumeId && markerGuard);
 				});
@@ -4564,7 +4647,8 @@ function writeHTMLResumeStatements(path) {
 		if (!reason) return;
 		const accessor = getScopeAccessor(binding);
 		pendingProperties.delete(accessor);
-		scopeProperties.push(toObjectProperty(accessor, ifWritten(reason, getDeclaredBindingExpression(binding))));
+		const value = ifWritten(reason, getDeclaredBindingExpression(binding));
+		if (value) scopeProperties.push(toObjectProperty(accessor, value));
 		if (debug) {
 			const { root, access } = getDebugAccess(binding, false, toAccess);
 			const locExpr = root.loc && _marko_compiler.types.stringLiteral(getDebugLoc(root.loc));
@@ -4579,10 +4663,14 @@ function writeHTMLResumeStatements(path) {
 		const ownerReason = findSectionSlot(section, 7)?.reason;
 		if (ownerReason) {
 			pendingProperties.delete(ownerAccessor);
-			if (!getOwnerResumedByMarker(section)) scopeProperties.push(toObjectProperty(ownerAccessor, ifWritten(ownerReason, callRuntime("_scope_with_id", getScopeIdIdentifier(section.parent)))));
+			const owner = !getOwnerResumedByMarker(section) && ifWritten(ownerReason, callRuntime("_scope_with_id", getScopeIdIdentifier(section.parent)));
+			if (owner) scopeProperties.push(toObjectProperty(ownerAccessor, owner));
 		}
 	}
-	for (const [key, { expression, reason }] of pendingProperties) scopeProperties.push(toObjectProperty(key, ifWritten(reason, expression)));
+	for (const [key, { expression, reason }] of pendingProperties) {
+		const value = ifWritten(reason, expression);
+		if (value) scopeProperties.push(toObjectProperty(key, value));
+	}
 	if (sectionReason) {
 		for (const prop of scopeProperties) if (prop.key.type === "Identifier" && prop.value.type === "Identifier" && prop.key.name === prop.value.name) prop.shorthand = true;
 		const writeScopeArgs = [scopeIdIdentifier, _marko_compiler.types.objectExpression(scopeProperties)];
@@ -4591,8 +4679,8 @@ function writeHTMLResumeStatements(path) {
 			for (const [accessor, varLoc] of getSectionDebugVars(section)) (debugVars ||= []).push(toObjectProperty(accessor, _marko_compiler.types.valueToNode(varLoc)));
 			if (debugVars) writeScopeArgs.push(_marko_compiler.types.objectExpression(debugVars));
 		}
-		const writeCall = writeScopeBuilder ? writeScopeBuilder(callRuntime("_scope", ...writeScopeArgs)) : callRuntime("_scope", ...writeScopeArgs);
-		body.push(_marko_compiler.types.expressionStatement(getExprIfWritten(section, sectionReason, writeCall)));
+		const write = getExprIfWritten(section, sectionReason, writeScopeBuilder ? writeScopeBuilder(callRuntime("_scope", ...writeScopeArgs)) : callRuntime("_scope", ...writeScopeArgs));
+		if (write) body.push(_marko_compiler.types.expressionStatement(write));
 	}
 	if (!isOptionalBranch(section) && (section.hasAbortSignal || !!section.referencedClosures || sectionReason && some(section.bindings, isLetBinding)) && markerGuard) {
 		const call = callRuntime("_resume_branch", scopeIdIdentifier);
@@ -4967,7 +5055,6 @@ function getSingleKnownSpread(paramsTree, attributes) {
 //#region src/translator/util/known-tag.ts
 const [getTagVarBindings] = createOutputSectionState(() => []);
 const [getCallSiteSourcesByParam] = createAnalysisState(() => /* @__PURE__ */ new Map());
-const kChildSection = Symbol("known tag child section");
 const kParamsTree = Symbol("known tag params tree");
 const kKnownExprs = Symbol("known tag exprs");
 const [getRecursiveTags] = createAnalysisState(() => []);
@@ -4977,15 +5064,15 @@ function knownTagAnalyze(tag, childSection, childParamsTree) {
 	const tagBody = tag.get("body");
 	const tagExtra = tag.node.extra ??= {};
 	tagExtra.childScopeBinding = createBinding("#childScope", 0, section);
+	tagExtra.childSection = childSection;
 	ensureBodySection(tagBody);
 	trackParamsReferences(tagBody, 2);
 	(section.knownTags ||= []).push(tagExtra);
-	tagExtra[kChildSection] = childSection;
 	const varBinding = trackVarReferences(tag, 4);
 	const recursive = isSameOrAncestorSection(childSection, section);
 	let exprs;
 	if (childSection.program === section.program) {
-		childSection.callSections = sectionUtil.add(childSection.callSections, section);
+		childSection.calls = push(childSection.calls, tagExtra);
 		if (recursive) getRecursiveTags().push(tag);
 		else exprs = analyzeKnownTagParams(tag, exposeChildParamsTree(childSection));
 	} else exprs = analyzeKnownTagParams(tag, childParamsTree);
@@ -5009,7 +5096,7 @@ function knownTagAnalyze(tag, childSection, childParamsTree) {
 }
 function analyzeRecursiveTags() {
 	for (const tag of getRecursiveTags()) {
-		const childSection = tag.node.extra[kChildSection];
+		const childSection = tag.node.extra.childSection;
 		assertTerminates(tag, childSection);
 		const exprs = analyzeKnownTagParams(tag, exposeChildParamsTree(childSection));
 		if (tag.node.var) {
@@ -5024,8 +5111,8 @@ function assertTerminates(tag, childSection) {
 	const callers = /* @__PURE__ */ new Set([getSection(tag)]);
 	for (const caller of callers) {
 		if (caller === childSection) throw tag.get("name").buildCodeFrameError(`A ${childSection === (0, _marko_compiler_babel_utils.getProgram)().node.extra.section ? "template" : "`<define>`"} that renders itself outside a branch never terminates. Render \`<${getTagNameHint(tag.node)}>\` inside a branch that eventually stops, such as \`<if>\`.`);
-		forEach(caller.callSections, (callSection) => {
-			callers.add(callSection);
+		forEach(caller.calls, (call) => {
+			callers.add(call.childScopeBinding.section);
 		});
 	}
 }
@@ -5048,8 +5135,8 @@ function getReturnParams(section) {
 function assertReturns(tag, childSection) {
 	if (!childSection.returnValueExpr) throw tag.get("var").buildCodeFrameError(`The \`${getTagNameHint(tag.node)}\` tag does not [\`<return>\`](https://markojs.com/docs/reference/core-tag#return) a value, so it does not support a [tag variable](https://markojs.com/docs/reference/language#tag-variables). Remove the variable, or add a \`<return>\` to the tag.`);
 }
-function isChildScopeResumed(tagExtra) {
-	return !!findSlot(tagExtra.childScopeBinding)?.reason;
+function isChildScopeResumed(section, tagExtra) {
+	return isEverWritten(section, findSlot(tagExtra.childScopeBinding)?.reason);
 }
 function getRenderArgs(tag, properties) {
 	const args = tag.node.arguments;
@@ -5066,7 +5153,7 @@ function toRenderArg(arg) {
 function knownTagTranslateHTML(tag, tagIdentifier) {
 	const { node } = tag;
 	const tagExtra = node.extra;
-	const childSection = tagExtra[kChildSection];
+	const childSection = tagExtra.childSection;
 	const paramsTree = getSettledParamsTree(tagExtra[kParamsTree]);
 	writeHTMLResumeStatements(tag);
 	const tagVar = node.var;
@@ -5078,8 +5165,8 @@ function knownTagTranslateHTML(tag, tagIdentifier) {
 	};
 	const childScopeBinding = tagExtra.childScopeBinding;
 	let varStatement;
-	if (isChildScopeResumed(tagExtra)) {
-		const peekScopeId = generateUidIdentifier(childScopeBinding?.name);
+	if (isChildScopeResumed(section, tagExtra)) {
+		const peekScopeId = generateUidIdentifier(childScopeBinding.name);
 		statements.push(_marko_compiler.types.variableDeclaration("const", [_marko_compiler.types.variableDeclarator(peekScopeId, callRuntime("_peek_scope_id"))]));
 		const childScopeSlot = findSlot(childScopeBinding);
 		writeSlot(childScopeSlot, callRuntime("_existing_scope", peekScopeId));
@@ -5104,7 +5191,7 @@ function knownTagTranslateDOM(tag, getBindingIdentifier, callSetup) {
 	if (node.var) {
 		const varBinding = node.var.extra.binding;
 		const signal = initValue(varBinding);
-		signal.register = isChildScopeResumed(extra);
+		signal.register = isChildScopeResumed(getSection(tag), extra);
 		signal.referenced = true;
 		signal.buildAssignment = (valueSection, value) => buildVarChange(createScopeReadExpression(childScopeBinding, valueSection), value, varBinding);
 		getTagVarBindings(tagSection).push(_marko_compiler.types.expressionStatement(callRuntime("_var", scopeIdentifier, getScopeAccessorLiteral(childScopeBinding, true), signal.identifier)));
@@ -5122,8 +5209,8 @@ function getCallSiteSources(param) {
 	if (sourcesByParam.has(param)) return sourcesByParam.get(param);
 	const body = param.section;
 	let sources;
-	forEach(body.callSections, (callSection) => {
-		for (const tagExtra of callSection.knownTags) if (tagExtra[kChildSection] === body) sources = mergeSources(sources, getSourcesForExprs(mapParamBindingToExpr(tagExtra[kKnownExprs], param)));
+	forEach(body.calls, (call) => {
+		sources = mergeSources(sources, getSourcesForExprs(mapParamBindingToExpr(call[kKnownExprs], param)));
 	});
 	sourcesByParam.set(param, sources);
 	return sources;
@@ -5136,8 +5223,8 @@ function addKnownTagReasons(section) {
 	for (const tagExtra of section.knownTags || []) {
 		const { childScopeBinding } = tagExtra;
 		const knownExprs = tagExtra[kKnownExprs];
-		const childSection = tagExtra[kChildSection];
-		if (knownExprs && childScopeBinding && childSection.paramReasonGroups) {
+		const { childSection } = tagExtra;
+		if (knownExprs && childSection.paramReasonGroups) {
 			for (const group of childSection.paramReasonGroups) if (!findSlot(childScopeBinding, 5, section, group)) {
 				const slot = ensureSlot(childScopeBinding, 5, section, group);
 				slot.reasonExprs = mapParamReasonToExpr(knownExprs, group);
@@ -5148,7 +5235,7 @@ function addKnownTagReasons(section) {
 }
 function callsOtherTemplateSetup(section) {
 	for (const tagExtra of section.knownTags || []) {
-		const childSection = tagExtra[kChildSection];
+		const { childSection } = tagExtra;
 		if (tagExtra.tagNameLoad || childSection.program !== section.program && childSection.hasSetupWork) return true;
 	}
 	return false;
@@ -5609,12 +5696,9 @@ function mapBodyParams(section, reason, seen) {
 	if (params === reason.param) return reason;
 	return mergeSources(mapBodyParams(section, mapped, seen), withSources(reason, reason.state, params)) || ALWAYS;
 }
-function isConditionalReason(reason) {
+function isGuardedReason(reason) {
 	return !!reason && !reason.always && !reason.state;
 }
-function isUnconditionalReason(reason) {
-	return !!reason && !isConditionalReason(reason);
-}
 function isStateReason(reason) {
 	return !!reason && !reason.always && !!reason.state;
 }
@@ -5942,7 +6026,9 @@ function initBranchSection(bodySection, branchExpr, branch) {
 }
 function resumeOwnerByMarkerWhenUnconditional(bodySection, nodeBinding) {
 	const branchExprReason = findSlot(nodeBinding, 4)?.reason;
-	if (isStateReason(branchExprReason) && some(branchExprReason.state, hasResumableAssignment) && isUnconditionalReason(getBranchWriteReason(bodySection)) && isUnconditionalReason(getWriteReason(nodeBinding))) setSectionOwnerResumedByMarker(bodySection);
+	const branchReason = getBranchWriteReason(bodySection);
+	const nodeReason = getWriteReason(nodeBinding);
+	if (isStateReason(branchExprReason) && some(branchExprReason.state, hasResumableAssignment) && branchReason && !isGuardedReason(branchReason) && nodeReason && !isGuardedReason(nodeReason)) setSectionOwnerResumedByMarker(bodySection);
 }
 function getBranchResumeArgs(tag, branchReasons, singleNode) {
 	const tagSection = getSection(tag);
@@ -8085,8 +8171,8 @@ function resolveBindings() {
 	}
 }
 function addSectionReasons(section) {
-	if (section.readsOwner) forEach(section.callSections, (callSection) => {
-		setReadsOwner(callSection, section.parent);
+	if (section.readsOwner) forEach(section.calls, (call) => {
+		setReadsOwner(call.childScopeBinding.section, section.parent);
 	});
 	if (section.isHoistThrough) addReason(ensureSectionSlot(section, 6), ALWAYS);
 	forEach(section.referencedClosures, (closure) => {
@@ -9816,6 +9902,7 @@ var dynamic_tag_default = {
 		analyzeAttributeTags(tag);
 		const tagSection = ensureSection(tag);
 		const inputNodes = getAllTagReferenceNodes(node);
+		(node.name.extra ??= {}).tagName = true;
 		const tagExtra = mergeReferences(tagSection, node, [node.name, ...inputNodes]);
 		if (inputNodes.length) tagExtra.retained = true;
 		const tagBody = tag.get("body");
@@ -9841,7 +9928,7 @@ var dynamic_tag_default = {
 		trackParamsReferences(tagBody, 2);
 		if (usesVar) addAlwaysReason(nodeBinding);
 		addReasonExprs(ensureSlot(nodeBinding), tagExtra);
-		if (!hasVar && !node.arguments && !node.attributes.length && !node.body.body.length) tagExtra.nameOnly = true;
+		if (!hasVar && !node.arguments && !node.attributes.length && !node.body.body.length && !tagExtra.attrTagLookup) tagExtra.nameOnly = true;
 		marker(tag, nodeBinding);
 		enterShallow(tag);
 		if (bodySection && tagExtra.featureType === "class" && !(0, _marko_compiler_babel_utils.getTagTemplate)(tag)) bodySection.structure = null;
@@ -10234,7 +10321,8 @@ var program_default = {
 			if (paramsBinding && !paramsBinding.pruned) programExtra.paramsTree = exposeParamsTree(paramsBinding);
 			const section = programExtra.section;
 			forEachSection((childSection) => {
-				programExtra.hasResumes ||= !!(isUnconditionalReason(mapBodyParams(childSection, childSection.reason)) || childSection !== section && !isSectionRendererElided(childSection) && getRendererReason(childSection));
+				const reason = mapBodyParams(childSection, childSection.reason);
+				programExtra.hasResumes ||= !!(reason && !isGuardedReason(reason) || childSection !== section && !isSectionRendererElided(childSection) && getRendererReason(childSection));
 			});
 			finalizeSetupWork();
 		}

package/dist/translator/util/known-tag.d.ts

@@ -4,19 +4,23 @@ import { type ParamsTree } from "./params-tree";
 import { type KnownExprs } from "./reasons";
 import { type Section } from "./sections";
 import { type Sources } from "./sources";
-declare const kChildSection: unique symbol;
 declare const kParamsTree: unique symbol;
 declare const kKnownExprs: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
         /** The dom binding a known tag holds its child's scope in. */
         childScopeBinding?: Binding;
-        [kChildSection]?: Section;
+        /** The section a known tag renders: another template's, a `<define>` body. */
+        childSection?: Section;
         /** The child's params tree the call site was analyzed against. */
         [kParamsTree]?: ParamsTree;
         [kKnownExprs]?: KnownExprs;
     }
 }
+export interface KnownTagExtra extends t.MarkoTagExtra {
+    childScopeBinding: Binding;
+    childSection: Section;
+}
 export declare function knownTagAnalyze(tag: t.NodePath<t.MarkoTag>, childSection: Section, childParamsTree?: ParamsTree): void;
 export declare function analyzeRecursiveTags(): void;
 export declare function knownTagTranslateHTML(tag: t.NodePath<t.MarkoTag>, tagIdentifier: t.Expression): void;

package/dist/translator/util/reasons.d.ts

@@ -11,11 +11,10 @@ export declare function addAlwaysReason(binding: Binding): void;
 export declare function addReasonExprs(slot: Slot, expr: Opt<t.NodeExtra>): void;
 export declare function addOwnerReason(from: Section, to: Section, reason: undefined | false | Reason): void;
 export declare function mapBodyParams(section: Section, reason: undefined | Reason, seen?: Set<ParamBinding>): Reason | undefined;
-export declare function isConditionalReason(reason: undefined | Reason): reason is Sources & {
+export declare function isGuardedReason(reason: undefined | Reason): reason is Sources & {
     state: undefined;
     always: undefined;
 };
-export declare function isUnconditionalReason(reason: undefined | Reason): reason is Reason;
 export declare function isStateReason(reason: undefined | Reason): reason is Sources;
 export declare function getSourcesForExpr(expr: t.NodeExtra): Sources | undefined;
 export declare function getSourcesForExprs(exprs: Opt<t.NodeExtra> | boolean): Sources | undefined;

package/dist/translator/util/references.d.ts

@@ -63,6 +63,8 @@ declare module "@marko/compiler/dist/types" {
         assignment?: Binding;
         assignmentTo?: Binding;
         read?: ResolvedRead;
+        /** An expression root that is a dynamic tag's name, not one of its inputs. */
+        tagName?: true;
         dropped?: true;
         /** The expression this node sits in: dropped or merged as one. */
         exprRoot?: NodeExtra;

package/dist/translator/util/sections.d.ts

@@ -3,6 +3,7 @@ import { type Binding, type Intersection, type IntersectionMeta, type ParamBindi
 import * as ContentType from "./constants/content-type";
 import type * as Step from "./constants/step";
 import * as StructureKind from "./constants/structure-kind";
+import type { KnownTagExtra } from "./known-tag";
 import { type OneMany, type Opt, Sorted, type SortedOpt } from "./optional";
 import { type KnownExprs, type Reason } from "./reasons";
 import { type Slot } from "./slots";
@@ -70,11 +71,11 @@ export interface Section {
     returnValueExpr: t.NodeExtra | undefined;
     isHoistThrough: true | undefined;
     branchExpr: t.NodeExtra | undefined;
-    /** For a `<define>` body or a template rendering itself, the sections whose
-     * direct calls render it. */
-    callSections: SortedOpt<Section>;
+    /** For a `<define>` body or a template rendering itself, the known tags whose
+     * direct calls render it (each in its child scope binding's section). */
+    calls: Opt<KnownTagExtra>;
     /** The known tags rendering in it, in analyze order. */
-    knownTags: t.MarkoTagExtra[] | undefined;
+    knownTags: KnownTagExtra[] | undefined;
     /** The content's rendering tag (its extra), and each child binding that
      * derives from the content, at `properties`. */
     derives: {
@@ -128,7 +129,7 @@ export declare function getSection(path: t.NodePath): Section;
 export declare const getScopeIdIdentifier: (section: Section) => t.Identifier;
 export declare const getBranchRendererArgs: (section: Section) => [template?: t.Expression | undefined, walks?: t.Expression | undefined, setup?: t.Expression | undefined, params?: t.Expression | undefined], setBranchRendererArgs: (section: Section, value: [template?: t.Expression | undefined, walks?: t.Expression | undefined, setup?: t.Expression | undefined, params?: t.Expression | undefined]) => void;
 export declare function forEachSection(fn: (section: Section) => void): void;
-export declare function getDynamicTagContentClosures(section: Section): ReferencedBindings;
+export declare function getDynamicTagContentClosures(section: Section): SortedOpt<Binding>;
 export declare function forEachAncestorSection<A>(from: Section, to: Section, fn: (section: Section, arg: A) => void, arg: A): void;
 export declare function forEachSectionReverse(fn: (section: Section) => void): void;
 export declare function getNodeContentType(path: t.NodePath<t.Statement>, edge: "startType" | "endType"): ContentType.Value | null;

package/dist/translator/util/solve-reasons.d.ts

@@ -6,4 +6,5 @@ import { type Section } from "./sections";
 export declare function solveReasons(intersectionsBySection: Map<Section, Intersection[]>): void;
 export declare function getReasonForBinding(binding: Binding, properties?: Opt<string> | true): undefined | Reason;
 export declare function getReasonForExpr(extra: t.NodeExtra): undefined | Reason;
+export declare function bindingLandsRetained(binding: Binding, properties: Opt<string>): boolean;
 export declare function landsRetained(extra: t.NodeExtra): boolean;

package/dist/translator/util/write-guard.d.ts

@@ -13,4 +13,5 @@ export declare function getWriteReason(binding: Binding): Sources | undefined;
 export declare function getBranchWriteReason(section: Section): Sources | undefined;
 export declare function getWriteGuard(section: Section, reason: undefined | Reason, omitUnconditional: boolean): t.Expression | undefined;
 export declare function getWriteGuardForAny(section: Section, reasons: undefined | Reasons, omitUnconditional: boolean): t.Expression | undefined;
-export declare function getExprIfWritten<T extends undefined | Reason, R extends (T extends {} ? t.Expression : undefined)>(section: Section, reason: T, expr: t.Expression): R;
+export declare function getExprIfWritten(section: Section, reason: undefined | Reason, expr: t.Expression): t.Expression | undefined;
+export declare function isEverWritten(section: Section, reason: undefined | Reason): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/runtime-tags",
-  "version": "6.4.7",
+  "version": "6.4.8",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -51,14 +51,14 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.42.13",
+    "@marko/compiler": "^5.42.14",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "6.4.7",
-    "marko": "5.39.47"
+    "@marko/runtime-tags": "6.4.8",
+    "marko": "5.39.48"
   },
   "engines": {
     "node": ">=22"

package/tags-html.d.ts

@@ -97,6 +97,7 @@ declare global {
       search: NativeTag<Marko.HTML.Search, HTMLElement>;
       section: NativeTag<Marko.HTML.Section, HTMLElement>;
       select: NativeTag<Marko.HTML.Select, HTMLSelectElement>;
+      selectedcontent: NativeTag<Marko.HTML.SelectedContent, HTMLElement>;
       slot: NativeTag<Marko.HTML.Slot, HTMLSlotElement>;
       small: NativeTag<Marko.HTML.Small, HTMLElement>;
       source: NativeTag<Marko.HTML.Source, HTMLSourceElement>;
@@ -2056,6 +2057,8 @@ declare global {
             ) => void);
       }
 
+      interface SelectedContent extends HTMLAttributes<HTMLElement> {}
+
       interface Slot extends HTMLAttributes<HTMLSlotElement> {
         /**
          * Used to assign slots to other elements