marko 6.4.1 → 6.4.3

package/dist/translator/index.js

@@ -156,6 +156,7 @@ var accessor_prop_debug_exports = /* @__PURE__ */ __exportAll({
 	AbortScopes: () => AbortScopes$1,
 	AwaitCounter: () => AwaitCounter$1,
 	BranchAccessor: () => BranchAccessor$1,
+	BranchRenders: () => BranchRenders$1,
 	BranchScopes: () => BranchScopes$2,
 	CatchContent: () => CatchContent$1,
 	ClosestBranch: () => ClosestBranch$1,
@@ -189,6 +190,7 @@ const AbortControllers$1 = "#AbortControllers";
 const AbortScopes$1 = "#AbortScopes";
 const AwaitCounter$1 = "#AwaitCounter";
 const BranchAccessor$1 = "#BranchAccessor";
+const BranchRenders$1 = "#BranchRenders";
 const BranchScopes$2 = "#BranchScopes";
 const CatchContent$1 = "#CatchContent";
 const ClosestBranch$1 = "#ClosestBranch";
@@ -797,6 +799,11 @@ function isInvokedFunction(expr) {
 	return false;
 }
 //#endregion
+//#region src/translator/util/is-static.ts
+function isStatic(path) {
+	return path.isImportDeclaration() || path.isExportDeclaration() || path.isMarkoScriptlet({ static: true });
+}
+//#endregion
 //#region src/translator/util/binding-has-prop.ts
 function getSectionRendererIdentifier(section) {
 	return isSectionRendererElided(section) ? void 0 : _marko_compiler.types.identifier(section.name);
@@ -829,6 +836,7 @@ function getPropertyPathAlias(binding, properties) {
 const Node = "node";
 const Text = "text";
 const Child = "child";
+const ModuleRead = "moduleRead";
 const SectionRef = "sectionRef";
 const ExportRef = "exportRef";
 //#endregion
@@ -968,7 +976,7 @@ var function_default = { analyze(fn) {
 	fnExtra.exprRoot = exprRoot.node.extra ??= {};
 	fnExtra.name = node.id?.name || (isMarkoAttribute(markoRoot) ? markoRoot.node.default ? _marko_compiler.types.toIdentifier((markoRoot.parentPath.has("var") ? markoRoot.parentPath.get("var") : markoRoot.parentPath.get("name")).toString()) : markoRoot.node.name : _marko_compiler.types.isVariableDeclarator(fn.parent) && _marko_compiler.types.isIdentifier(fn.parent.id) ? fn.parent.id.name : _marko_compiler.types.isObjectMethod(node) && _marko_compiler.types.isIdentifier(node.key) ? node.key.name : "anonymous");
 	reserveExportRegisterId(fnExtra, fn, markoRoot);
-	if (isStaticRoot(markoRoot)) {
+	if (isStatic(markoRoot)) {
 		const refs = getStaticDeclRefs(fn);
 		if (refs.size) getReferencesByFn().set(fnExtra, refs);
 	} else getReferencesByFn().set(fnExtra, /* @__PURE__ */ new Set([fnExtra.exprRoot]));
@@ -1047,7 +1055,7 @@ function registerImportedFn({ node, ...importedFn }) {
 	(0, _marko_compiler_babel_utils.getProgram)().node.extra.isInteractive = true;
 }
 function reserveExportRegisterId(fnExtra, fn, markoRoot) {
-	if (!isStaticRoot(markoRoot)) return;
+	if (!isStatic(markoRoot)) return;
 	const exportNames = getExportNames(fn, markoRoot);
 	const exportName = exportNames?.find((name) => _marko_compiler.types.isValidIdentifier(name));
 	if (!exportName) return;
@@ -1105,7 +1113,7 @@ function addBindingRefs(binding, refs, seen) {
 		const exprRoot = getExprRoot(ref);
 		const markoRoot = getMarkoRoot(exprRoot);
 		if (!markoRoot || canIgnoreRegister(markoRoot, exprRoot)) continue;
-		if (isStaticRoot(markoRoot)) getStaticDeclRefs(ref, refs, seen);
+		if (isStatic(markoRoot)) getStaticDeclRefs(ref, refs, seen);
 		else refs.add(exprRoot.node.extra ??= {});
 	}
 }
@@ -1118,14 +1126,6 @@ function registerFunction(fnExtra) {
 function isMarkoAttribute(path) {
 	return path ? path.isMarkoAttribute() : false;
 }
-function isStaticRoot(path) {
-	switch (path.type) {
-		case "MarkoScriptlet": return path.node.static;
-		case "ExportDefaultDeclaration":
-		case "ExportNamedDeclaration": return true;
-		default: return false;
-	}
-}
 //#endregion
 //#region src/translator/util/cyclic-memo.ts
 function createCyclicMemo(compute, cycleAnswer) {
@@ -1680,6 +1680,7 @@ const pureDOMFunctions = /* @__PURE__ */ new Set([
 	"_const",
 	"_load_signal",
 	"_load_setup",
+	"_load_setup_var",
 	"_load_template",
 	"_load_visible_trigger",
 	"_load_event_trigger",
@@ -1749,7 +1750,8 @@ function getHTMLRuntime() {
 		_attr_class,
 		_attr_style,
 		_escape_script,
-		_escape_style
+		_escape_style,
+		escapeDoubleQuotedAttrValue
 	};
 }
 function getRuntimePath(output) {
@@ -1966,6 +1968,7 @@ var accessor_prop_exports = /* @__PURE__ */ __exportAll({
 	AbortScopes: () => "B",
 	AwaitCounter: () => "O",
 	BranchAccessor: () => "C",
+	BranchRenders: () => "BR",
 	BranchScopes: () => "D",
 	CatchContent: () => "E",
 	ClosestBranch: () => "F",
@@ -2224,7 +2227,7 @@ function getOrCreateHtmlLoadWrapped(readyId, originalIdentifier, filename, trigg
 	markoOpts.linkAssets?.onAsset("load", filename, readyId);
 	const wrappedName = generateUid(`${originalIdentifier.name ?? "tag"}_withLoadAssets`);
 	loadWrapped.set(readyId, wrappedName);
-	(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.markoScriptlet([_marko_compiler.types.variableDeclaration("const", [_marko_compiler.types.variableDeclarator(_marko_compiler.types.identifier(wrappedName), callRuntime("withLoadAssets", originalIdentifier, _marko_compiler.types.stringLiteral(readyId), triggers ? _marko_compiler.types.valueToNode(triggers) : void 0))])], true));
+	(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.markoScriptlet([_marko_compiler.types.variableDeclaration("const", [_marko_compiler.types.variableDeclarator(_marko_compiler.types.identifier(wrappedName), callRuntime("withLoadAssets", originalIdentifier, (0, _marko_compiler_babel_utils.importNamed)((0, _marko_compiler_babel_utils.getFile)(), markoOpts.linkAssets.runtime, "flush"), _marko_compiler.types.stringLiteral(readyId), triggers ? _marko_compiler.types.valueToNode(triggers) : void 0))])], true));
 	return wrappedName;
 }
 function trackImportedRegisteredFns(importDecl) {
@@ -2640,8 +2643,16 @@ function normalizeStringExpression(parts, useIife) {
 		if (exprs.length === 1 && !curStr && !strs[0]) return exprs[0];
 		strs.push(curStr);
 		if (useIife) {
-			const params = exprs.map((_, i) => _marko_compiler.types.identifier(`_w${i}`));
-			const iife = _marko_compiler.types.callExpression(_marko_compiler.types.arrowFunctionExpression(params, _marko_compiler.types.templateLiteral(strs.map((raw) => _marko_compiler.types.templateElement({ raw: escapeTemplateRaw(raw) })), params)), exprs);
+			const args = [];
+			const params = [];
+			const body = _marko_compiler.types.templateLiteral(strs.map((raw) => _marko_compiler.types.templateElement({ raw: escapeTemplateRaw(raw) })), exprs.map((expr) => {
+				if (expr.type !== "Identifier") return expr;
+				const param = _marko_compiler.types.identifier(`_w${params.length}`);
+				params.push(param);
+				args.push(expr);
+				return param;
+			}));
+			const iife = _marko_compiler.types.callExpression(_marko_compiler.types.arrowFunctionExpression(params, body), args);
 			_marko_compiler.types.addComment(iife, "leading", "@__PURE__");
 			return iife;
 		}
@@ -2960,8 +2971,8 @@ function getDeclaredBindingExpression(binding, inPlace = false) {
 	if (canonicalBinding.localOf) return getDeclaredBindingExpression(canonicalBinding.localOf, inPlace);
 	const { aliasOf: aliased, property, declaredAlias } = canonicalBinding;
 	if (binding.declared) return _marko_compiler.types.identifier(binding.name);
-	if (canonicalBinding.declared || canonicalBinding.excludeProperties !== void 0) return _marko_compiler.types.identifier(canonicalBinding.name);
-	if (declaredAlias && declaredAlias.excludeProperties === void 0 && !getNearestDeclared(canonicalBinding)) return _marko_compiler.types.identifier(declaredAlias.name);
+	if (canonicalBinding.declared || isRest(canonicalBinding)) return _marko_compiler.types.identifier(canonicalBinding.name);
+	if (declaredAlias && !isRest(declaredAlias) && !getNearestDeclared(canonicalBinding)) return _marko_compiler.types.identifier(declaredAlias.name);
 	if (!aliased) return _marko_compiler.types.identifier(canonicalBinding.name);
 	if (property !== void 0) {
 		const alias = !getNearestDeclared(aliased) && aliased.declaredAlias;
@@ -3091,7 +3102,7 @@ function translateVar(tag, initialValue, kind = "const", statements) {
 			if (binding.declared) {
 				if (binding.section === section) allPruned = false;
 				else translateAliasInSection(tag, id, binding, kind);
-			} else if (binding.excludeProperties !== void 0) translateRest(tag, id, binding, kind);
+			} else if (isRest(binding)) translateRest(tag, id, binding, kind);
 		});
 		if (allPruned) return;
 		removeUndeclared(tagVar, section);
@@ -3108,7 +3119,7 @@ function translateVar(tag, initialValue, kind = "const", statements) {
 			const changeBinding = binding.aliasOf.propertyAliases.get(changeName);
 			if (changeBinding && changeName !== changeBinding.name) {
 				const pattern = getDestructurePattern(id);
-				if (pattern) pattern.unshiftContainer("properties", _marko_compiler.types.objectProperty(_marko_compiler.types.identifier(changeName), _marko_compiler.types.identifier(changeBinding.name)));
+				if (pattern) pattern.unshiftContainer("properties", _marko_compiler.types.objectProperty(toPropertyName(changeName), _marko_compiler.types.identifier(changeBinding.name)));
 			}
 		}
 	});
@@ -3159,11 +3170,11 @@ function translateRest(tag, id, rest, kind) {
 }
 function getRestPattern(rest, id, from, shorthand) {
 	const restElement = _marko_compiler.types.restElement(id);
-	if (rest.restOffset) return _marko_compiler.types.arrayPattern([...new Array(rest.restOffset - (from.restOffset || 0)).fill(null), restElement]);
+	if (rest.restOffset !== void 0) return _marko_compiler.types.arrayPattern([...new Array(rest.restOffset - (from.restOffset || 0)).fill(null), restElement]);
 	return _marko_compiler.types.objectPattern([...toArray(rest.excludeProperties, shorthand ? (name) => name === id.name ? toExcludedProperty(name) : toShorthandExcludedProperty(name) : toExcludedProperty), restElement]);
 }
 function withRestFallback(rest, from, value) {
-	return from.nullable ? _marko_compiler.types.logicalExpression("||", value, rest.restOffset ? _marko_compiler.types.arrayExpression([]) : _marko_compiler.types.objectExpression([])) : value;
+	return from.nullable ? _marko_compiler.types.logicalExpression("||", value, rest.restOffset !== void 0 ? _marko_compiler.types.arrayExpression([]) : _marko_compiler.types.objectExpression([])) : value;
 }
 function getSectionTarget(tag, section) {
 	let target = tag;
@@ -3376,7 +3387,7 @@ function getSignalFn(signal) {
 			const aliasSignal = getSignal(alias.section, alias);
 			if (signalHasStatements(aliasSignal)) {
 				signal.forwards = push(signal.forwards, aliasSignal);
-				if (alias.excludeProperties !== void 0) {
+				if (isRest(alias)) {
 					const aliasId = _marko_compiler.types.identifier(alias.name);
 					signal.render.push(_marko_compiler.types.expressionStatement(_marko_compiler.types.callExpression(aliasSignal.identifier, [
 						scopeIdentifier,
@@ -3912,6 +3923,52 @@ function isOnlyChild(tag) {
 	return true;
 }
 //#endregion
+//#region src/translator/util/module-read.ts
+const styleImportReg = /\.(?:css(?:\.[cm]?[jt]s)?|less|s[ac]ss|styl(?:us)?|pcss|postcss)(?:\?|$)/i;
+const kModuleRead = Symbol("module read");
+/** The module read an expression is, resolved on first use: translate replaces
+* a `<style/name>` tag. */
+function getModuleRead(path, expr) {
+	return ((expr.extra ??= {})[kModuleRead] ??= resolveModuleRead(path, expr)) || void 0;
+}
+/** A module read of a stylesheet module, whose reads are class name strings. */
+function getStyleImportRead(path, expr) {
+	const moduleRead = getModuleRead(path, expr);
+	if (moduleRead && (moduleRead.request === void 0 || styleImportReg.test(moduleRead.request))) return moduleRead.read;
+}
+function toModuleReadExpression([name, ...members]) {
+	let expr = _marko_compiler.types.identifier(name);
+	for (const member of members) expr = _marko_compiler.types.memberExpression(expr, _marko_compiler.types.identifier(member));
+	return expr;
+}
+function resolveModuleRead(path, expr) {
+	switch (expr.type) {
+		case "Identifier": {
+			const decl = path.scope.getBinding(expr.name)?.path;
+			const importDecl = decl?.parentPath;
+			if (importDecl?.isImportDeclaration()) {
+				const scriptlet = importDecl.parentPath;
+				return scriptlet.isMarkoScriptlet() && scriptlet.node.target ? null : {
+					read: [expr.name],
+					request: importDecl.node.source.value
+				};
+			}
+			return decl && isCoreTagName(decl, "style") && decl.node.var.type === "Identifier" ? {
+				read: [expr.name],
+				request: void 0
+			} : null;
+		}
+		case "MemberExpression": {
+			const object = !expr.computed && getModuleRead(path, expr.object);
+			return object ? {
+				read: [...object.read, expr.property.name],
+				request: object.request
+			} : null;
+		}
+	}
+	return null;
+}
+//#endregion
 //#region src/translator/util/structure.ts
 const walkCodeToName = {
 	[32]: "get",
@@ -3958,6 +4015,12 @@ function writeTo(path) {
 		}
 	};
 }
+function writeModuleReadTo(path, read) {
+	getSection(path).structure?.push({
+		kind: ModuleRead,
+		read
+	});
+}
 function writeTextTo(path, value) {
 	if (value) getSection(path).structure?.push({
 		kind: Text,
@@ -4018,6 +4081,10 @@ function resolveStructure(section) {
 			appendLiteral(resolved.writes, op.value);
 			textEdge = "own";
 			break;
+		case ModuleRead:
+			resolved.writes.push(toModuleReadExpression(op.read), "");
+			textEdge = void 0;
+			break;
 		case Node: {
 			if (!op.binding) continue;
 			const withVar = hasScopeOffset(op.binding);
@@ -4266,11 +4333,6 @@ function assertSetupWorkFound(program, section, written) {
 	if (!section.hasSetupWork && setup && written.has(setup)) throw program.buildCodeFrameError("Marko internal error: analysis found no setup work for a section whose translation produced setup statements. Please open an issue with a reproduction.");
 }
 //#endregion
-//#region src/translator/util/is-static.ts
-function isStatic(path) {
-	return path.isImportDeclaration() || path.isExportDeclaration() || path.isMarkoScriptlet({ static: true });
-}
-//#endregion
 //#region src/translator/visitors/program/html.ts
 function getTemplateContentName() {
 	return getSharedUid("content");
@@ -4758,7 +4820,7 @@ var custom_tag_default = {
 		if (childSection === programSection && getOrCreateSection(tag) === programSection) throw tag.get("name").buildCodeFrameError(`A template that renders itself outside a branch never terminates. Render \`<${getStaticTagName(tag.node)}>\` inside a branch that eventually stops, such as \`<if>\`.`);
 		if (childExtra.page) programExtra.page ??= true;
 		if (tagExtra.tagNameLoad) tagExtra[kLoadTagBinding] = createBinding("#text", 0, getOrCreateSection(tag));
-		knownTagAnalyze(tag, childSection, programSection === childSection ? programSection.params && getBindingPropTree(programSection.params) : childExtra.paramsTree);
+		knownTagAnalyze(tag, childSection, childExtra.paramsTree);
 		const tagName = getStaticTagName(tag.node);
 		if (tagExtra.tagNameLoad) {
 			marker(tag, tagExtra[kLoadTagBinding]);
@@ -4804,6 +4866,7 @@ function translateDOM$1(tag) {
 	const isLoad = !!loadConfig;
 	const tagName = getStaticTagName(node);
 	if (isLoad) {
+		if (node.var) importRuntimeFeature("dynamic-tag-var");
 		const childFileName = childFile.opts.filename;
 		const { triggers, signals, setups } = getLoadIdentifiers();
 		let triggerIdent = triggers.get(loadConfig);
@@ -4826,14 +4889,14 @@ function translateDOM$1(tag) {
 			}
 			return signalIdent;
 		}, (section, childBinding) => {
-			const setupKey = `${triggerIdent ? triggerIdent.name : ""}\0${childFileName}`;
+			const setupKey = `${triggerIdent ? triggerIdent.name : ""}\0${childFileName}${node.var ? "\0var" : ""}`;
 			let setupIdent = setups.get(setupKey);
 			if (!setupIdent) {
 				setupIdent = generateUidIdentifier(`load_${tagName}_setup`);
 				setups.set(setupKey, setupIdent);
 				const setupLoadExpr = _marko_compiler.types.arrowFunctionExpression([], dynamicImport(buildLoadSetupVirtualModule(file, childFileName, childExports)));
 				importRuntimeFeature("catch");
-				(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.variableDeclaration("let", [_marko_compiler.types.variableDeclarator(setupIdent, callRuntime("_load_setup", triggerIdent ? _marko_compiler.types.addComment(_marko_compiler.types.callExpression(triggerIdent, [setupLoadExpr]), "leading", "@__PURE__") : setupLoadExpr))]));
+				(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.variableDeclaration("let", [_marko_compiler.types.variableDeclarator(setupIdent, callRuntime(node.var ? "_load_setup_var" : "_load_setup", triggerIdent ? _marko_compiler.types.addComment(_marko_compiler.types.callExpression(triggerIdent, [setupLoadExpr]), "leading", "@__PURE__") : setupLoadExpr))]));
 			}
 			addStatement("render", section, void 0, _marko_compiler.types.expressionStatement(_marko_compiler.types.callExpression(setupIdent, [
 				scopeIdentifier,
@@ -5236,6 +5299,7 @@ var program_default = {
 		},
 		exit(program) {
 			if (hasAnalyzeErrors()) return;
+			analyzeRecursiveTags();
 			finalizeReferences();
 			const programExtra = program.node.extra;
 			const paramsBinding = programExtra.binding;
@@ -5786,33 +5850,51 @@ const [getKnownTags] = createSectionState("known tags", () => []);
 const kContentSection = Symbol("known tag content section");
 const kPropTree = Symbol("known tag prop tree");
 const kKnownExprs = Symbol("known tag exprs");
-function knownTagAnalyze(tag, contentSection, propTree) {
+const [getRecursiveTags] = createProgramState(() => []);
+function knownTagAnalyze(tag, contentSection, childParamsTree) {
 	analyzeAttributeTags(tag);
 	const section = getOrCreateSection(tag);
 	const tagBody = tag.get("body");
 	const tagExtra = tag.node.extra ??= {};
-	const childScopeBinding = tagExtra.nodeBinding = createBinding("#childScope", 0, section);
-	const attrExprs = /* @__PURE__ */ new Set([tagExtra]);
+	tagExtra.nodeBinding = createBinding("#childScope", 0, section);
 	startSection(tagBody);
 	trackParamsReferences(tagBody, 2);
 	getKnownTags(section).push(tagExtra);
 	tagExtra[kContentSection] = contentSection;
-	tagExtra[kPropTree] = propTree;
-	if (contentSection.program === section.program) contentSection.callSections = sectionUtil.add(contentSection.callSections, section);
 	const varBinding = trackVarReferences(tag, 4);
-	const exprs = tagExtra[kKnownExprs] = analyzeParams(tagExtra, section, tag, propTree, attrExprs);
-	setTagDerivedFrom(tag, propTree?.props?.[0]?.binding, exprs);
+	const recursive = isSameOrChildSection(contentSection, section);
+	let exprs;
+	if (contentSection.program === section.program) {
+		contentSection.callSections = sectionUtil.add(contentSection.callSections, section);
+		if (recursive) getRecursiveTags().push(tag);
+		else exprs = analyzeKnownTagParams(tag, getParamsTree(contentSection));
+	} else exprs = analyzeKnownTagParams(tag, childParamsTree);
 	if (varBinding) {
 		addSetupExpr(section);
 		const mutatesTagVar = !!(tag.node.var.type === "Identifier" && tag.scope.getBinding(tag.node.var.name)?.constantViolations.length);
-		const varExpr = isSameOrChildSection(contentSection, section) || (tagExtra.defineBodySection ? contentSection.returnValueExpr : mapParamReasonToExpr(exprs, getReturnParams(contentSection)));
+		const varExpr = recursive || (tagExtra.defineBodySection ? contentSection.returnValueExpr : mapParamReasonToExpr(exprs, getReturnParams(contentSection)));
+		const childScopeBinding = tagExtra.nodeBinding;
 		varBinding.returnedBy = childScopeBinding;
 		reserveId(childScopeBinding, 1);
 		setDerivedFrom(varBinding, varExpr);
 		if (mutatesTagVar || varExpr === true) addReason(getSlot(childScopeBinding), ALWAYS);
 		if (varExpr !== true) addReasonExprs(getSlot(childScopeBinding), varExpr);
 	}
-	addReasonExprs(getSlot(childScopeBinding), fromIter(attrExprs));
+}
+function analyzeRecursiveTags() {
+	for (const tag of getRecursiveTags()) analyzeKnownTagParams(tag, getParamsTree(tag.node.extra[kContentSection]));
+}
+function getParamsTree(contentSection) {
+	return contentSection.params && getBindingPropTree(contentSection.params, true);
+}
+function analyzeKnownTagParams(tag, propTree) {
+	const tagExtra = tag.node.extra;
+	const attrExprs = /* @__PURE__ */ new Set([tagExtra]);
+	tagExtra[kPropTree] = propTree;
+	const exprs = tagExtra[kKnownExprs] = analyzeParams(tagExtra, getSection(tag), tag, propTree, attrExprs);
+	setTagDerivedFrom(tag, propTree?.props?.[0]?.binding, exprs);
+	addReasonExprs(getSlot(tagExtra.nodeBinding), fromIter(attrExprs));
+	return exprs;
 }
 function getReturnParams(section) {
 	const sources = section.returnValueExpr && getSourcesForExpr(section.returnValueExpr);
@@ -6609,19 +6691,23 @@ function addValueReferences(refs, expr) {
 	return isReferencedExtra(getCanonicalExtra(expr)) && !expr.initialValue ? bindingUtil.union(refs, getReferencedBindings(expr)) : refs;
 }
 function getWalkedBinding(op) {
-	return typeof op === "object" && op.kind !== "text" ? op.binding : void 0;
+	return typeof op === "object" && (op.kind === "node" || op.kind === "child") ? op.binding : void 0;
 }
 function getLastOwnSourceReturn(intersection, section) {
-	let returnedBy;
-	for (const binding of intersection) if (binding.section === section && binding.sources) {
-		returnedBy = reduce(binding.sources.state, lastReturnedBy, returnedBy);
-		returnedBy = reduce(binding.sources.param, lastReturnedBy, returnedBy);
-	}
-	return returnedBy;
-}
-function lastReturnedBy(last, source) {
-	const { returnedBy } = source;
-	return returnedBy && (!last || last.id < returnedBy.id) ? returnedBy : last;
+	let last;
+	const seen = /* @__PURE__ */ new Set();
+	const track = (binding) => {
+		if (binding.section === section && !seen.has(binding)) {
+			seen.add(binding);
+			const { returnedBy } = getAliasRoot(binding) || binding;
+			if (returnedBy && (!last || last.id < returnedBy.id)) last = returnedBy;
+			if (binding.derivedFrom) forEach(getValueReferences(binding.derivedFrom), track);
+			forEach(binding.sources?.state, track);
+			forEach(binding.sources?.param, track);
+		}
+	};
+	forEach(intersection, track);
+	return last;
 }
 function getIntersectionSource(intersection, section, resolved) {
 	if (!resolved.has(intersection)) {
@@ -6665,11 +6751,6 @@ function resolveBindingSources(binding) {
 			binding.sources = globalSources;
 			return;
 	}
-	if (binding.localOf) {
-		resolveBindingSources(binding.localOf);
-		binding.sources = binding.localOf.sources;
-		return;
-	}
 	const aliasRoot = getAliasRoot(binding);
 	if (aliasRoot) {
 		if (!resolvedSources.has(aliasRoot)) {
@@ -6715,18 +6796,20 @@ function pruneBinding(binding) {
 	binding.pruned = false;
 	for (const read of binding.reads.keys()) if (isDroppableValue(read)) forEach(read.derives, pruneBinding);
 	forEach(binding.assignments, pruneWriter);
+	const assignedObject = getAssignedObject(binding);
 	for (const [expr, reads] of binding.reads) {
-		const owner = getReadOwner(binding.aliasOf, expr);
+		const owner = assignedObject ? getReadOwner(assignedObject, expr) || assignedObject : getReadOwner(binding.aliasOf, expr);
 		if (owner) {
 			owner.reads.set(expr, concat(owner.reads.get(expr), reads));
 			binding.reads.delete(expr);
 		}
 	}
-	let shouldPrune = !binding.reads.size && !(binding.reserveSize && some(binding.assignments, inEmittedExpr));
+	let shouldPrune = true;
 	for (const alias of binding.aliases) if (pruneBinding(alias)) binding.aliases.delete(alias);
 	else if (alias.type !== 5) shouldPrune = false;
 	for (const [key, alias] of binding.propertyAliases) if (pruneBinding(alias)) binding.propertyAliases.delete(key);
 	else if (alias.type !== 5) shouldPrune = false;
+	shouldPrune &&= !binding.reads.size && !(binding.reserveSize && some(binding.assignments, inEmittedExpr));
 	binding.pruned = shouldPrune;
 	if (shouldPrune && !hasEmittedAssignment(binding)) {
 		if (binding.derivedFrom) forEach(binding.derivedFrom, dropUnreadValue);
@@ -7441,7 +7524,7 @@ function getOrCreateLocalClosure(local, section) {
 	while (section.parent !== local.section) section = section.parent;
 	let closure = local.localClosures?.get(section);
 	if (!closure) {
-		closure = createBinding(local.name, 4, section, void 0, void 0, void 0, local.loc);
+		closure = createBinding(local.name, 2, section, void 0, void 0, void 0, local.loc);
 		closure.localOf = local;
 		(local.localClosures ??= /* @__PURE__ */ new Map()).set(section, closure);
 	}
@@ -7462,6 +7545,7 @@ function trackDomVarReferences(tag, binding) {
 	binding.originalName = tagVar.name;
 	if (babelBinding.constantViolations.length) for (const ref of babelBinding.constantViolations) throw ref.type === "MarkoTag" ? ref.get("var").buildCodeFrameError(`Duplicate declaration of \`${binding.originalName}\`.`) : ref.buildCodeFrameError(`\`${binding.originalName}\` is a [tag variable](https://markojs.com/docs/reference/language#tag-variables) on a native element (an element reference) and cannot be assigned to.`);
 	for (const ref of babelBinding.referencePaths) {
+		assertReferencedInRender(ref, tagVar.name);
 		const refSection = getOrCreateSection(ref);
 		const invoked = isInvokedFunction(ref);
 		const hoisted = isReferenceHoisted(babelBinding.path, ref) ? getCommonSection(refSection, binding.section) : false;
@@ -7485,7 +7569,7 @@ function trackVarReferences(tag, type, aliased) {
 		let target = aliased && getCanonicalBinding(aliased);
 		if (target) {
 			const { excludeProperties, restOffset } = target;
-			if (excludeProperties !== void 0) target = target.aliasOf;
+			if (isRest(target)) target = target.aliasOf;
 			createBindingsAndTrackReferences(tagVar, target.type, tag.scope, section, target, void 0, excludeProperties, restOffset, false);
 			return target;
 		}
@@ -7503,6 +7587,7 @@ function trackParamsReferences(body, type) {
 		if (bodySection) bodySection.params = paramsBinding;
 		for (let i = 0; i < params.length; i++) {
 			const param = params[i];
+			if (param.type === "RestElement") assertRestNotAssigned(body.scope, param.argument);
 			if (i === 0 && param.type === "RestElement" && param.argument.type === "Identifier") {
 				const { argument } = param;
 				paramsBinding.name = argument.name;
@@ -7544,9 +7629,10 @@ function isReferenceHoisted(bindingPath, reference) {
 function trackReferencesForBinding(babelBinding, binding) {
 	const { referencePaths, constantViolations } = babelBinding;
 	for (const ref of referencePaths) {
-		const refSection = getOrCreateSection(ref);
 		const markoRoot = getMarkoRoot(ref);
-		if (!binding.declared && binding.excludeProperties === void 0) {
+		assertReferencedInRender(ref, ref.node.name, markoRoot);
+		const refSection = getOrCreateSection(ref);
+		if (!binding.declared && !isRest(binding)) {
 			const root = getNearestDeclared(binding);
 			binding.declared = !!root && ref.scope.getBinding(root.name) !== babelBinding.scope.getBinding(root.name);
 		}
@@ -7573,6 +7659,7 @@ function trackReferencesForBinding(babelBinding, binding) {
 	}
 	for (const ref of constantViolations) {
 		if (ref.type === "MarkoTag") throw ref.get("var").buildCodeFrameError(`Duplicate declaration of \`${binding.name}\`.`);
+		assertReferencedInRender(ref, binding.name);
 		if (isReferenceHoisted(babelBinding.path, ref)) throw ref.buildCodeFrameError(`\`${binding.name}\` is declared by a tag below this assignment; a [tag variable](https://markojs.com/docs/reference/language#tag-variables) can only be assigned below its declaration. Move the declaring tag above this code.`);
 		if (ref.isUpdateExpression()) trackAssignment(ref.get("argument"), binding);
 		else if (ref.isAssignmentExpression()) {
@@ -7588,6 +7675,8 @@ function trackAssignment(assignment, binding) {
 	const fnParent = getFnParent(assignment);
 	if (!fnParent) throw assignment.buildCodeFrameError(`\`${binding.name}\` is a tag ${binding.type === 2 ? "parameter" : "variable"} and can only be assigned within a script or function.`);
 	if (binding.type === 3) throw assignment.buildCodeFrameError(`\`${binding.name}\` is a tag parameter and cannot be assigned to.`);
+	let assigned = binding;
+	while (isDirectAlias(assigned)) assigned = assigned.aliasOf;
 	const fnRoot = getFnRoot(fnParent);
 	const fnExtra = fnRoot && (fnRoot.node.extra ??= {});
 	const section = getOrCreateSection(assignment);
@@ -7595,7 +7684,7 @@ function trackAssignment(assignment, binding) {
 	forEachIdentifierPath(assignment, (id) => {
 		if (id.node.name === binding.name) {
 			const idExtra = id.node.extra ??= {};
-			idExtra.assignment = binding;
+			idExtra.assignment = assigned;
 			idExtra.section = section;
 			idExtra.exprRoot = getExprRoot(fnRoot || assignment).node.extra ??= {};
 			idExtra.fnRoot = fnExtra;
@@ -7604,16 +7693,19 @@ function trackAssignment(assignment, binding) {
 				fnExtra.section = section;
 				fnExtra.exprRoot = idExtra.exprRoot;
 			}
-			if (binding.aliasOf && binding.property !== void 0) {
-				if (binding.aliasOf === binding.section.params) throw assignment.buildCodeFrameError(`\`${binding.name}\` is a tag parameter and cannot be assigned to.`);
-				const changePropName = binding.property + "Change";
-				const changeBinding = binding.aliasOf.propertyAliases.get(changePropName) || createBinding(generateUid(changePropName), binding.type, binding.section, binding.aliasOf, changePropName, void 0, id.node.loc, binding.declared);
+			if (assigned.aliasOf && assigned.property !== void 0) {
+				if (assigned.aliasOf === assigned.section.params) throw assignment.buildCodeFrameError(`\`${binding.name}\` is a tag parameter and cannot be assigned to.`);
+				const changePropName = assigned.property + "Change";
+				const changeBinding = assigned.aliasOf.propertyAliases.get(changePropName) || createBinding(generateUid(changePropName), assigned.type, assigned.section, assigned.aliasOf, changePropName, void 0, id.node.loc, assigned.declared);
 				idExtra.assignmentTo = changeBinding;
 				addReadToExpression(id, changeBinding, void 0);
 			}
 		}
 	});
 }
+function assertReferencedInRender(ref, name, markoRoot = getMarkoRoot(ref)) {
+	if (markoRoot && isStatic(markoRoot)) throw ref.buildCodeFrameError(`\`${name}\` exists only while the template renders, so module level code ([\`static\`, \`server\` and \`client\`](https://markojs.com/docs/reference/language#static) and [\`export\`](https://markojs.com/docs/reference/language#export) statements), which runs once as the template loads, cannot reference it. Reference it in the template instead, passing it to module level functions as an argument.`);
+}
 function setReferencesScope(path) {
 	const fnRoot = getFnRoot(path);
 	if (fnRoot) (fnRoot.node.extra ??= {}).referencesScope = true;
@@ -7628,8 +7720,7 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, aliased, p
 			createBindingsAndTrackReferences(lVal.left, type, scope, section, aliased, property, excludeProperties, restOffset, declared);
 			break;
 		case "Identifier": {
-			const binding = (lVal.extra ??= {}).binding = createBinding(lVal.name, type, section, aliased, property, excludeProperties, lVal.loc, declared);
-			if (restOffset) binding.restOffset = restOffset;
+			const binding = (lVal.extra ??= {}).binding = createBinding(lVal.name, type, section, aliased, property, excludeProperties, lVal.loc, declared, restOffset);
 			trackReferencesForBinding(scope.getBinding(lVal.name), binding);
 			break;
 		}
@@ -7639,8 +7730,10 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, aliased, p
 			const { properties } = lVal;
 			const hasRest = properties.length > 0 && properties[properties.length - 1].type === "RestElement";
 			const declaresPattern = declared || hasRest;
-			for (const prop of lVal.properties) if (prop.type === "RestElement") createBindingsAndTrackReferences(prop.argument, type, scope, section, patternBinding, void 0, excludeProperties, void 0, declaresPattern);
-			else {
+			for (const prop of lVal.properties) if (prop.type === "RestElement") {
+				assertRestNotAssigned(scope, prop.argument);
+				createBindingsAndTrackReferences(prop.argument, type, scope, section, patternBinding, void 0, excludeProperties, void 0, declaresPattern);
+			} else {
 				let key;
 				if (!prop.computed && prop.key.type === "Identifier") key = prop.key.name;
 				else if (prop.key.type === "StringLiteral") key = prop.key.value;
@@ -7660,6 +7753,7 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, aliased, p
 				index++;
 				if (element) {
 					if (element.type === "RestElement") {
+						assertRestNotAssigned(scope, element.argument);
 						excludeProperties = index > 0 ? addNumericPropertiesUntil(excludeProperties, index) : void 0;
 						createBindingsAndTrackReferences(element.argument, type, scope, section, patternBinding, void 0, excludeProperties, index, declaresPattern);
 					} else if (_marko_compiler.types.isLVal(element)) {
@@ -7678,16 +7772,29 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, aliased, p
 function isAssignment(ref) {
 	return ref.type !== "MarkoTag";
 }
+function assertRestNotAssigned(scope, rest) {
+	if (rest.type === "Identifier") {
+		const assignment = scope.getBinding(rest.name).constantViolations.find(isAssignment);
+		if (assignment) throw assignment.buildCodeFrameError(`\`${rest.name}\` is a rest element, which has no [change handler](https://markojs.com/docs/reference/language#shorthand-change-handlers-two-way-binding) to receive a new value, so it cannot be assigned to. Assign the properties of the value it is destructured from instead.`);
+	}
+}
 function trackReference(referencePath, binding) {
 	let root = referencePath;
 	let reference = binding;
 	while (true) {
 		const { parent } = root;
-		if (!_marko_compiler.types.isMemberExpression(parent) && !_marko_compiler.types.isOptionalMemberExpression(parent) || isWrittenMember(root.parentPath)) break;
+		if (!_marko_compiler.types.isMemberExpression(parent) && !_marko_compiler.types.isOptionalMemberExpression(parent)) break;
 		let prop = getMemberExpressionPropString(parent);
+		if (isAssignedMember(root.parentPath)) {
+			let object = reference;
+			while (isDirectAlias(object)) object = object.aliasOf;
+			if (isRest(object)) throw root.parentPath.buildCodeFrameError(`\`${referencePath.node.name}\` is a rest element, a copy rebuilt from the value it is destructured from whenever that changes, so assigning its members would be lost. Assign the property on that value instead, or keep your own copy in a \`<let>\`.`);
+			addAssignedProperty(object, prop);
+			break;
+		}
 		if (prop === void 0) break;
-		if (reference.aliasOf && reference.excludeProperties !== void 0) {
-			if (reference.restOffset) {
+		if (reference.aliasOf && isRest(reference)) {
+			if (reference.restOffset !== void 0) {
 				if (isIndexProperty(prop)) {
 					prop = `${+prop + reference.restOffset}`;
 					reference = reference.aliasOf;
@@ -7702,7 +7809,7 @@ function trackReference(referencePath, binding) {
 	(referencePath.node.extra ??= {}).binding = binding;
 	addReadToExpression(root, reference, void 0);
 }
-function isWrittenMember(member) {
+function isAssignedMember(member) {
 	const { node, parent } = member;
 	switch (parent.type) {
 		case "AssignmentExpression":
@@ -7830,7 +7937,9 @@ function untrackExtra(exprExtra) {
 	if (reads) {
 		readsByExpr.delete(exprExtra);
 		getFunctionReadsByExpression().delete(exprExtra);
-		forEach(reads, (read) => read.binding.reads.delete(exprExtra));
+		forEach(reads, (read) => {
+			for (let cur = read.binding; cur; cur = cur.aliasOf) cur.reads.delete(exprExtra);
+		});
 	}
 }
 function dropContent(body) {
@@ -7990,7 +8099,7 @@ function getKnownExprsAt(exprs, binding) {
 //#region src/translator/util/bindings.ts
 const [getBindings] = createProgramState(() => /* @__PURE__ */ new Set());
 const [getNextBindingId, setNextBindingId] = createProgramState(() => 0);
-function createBinding(name, type, refSection, aliased, property, excludeProperties, loc = null, refDeclared = false) {
+function createBinding(name, type, refSection, aliased, property, excludeProperties, loc = null, refDeclared = false, restOffset) {
 	const id = getNextBindingId();
 	const section = aliased ? aliased.section : refSection;
 	const sameSection = refSection === section;
@@ -8009,6 +8118,7 @@ function createBinding(name, type, refSection, aliased, property, excludePropert
 		closureId: void 0,
 		assignments: void 0,
 		excludeProperties,
+		assignedProperties: void 0,
 		sources: void 0,
 		intersection: void 0,
 		derivedFrom: void 0,
@@ -8022,11 +8132,11 @@ function createBinding(name, type, refSection, aliased, property, excludePropert
 		declaredAlias: void 0,
 		localOf: void 0,
 		localClosures: void 0,
-		restOffset: void 0,
+		restOffset,
 		returnedBy: void 0,
 		reserveSize: 0,
 		scopeAccessor: void 0,
-		nullable: !sameSection || excludeProperties === void 0,
+		nullable: !sameSection || excludeProperties === void 0 && restOffset === void 0,
 		pruned: void 0,
 		exposed: false,
 		hasLazyReads: false
@@ -8053,6 +8163,18 @@ function getOrCreatePropertyAlias(binding, property) {
 	while (isDirectAlias(binding)) binding = binding.aliasOf;
 	return binding.propertyAliases.get(property) || createBinding(`${binding.name}_${property.replace(/[^a-zA-Z0-9_$]/g, "_")}`, binding.type, binding.section, binding, property);
 }
+function addAssignedProperty(binding, property) {
+	if (binding.assignedProperties !== true) binding.assignedProperties = property === void 0 || propsUtil.add(binding.assignedProperties, property);
+}
+function getAssignedObject(binding) {
+	let object;
+	for (let alias = binding; alias.aliasOf && !isRest(alias); alias = alias.aliasOf) if (alias.property !== void 0) {
+		let parent = alias.aliasOf;
+		while (isDirectAlias(parent)) parent = parent.aliasOf;
+		if (parent.assignedProperties === true || propsUtil.has(parent.assignedProperties, alias.property)) object = alias.aliasOf;
+	}
+	return object;
+}
 function getPropertyAlias(binding, properties) {
 	return reduce(properties, getExistingPropertyAlias, binding);
 }
@@ -8111,12 +8233,15 @@ function getNearestDeclared(binding) {
 	for (let cur = binding; cur; cur = cur.aliasOf) if (cur.declared) return cur;
 }
 function isDirectAlias(binding) {
-	return binding.aliasOf !== void 0 && binding.property === void 0 && binding.excludeProperties === void 0;
+	return binding.aliasOf !== void 0 && binding.property === void 0 && !isRest(binding);
+}
+function isRest(binding) {
+	return binding.excludeProperties !== void 0 || binding.restOffset !== void 0;
 }
 function getDebugScopeAccess(binding) {
 	let root = binding;
 	let access = "";
-	while (!(root.loc || root.declared) && root.aliasOf && root.excludeProperties === void 0) {
+	while (!(root.loc || root.declared) && root.aliasOf && !isRest(root)) {
 		if (root.property !== void 0) access = toAccess(root.property) + access;
 		root = root.aliasOf;
 	}
@@ -8132,7 +8257,7 @@ function getDebugName(binding) {
 	if (isTemplateParam(binding)) {
 		let root = binding;
 		let access = "";
-		while (root.aliasOf !== root.section.params && root.excludeProperties === void 0) {
+		while (root.aliasOf !== root.section.params && !isRest(root)) {
 			if (root.property !== void 0) access = toAccess(root.property) + access;
 			root = root.aliasOf;
 		}
@@ -8150,11 +8275,11 @@ function getDebugNamesAsIdentifier(refs) {
 function getDebugNameAsIdentifier(binding) {
 	let root = binding;
 	let access = "";
-	if (isTemplateParam(binding)) while (root.aliasOf !== root.section.params && root.excludeProperties === void 0) {
+	if (isTemplateParam(binding)) while (root.aliasOf !== root.section.params && !isRest(root)) {
 		if (root.property !== void 0) access = `_${root.property.replace(/[^a-z0-9_$]/gi, "_") + access}`;
 		root = root.aliasOf;
 	}
-	else while (!(root.loc || root.declared) && root.aliasOf && root.excludeProperties === void 0) {
+	else while (!(root.loc || root.declared) && root.aliasOf && !isRest(root)) {
 		if (root.property !== void 0) access = `_${root.property.replace(/[^a-z0-9_$]/gi, "_") + access}`;
 		root = root.aliasOf;
 	}
@@ -8164,7 +8289,7 @@ function isInvokeOnlyBinding(binding) {
 	return !someAlias(binding, isReadBeyondInvoking, void 0);
 }
 function isReadBeyondInvoking(binding) {
-	if (binding.assignments || binding.hoists || binding.getters.size || binding.propertyAliases.size || binding.excludeProperties) return true;
+	if (binding.assignments || binding.hoists || binding.getters.size || binding.propertyAliases.size || isRest(binding)) return true;
 	for (const expr of binding.reads.keys()) if (!expr.invokeOnly) return true;
 	return false;
 }
@@ -9878,9 +10003,11 @@ var referenced_identifier_default = {
 		const { name } = identifier.node;
 		if (identifier.scope.hasBinding(name)) return;
 		if (name === "$global") {
+			assertReferencedInRender(identifier, name);
 			setReferencesScope(identifier);
 			trackGlobalReference(identifier);
 		} else if (name === "$signal") {
+			assertReferencedInRender(identifier, name);
 			const section = getOrCreateSection(identifier);
 			section.hasAbortSignal = true;
 			setReferencesScope(identifier);
@@ -10063,7 +10190,7 @@ var native_tag_default = {
 					} else {
 						assertValidNativeEventHandlerAttr(tag, attr);
 						if (isChangeHandlerAttr) valueExtra.retained = true;
-						if (!evaluate(attr.value).confident) {
+						if (!isStaticDelimitedAttr(tag, attr) && !evaluate(attr.value).confident) {
 							hasDynamicAttributes = true;
 							addSetupExpr(tagSection, attr.value);
 						} else if (attr.name === "content" && tagName !== "meta") addSetupExpr(tagSection, attr.value);
@@ -10137,13 +10264,21 @@ var native_tag_default = {
 				const { confident, computed } = evaluate(value);
 				if (confident) write`${getStaticAttrMarkup(name, computed)}`;
 				else if (name === "class" || name === "style") {
-					const meta = {
-						staticItems: void 0,
-						dynamicItems: void 0,
-						dynamicValues: void 0
-					};
-					trackDelimitedAttrValue(value, meta);
-					if (!meta.dynamicItems && meta.staticItems) write`${getStaticAttrMarkup(name, meta.staticItems)}`;
+					const meta = trackDelimitedAttrValue(tag, name, value);
+					const { staticParts } = meta;
+					if (getDelimitedAttrItems(name, meta) && staticParts.length) {
+						if (staticParts.every(isLiteralPart)) write`${getStaticAttrMarkup(name, staticParts)}`;
+						else {
+							write` class="`;
+							for (let i = 0; i < staticParts.length; i++) {
+								const part = staticParts[i];
+								if (i) write` `;
+								if (isLiteralPart(part)) write`${getHTMLRuntime().escapeDoubleQuotedAttrValue(part)}`;
+								else writeModuleReadTo(tag, part);
+							}
+							write`"`;
+						}
+					}
 				}
 			}
 			write`>`;
@@ -10245,7 +10380,7 @@ var native_tag_default = {
 						write`${callRuntime("_attr_option_value", value)}`;
 						continue;
 					}
-					write`${confident ? getStaticAttrMarkup(name, computed) : factorAttrConditional(buildAttrExpression(name, value))}`;
+					write`${confident ? getStaticAttrMarkup(name, computed) : factorAttrConditional(buildAttrExpression(tag, name, value))}`;
 				}
 				if (handlers) for (const index of handlers) addHTMLEffectCall(tagSection, getReferencedBindings(attributes[index].value.extra));
 				const isOpenOnly = !!(tagDef && tagDef.parseOptions?.openTagOnly);
@@ -10332,37 +10467,27 @@ var native_tag_default = {
 					const valueReferences = getReferencedBindings(value.extra);
 					switch (name) {
 						case "class":
-						case "style": {
-							const helper = `_attr_${name}`;
+						case "style":
 							if (!confident) {
-								const nodeExpr = createScopeReadExpression(nodeBinding);
-								const meta = {
-									staticItems: void 0,
-									dynamicItems: void 0,
-									dynamicValues: void 0
-								};
-								let stmt;
-								trackDelimitedAttrValue(value, meta);
-								if (meta.dynamicItems) stmt = _marko_compiler.types.expressionStatement(callRuntime(helper, nodeExpr, value));
-								else if (meta.dynamicValues) {
-									const keys = Object.keys(meta.dynamicValues);
-									if (keys.length === 1) {
-										const [key] = keys;
-										const value = meta.dynamicValues[key];
-										stmt = _marko_compiler.types.expressionStatement(callRuntime(`_attr_${name}_item`, nodeExpr, _marko_compiler.types.stringLiteral(key), value));
-									} else {
-										const props = [];
-										for (const key of keys) {
-											const value = meta.dynamicValues[key];
-											props.push(_marko_compiler.types.objectProperty(toPropertyName(key), value));
-										}
-										stmt = _marko_compiler.types.expressionStatement(callRuntime(`_attr_${name}_items`, nodeExpr, _marko_compiler.types.objectExpression(props)));
-									}
+								const meta = trackDelimitedAttrValue(tag, name, value);
+								const items = getDelimitedAttrItems(name, meta);
+								const calls = [];
+								const assert = buildClassTogglesAssert(meta);
+								if (assert) calls.push(assert);
+								if (!items) calls.push(callRuntime(`_attr_${name}`, createScopeReadExpression(nodeBinding), value));
+								else {
+									const single = [];
+									for (const { key, value } of items) if (isLiteralPart(key) && !/\s/.test(key)) single.push({
+										key,
+										value
+									});
+									else calls.push(callRuntime("_attr_class_names", createScopeReadExpression(nodeBinding), toClassPartExpression(key), value));
+									if (single.length === 1) calls.push(callRuntime(`_attr_${name}_item`, createScopeReadExpression(nodeBinding), _marko_compiler.types.stringLiteral(single[0].key), single[0].value));
+									else if (single.length) calls.push(callRuntime(`_attr_${name}_items`, createScopeReadExpression(nodeBinding), _marko_compiler.types.objectExpression(single.map(({ key, value }) => _marko_compiler.types.objectProperty(toPropertyName(key), value)))));
 								}
-								if (stmt) addStatement("render", tagSection, valueReferences, stmt, true);
+								for (const call of calls) addStatement("render", tagSection, valueReferences, _marko_compiler.types.expressionStatement(call), true);
 							}
 							break;
-						}
 						default: if (confident) break;
 						else addStatement("render", tagSection, valueReferences, _marko_compiler.types.expressionStatement(callRuntime("_attr", createScopeReadExpression(nodeBinding), _marko_compiler.types.stringLiteral(name), value)), true);
 					}
@@ -10637,13 +10762,13 @@ function getStaticAttrMarkup(name, computed) {
 		default: return getHTMLRuntime()._attr(name, computed);
 	}
 }
-function buildAttrExpression(name, value) {
-	if (value.type === "ConditionalExpression") return _marko_compiler.types.conditionalExpression(value.test, buildAttrExpression(name, value.consequent), buildAttrExpression(name, value.alternate));
+function buildAttrExpression(tag, name, value) {
+	if (value.type === "ConditionalExpression") return _marko_compiler.types.conditionalExpression(value.test, buildAttrExpression(tag, name, value.consequent), buildAttrExpression(tag, name, value.alternate));
 	const { confident, computed } = evaluate(value);
 	if (confident) return _marko_compiler.types.stringLiteral(getStaticAttrMarkup(name, computed));
 	switch (name) {
-		case "class": return buildStringAttrAnd(name, value) || buildClassAttrExpression(value) || callRuntime("_attr_class", value);
-		case "style": return buildStringAttrAnd(name, value) || callRuntime("_attr_style", value);
+		case "class": return buildClassAttrExpression(tag, value) || callRuntime("_attr_class", value);
+		case "style": return buildStyleAttrAnd(value) || callRuntime("_attr_style", value);
 		default: return buildLogicalAttr(name, value) || callRuntime("_attr", _marko_compiler.types.stringLiteral(name), value);
 	}
 }
@@ -10677,105 +10802,198 @@ function buildLogicalAttr(name, value) {
 	const attr = getHTMLRuntime()._attr(name, computed);
 	return callRuntime(value.operator === "&&" ? "_attr_and" : value.operator === "||" ? "_attr_or" : "_attr_nullish", _marko_compiler.types.stringLiteral(name), value.left, _marko_compiler.types.stringLiteral(attr));
 }
-function buildStringAttrAnd(name, value) {
+function buildStyleAttrAnd(value) {
 	if (value.type === "LogicalExpression" && value.operator === "&&") {
 		const { confident, computed } = evaluate(value.right);
-		if (confident) return _marko_compiler.types.conditionalExpression(value.left, _marko_compiler.types.stringLiteral(getStaticAttrMarkup(name, computed)), _marko_compiler.types.stringLiteral(""));
+		if (confident) return _marko_compiler.types.conditionalExpression(value.left, _marko_compiler.types.stringLiteral(getStaticAttrMarkup("style", computed)), _marko_compiler.types.stringLiteral(""));
 	}
 }
 const MAX_PRECOMPUTED_CLASS_TOGGLES = 4;
-function buildClassAttrExpression(value) {
-	if (value.type !== "ObjectExpression" && value.type !== "ArrayExpression") return;
+function buildClassAttrExpression(tag, value) {
+	const meta = trackDelimitedAttrValue(tag, "class", value);
+	if (meta.dynamic) return;
+	const markup = buildClassMarkup(meta);
+	const assert = markup && buildClassTogglesAssert(meta);
+	return assert ? _marko_compiler.types.sequenceExpression([assert, markup]) : markup;
+}
+function buildClassMarkup({ staticParts, dynamicValues = [] }) {
+	if (dynamicValues.length > MAX_PRECOMPUTED_CLASS_TOGGLES) {
+		if (staticParts.length) return callRuntime("_attr_class", buildClassString(staticParts, dynamicValues));
+		return;
+	}
+	const combos = [];
+	for (let mask = 0; mask < 1 << dynamicValues.length; mask++) {
+		const parts = [...staticParts];
+		for (let i = 0; i < dynamicValues.length; i++) {
+			const { key, alternate } = dynamicValues[i];
+			const part = mask & 1 << i ? key : alternate;
+			if (part) parts.push(part);
+		}
+		combos.push(parts);
+	}
+	if (combos.every((parts) => parts.every(isLiteralPart))) return buildPrecomputedClass(combos.map((parts) => getHTMLRuntime()._attr_class(parts.join(" "))), dynamicValues);
+	const table = getHoistedClassMarkup(combos);
+	return dynamicValues.length ? _marko_compiler.types.memberExpression(table, buildToggleIndex(dynamicValues), true) : table;
+}
+function buildPrecomputedClass(combos, toggles) {
+	if (!toggles.length) return _marko_compiler.types.stringLiteral(combos[0]);
+	if (toggles.length === 1) return _marko_compiler.types.conditionalExpression(toggles[0].value, _marko_compiler.types.stringLiteral(combos[1]), _marko_compiler.types.stringLiteral(combos[0]));
+	const end = commonAttrPrefixEnd(combos);
+	const table = generateUidIdentifier("class");
+	(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.markoScriptlet([_marko_compiler.types.variableDeclaration("const", [_marko_compiler.types.variableDeclarator(table, _marko_compiler.types.arrayExpression(combos.map((combo) => _marko_compiler.types.stringLiteral(combo.slice(end)))))])], true));
+	const lookup = _marko_compiler.types.memberExpression(_marko_compiler.types.cloneNode(table), buildToggleIndex(toggles), true);
+	return normalizeStringExpression([combos[0].slice(0, end), lookup]);
+}
+const [getHoistedClassMarkups] = createProgramState(() => /* @__PURE__ */ new Map());
+function getHoistedClassMarkup(combos) {
+	const key = JSON.stringify(combos);
+	const hoisted = getHoistedClassMarkups();
+	let id = hoisted.get(key);
+	if (!id) {
+		const markups = combos.map((parts) => parts.length ? callRuntime("_attr_class", buildClassString(parts, [])) : _marko_compiler.types.stringLiteral(""));
+		hoisted.set(key, id = generateUidIdentifier("class"));
+		(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.markoScriptlet([_marko_compiler.types.variableDeclaration("const", [_marko_compiler.types.variableDeclarator(id, markups.length === 1 ? markups[0] : _marko_compiler.types.arrayExpression(markups))])], true));
+	}
+	return _marko_compiler.types.cloneNode(id);
+}
+function buildClassTogglesAssert({ staticParts, dynamicValues }) {
+	if (isOptimize() || !dynamicValues || [...staticParts, ...dynamicValues.flatMap(({ key, alternate }) => [key, alternate])].every((part) => part === void 0 || isLiteralPart(part))) return;
+	return callRuntime("_assert_class_toggles", buildClassString(staticParts, []), _marko_compiler.types.arrayExpression(dynamicValues.map(({ key, alternate }) => buildClassString(alternate ? [key, alternate] : [key], []))));
+}
+function buildToggleIndex(toggles) {
+	let index = _marko_compiler.types.conditionalExpression(toggles[0].value, _marko_compiler.types.numericLiteral(1), _marko_compiler.types.numericLiteral(0));
+	for (let i = 1; i < toggles.length; i++) index = _marko_compiler.types.binaryExpression("+", index, _marko_compiler.types.conditionalExpression(toggles[i].value, _marko_compiler.types.numericLiteral(1 << i), _marko_compiler.types.numericLiteral(0)));
+	return index;
+}
+function buildClassString(parts, toggles) {
+	const strs = [];
+	for (let i = 0; i < parts.length; i++) {
+		if (i) strs.push(" ");
+		strs.push(toClassPartExpression(parts[i]));
+	}
+	for (const { key, value, alternate } of toggles) strs.push(_marko_compiler.types.conditionalExpression(value, toSpacedClassPart(key), toSpacedClassPart(alternate)));
+	return normalizeStringExpression(strs) || _marko_compiler.types.stringLiteral("");
+}
+function toClassPartExpression(part) {
+	return isLiteralPart(part) ? _marko_compiler.types.stringLiteral(part) : toModuleReadExpression(part);
+}
+function toSpacedClassPart(part) {
+	return part === void 0 ? _marko_compiler.types.stringLiteral("") : isLiteralPart(part) ? _marko_compiler.types.stringLiteral(" " + part) : _marko_compiler.types.binaryExpression("+", _marko_compiler.types.stringLiteral(" "), toModuleReadExpression(part));
+}
+const delimitedAttrStringify = {
+	class: [" ", stringifyClassObject],
+	style: [";", stringifyStyleObject]
+};
+function assertUniqueClassToggles(tag, attr, { staticParts, dynamicValues = [] }) {
+	const written = new Set(staticParts.flatMap(getClassNames));
+	for (const { key, alternate } of dynamicValues) {
+		const names = /* @__PURE__ */ new Set([...getClassNames(key), ...getClassNames(alternate)]);
+		for (const name of names) if (written.has(name)) throw tag.hub.buildError(attr, `The toggled class \`${name}\` is also written by another part of the \`class\` value; a toggled [class name](https://markojs.com/docs/reference/native-tag#class) may appear only once.`, Error);
+		for (const name of names) written.add(name);
+	}
+}
+function getClassNames(part) {
+	return part === void 0 ? [] : isLiteralPart(part) ? part.split(/\s+/).filter(Boolean) : [part.join(".")];
+}
+function isStaticDelimitedAttr(tag, attr) {
+	const { name, value } = attr;
+	if (name !== "class" && name !== "style") return false;
+	const meta = trackDelimitedAttrValue(tag, name, value);
+	if (name === "class") assertUniqueClassToggles(tag, attr, meta);
+	return !meta.dynamic && !meta.dynamicValues;
+}
+function getDelimitedAttrItems(name, { dynamic, dynamicValues }) {
+	if (dynamic) return;
+	const items = [];
+	if (!dynamicValues) return items;
+	const keys = /* @__PURE__ */ new Set();
+	for (const { key, value, alternate } of dynamicValues) {
+		if (alternate !== void 0 || name === "style" && (!isLiteralPart(key) || /\s/.test(key) || keys.size === keys.add(key).size)) return;
+		items.push({
+			key,
+			value
+		});
+	}
+	return items;
+}
+function isLiteralPart(part) {
+	return typeof part === "string";
+}
+function trackDelimitedAttrValue(tag, name, value) {
 	const meta = {
-		staticItems: void 0,
-		dynamicItems: void 0,
+		dynamic: false,
+		staticParts: [],
 		dynamicValues: void 0
 	};
-	trackDelimitedAttrValue(value, meta);
-	if (meta.dynamicItems || !meta.staticItems || !meta.dynamicValues) return;
-	const base = toDelimitedString(meta.staticItems, " ", stringifyClassObject);
-	if (!base) return;
-	const { _attr_class } = getHTMLRuntime();
-	const keys = Object.keys(meta.dynamicValues);
-	if (keys.length === 1) {
-		const [key] = keys;
-		return _marko_compiler.types.conditionalExpression(meta.dynamicValues[key], _marko_compiler.types.stringLiteral(_attr_class(base + " " + key)), _marko_compiler.types.stringLiteral(_attr_class(base)));
-	}
-	if (keys.length <= MAX_PRECOMPUTED_CLASS_TOGGLES) {
-		const combos = [];
-		for (let mask = 0; mask < 1 << keys.length; mask++) {
-			let classes = base;
-			for (let i = 0; i < keys.length; i++) if (mask & 1 << i) classes += " " + keys[i];
-			combos.push(_attr_class(classes));
-		}
-		const end = commonAttrPrefixEnd(combos);
-		const table = generateUidIdentifier("class");
-		(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.markoScriptlet([_marko_compiler.types.variableDeclaration("const", [_marko_compiler.types.variableDeclarator(table, _marko_compiler.types.arrayExpression(combos.map((combo) => _marko_compiler.types.stringLiteral(combo.slice(end)))))])], true));
-		let index = _marko_compiler.types.conditionalExpression(meta.dynamicValues[keys[0]], _marko_compiler.types.numericLiteral(1), _marko_compiler.types.numericLiteral(0));
-		for (let i = 1; i < keys.length; i++) index = _marko_compiler.types.binaryExpression("+", index, _marko_compiler.types.conditionalExpression(meta.dynamicValues[keys[i]], _marko_compiler.types.numericLiteral(1 << i), _marko_compiler.types.numericLiteral(0)));
-		const lookup = _marko_compiler.types.memberExpression(_marko_compiler.types.cloneNode(table), index, true);
-		return normalizeStringExpression([combos[0].slice(0, end), lookup]);
-	}
-	let classes = _marko_compiler.types.stringLiteral(base);
-	for (const key of keys) classes = _marko_compiler.types.binaryExpression("+", classes, _marko_compiler.types.conditionalExpression(meta.dynamicValues[key], _marko_compiler.types.stringLiteral(" " + key), _marko_compiler.types.stringLiteral("")));
-	return callRuntime("_attr_class", classes);
-}
-function trackDelimitedAttrValue(expr, meta) {
-	switch (expr.type) {
-		case "ObjectExpression":
-			trackDelimitedAttrObjectProperties(expr, meta);
-			break;
-		case "ArrayExpression":
-			trackDelimitedAttrArrayItems(expr, meta);
-			break;
-		default: (meta.dynamicItems ||= []).push(expr);
-	}
+	trackDelimitedAttrItem(tag, name, value, meta);
+	return meta;
 }
-function trackDelimitedAttrArrayItems(arr, meta) {
-	for (const item of arr.elements) if (item) switch (item.type) {
+function trackDelimitedAttrItem(tag, name, item, meta) {
+	switch (item.type) {
 		case "ArrayExpression":
-			trackDelimitedAttrArrayItems(item, meta);
-			break;
-		case "ObjectExpression":
-			trackDelimitedAttrObjectProperties(item, meta);
-			break;
+			for (const child of item.elements) if (child) trackDelimitedAttrItem(tag, name, child, meta);
+			return;
 		case "SpreadElement":
-			if (item.argument.type === "ArrayExpression") trackDelimitedAttrArrayItems(item.argument, meta);
-			else (meta.dynamicItems ||= []).push(item);
-			break;
-		default: {
-			const evalItem = evaluate(item);
-			if (evalItem.confident) (meta.staticItems ||= []).push(evalItem.computed);
-			else (meta.dynamicItems ||= []).push(item);
-			break;
-		}
+			if (item.argument.type === "ArrayExpression") trackDelimitedAttrItem(tag, name, item.argument, meta);
+			else meta.dynamic = true;
+			return;
+		case "ObjectExpression":
+			trackDelimitedAttrObjectProperties(tag, name, item, meta);
+			return;
 	}
-}
-function trackDelimitedAttrObjectProperties(obj, meta) {
-	let staticProps;
-	let dynamicProps;
+	const part = getDelimitedAttrPart(tag, name, item);
+	if (part !== void 0) {
+		if (part) meta.staticParts.push(part);
+	} else if (name === "class" && item.type === "LogicalExpression") {
+		const key = item.operator === "&&" && getDelimitedAttrPart(tag, name, item.right);
+		if (key) addDynamicValue(meta, key, item.left, void 0);
+		else meta.dynamic = true;
+	} else if (name === "class" && item.type === "ConditionalExpression") {
+		const key = getDelimitedAttrPart(tag, name, item.consequent);
+		const alternate = getDelimitedAttrPart(tag, name, item.alternate);
+		if (key && alternate !== void 0) addDynamicValue(meta, key, item.test, alternate || void 0);
+		else meta.dynamic = true;
+	} else meta.dynamic = true;
+}
+function trackDelimitedAttrObjectProperties(tag, name, obj, meta) {
 	for (const prop of obj.properties) {
-		if (prop.type !== "ObjectProperty" || prop.computed) {
-			(dynamicProps ||= []).push(prop);
-			continue;
-		}
-		let key;
-		if (prop.key.type === "Identifier") key = prop.key.name;
-		else {
-			const keyEval = evaluate(prop.key);
-			if (keyEval.confident && typeof keyEval.computed === "string" && !/^$|\s/.test(keyEval.computed)) key = keyEval.computed + "";
-			else {
-				(dynamicProps ||= []).push(prop);
-				continue;
-			}
+		const key = prop.type === "ObjectProperty" ? getDelimitedAttrKey(tag, name, prop) : void 0;
+		if (!key || prop.type !== "ObjectProperty") {
+			meta.dynamic = true;
+			return;
 		}
 		const value = prop.value;
-		const propEval = evaluate(value);
-		if (propEval.confident) (staticProps ||= {})[key] = propEval.computed;
-		else (meta.dynamicValues ||= {})[key] = value;
+		const { confident, computed } = evaluate(value);
+		if (!confident) addDynamicValue(meta, key, value, void 0);
+		else if (!isLiteralPart(key)) {
+			if (computed) meta.staticParts.push(key);
+		} else {
+			const part = delimitedAttrStringify[name][1](key, computed);
+			if (part) meta.staticParts.push(part);
+		}
 	}
-	if (staticProps) (meta.staticItems ||= []).push(staticProps);
-	if (dynamicProps) (meta.dynamicItems ||= []).push(_marko_compiler.types.objectExpression(dynamicProps));
+}
+function getDelimitedAttrKey(tag, name, prop) {
+	if (!prop.computed && prop.key.type === "Identifier") return prop.key.name;
+	const key = prop.key;
+	const { confident, computed } = evaluate(key);
+	if (confident) return typeof computed === "string" || typeof computed === "number" ? computed + "" : void 0;
+	if (name === "class") return getStyleImportRead(tag, key);
+}
+function getDelimitedAttrPart(tag, name, value) {
+	const { confident, computed } = evaluate(value);
+	if (confident) {
+		const [delimiter, stringify] = delimitedAttrStringify[name];
+		return toDelimitedString(computed, delimiter, stringify);
+	}
+	if (name === "class") return getStyleImportRead(tag, value);
+}
+function addDynamicValue(meta, key, value, alternate) {
+	(meta.dynamicValues ||= []).push({
+		key,
+		value,
+		alternate
+	});
 }
 function buildUndefined() {
 	return _marko_compiler.types.unaryExpression("void", _marko_compiler.types.numericLiteral(0));
@@ -10824,9 +11042,10 @@ var dynamic_tag_default = {
 		if (tag.node.extra?.tagNameUnresolved) throw tagNotFoundError(tag);
 		(0, _marko_compiler_babel_utils.assertAttributesOrArgs)(tag);
 		const { node } = tag;
+		if (node.var && node.extra.featureType === "class") throw tag.get("var").buildCodeFrameError(`The Marko 5 (class API) tag \`${getStaticTagName(node)}\` cannot [\`<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 migrate the tag to the tags API.`);
 		const definedBodySection = node.extra?.defineBodySection;
 		if (definedBodySection) {
-			knownTagAnalyze(tag, definedBodySection, definedBodySection.params && getBindingPropTree(definedBodySection.params, !isSameOrChildSection(definedBodySection, getOrCreateSection(tag))));
+			knownTagAnalyze(tag, definedBodySection);
 			child(tag, getStaticTagName(tag.node), {
 				kind: SectionRef,
 				section: definedBodySection
@@ -10960,10 +11179,10 @@ var dynamic_tag_default = {
 				const bodySection = getSectionForBody(tag.get("body"));
 				const signal = getSignal(section, nodeBinding, "dynamicTag");
 				let tagVarSignal;
-				if (tag.node.var) {
+				if (tag.node.var && isTagVarResumed(tag)) {
 					const varBinding = tag.node.var.extra.binding;
 					tagVarSignal = initValue(varBinding);
-					tagVarSignal.register = isTagVarResumed(tag);
+					tagVarSignal.register = true;
 					tagVarSignal.referenced = true;
 					tagVarSignal.buildAssignment = (valueSection, value) => {
 						const changeArgs = [_marko_compiler.types.memberExpression(getScopeExpression(tagVarSignal.section, valueSection), _marko_compiler.types.stringLiteral(getAccessorPrefix().BranchScopes + getScopeAccessor(nodeBinding)), true), value];
@@ -10981,9 +11200,9 @@ var dynamic_tag_default = {
 					const argsOrInput = hasTagArgs ? _marko_compiler.types.arrayExpression(args) : args[0];
 					if (!_marko_compiler.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) signal.extraArgs = [_marko_compiler.types.arrowFunctionExpression([], statements.length ? _marko_compiler.types.blockStatement(statements.concat(_marko_compiler.types.returnStatement(argsOrInput))) : argsOrInput)];
 				}
+				enableDynamicTagVar(tag);
 				if (!isClassAPI) {
 					enableDynamicTagResume(tag);
-					enableDynamicTagVar(tag);
 					enableDynamicTagControllables(tag);
 				}
 				addValue(section, getReferencedBindings(tagExtra), signal, tagExpression);
@@ -11002,9 +11221,9 @@ function enableDynamicTagControllables(tag) {
 	}
 }
 function enableDynamicTagVar(tag) {
-	if (!tag.node.var || !isTagVarResumed(tag) || analyzeTagNameType(tag, true) === 1) return;
+	if (!tag.node.var || !isTagVarResumed(tag)) return;
 	importRuntimeFeature("dynamic-tag-var");
-	if (!tag.node.var.extra.binding.pruned) {
+	if (analyzeTagNameType(tag, true) !== 1 && !tag.node.var.extra.binding.pruned) {
 		const accessor = getScopeAccessorLiteral(tag.node.extra.nodeBinding, true);
 		if (addRuntimeOnce(`_dynamic_tag_var_resume ${accessor.value}`)) (0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.expressionStatement(callRuntime("_dynamic_tag_var_resume", accessor)));
 	}