svelte-effect-runtime 3.4.10 → 4.0.0

package/.dist/chunks/{transform-CEK6Ccll.js → transform-jNUr65K9.js}

@@ -1,4 +1,5 @@
-import { A as YieldStarInEventCallbackError, D as UnsupportedMarkupEffectPositionError, n as AsyncEffectInSyncRuneError, t as AsyncEffectInEventCallbackError } from "./errors-Dcf0MVbq.js";
+import { D as UnsupportedMarkupEffectPositionError, k as YieldStarInEventCallbackError, n as AsyncEffectInSyncRuneError, t as AsyncEffectInEventCallbackError } from "./errors-IJjsUwrE.js";
+import { t as scan_svelte_effect_source } from "./source-scan-C4PsggID.js";
 import { contains_top_level_yield_star } from "../detect.js";
 import ts from "typescript";
 import { parse } from "svelte/compiler";
@@ -22,20 +23,37 @@ function make_imports(has_effect_import, has_dispatcher_import, has_untrack_impo
 	dispatcher_value: "__SER___dispatcher",
 	effect: "Effect",
 	program: "__SER___program",
-	untrack: "untrack"
+	untrack: "untrack",
+	yield_success: "YieldSuccess",
+	yieldable: "ToEffect"
 }, options = {}) {
 	const needs_dispatcher = options.needs_dispatcher ?? true;
 	const needs_effect = options.needs_effect ?? true;
 	const needs_untrack = options.needs_untrack ?? true;
-	const dispatcher_import = bindings.dispatcher === "get_dispatcher" ? `import { get_dispatcher } from "svelte-effect-runtime/internal/generators";` : `import { get_dispatcher as ${bindings.dispatcher} } from "svelte-effect-runtime/internal/generators";`;
+	const needs_yield_success = options.needs_yield_success ?? false;
+	const needs_yieldable = options.needs_yieldable ?? false;
+	const generator_import = make_generator_import(bindings, needs_dispatcher && !has_dispatcher_import, needs_yieldable, needs_yield_success);
 	const untrack_import = bindings.untrack === "untrack" ? `import { untrack } from "svelte";` : `import { untrack as ${bindings.untrack} } from "svelte";`;
 	const effect_import = has_effect_import ? false : bindings.effect === "Effect" ? `import { Effect } from "effect";` : `import { Effect as ${bindings.effect} } from "effect";`;
 	return [
-		needs_dispatcher && !has_dispatcher_import && dispatcher_import,
+		generator_import,
 		needs_untrack && !has_untrack_import && untrack_import,
 		needs_effect && effect_import
 	].filter(Boolean).join("\n");
 }
+function make_generator_import(bindings, needs_dispatcher, needs_yieldable, needs_yield_success) {
+	const specifiers = [
+		needs_dispatcher && make_named_import("get_dispatcher", bindings.dispatcher),
+		needs_yieldable && make_named_import("ToEffect", bindings.yieldable),
+		needs_yield_success && make_named_import("YieldSuccess", bindings.yield_success, true)
+	].filter((specifier) => specifier !== false);
+	if (specifiers.length === 0) return false;
+	return `import { ${specifiers.join(", ")} } from "svelte-effect-runtime/internal/generators";`;
+}
+function make_named_import(imported_name, local_name, type_only = false) {
+	const prefix = type_only ? "type " : "";
+	return imported_name === local_name ? `${prefix}${imported_name}` : `${prefix}${imported_name} as ${local_name}`;
+}
 /**
 * Checks whether a source file imports a local binding from a module.
 *
@@ -93,7 +111,8 @@ function collect_binding_name_text(name) {
 //#region src/markup/transform/constants.ts
 const HELPERS = {
 	codes: "Code",
-	dispatcher: "Dispatcher"
+	dispatcher: "Dispatcher",
+	yieldable: "ToEffect"
 };
 //#endregion
 //#region src/markup/transform/apply.ts
@@ -144,7 +163,8 @@ function make_markup_helper_bindings(content) {
 	return {
 		bindings: {
 			codes: name_allocator.reserve(HELPERS.codes),
-			dispatcher: name_allocator.reserve(HELPERS.dispatcher)
+			dispatcher: name_allocator.reserve(HELPERS.dispatcher),
+			yieldable: name_allocator.reserve(HELPERS.yieldable)
 		},
 		name_allocator
 	};
@@ -183,7 +203,7 @@ function make_import_helper(content, import_text) {
 	return import_text;
 }
 function make_dispatcher_import(bindings) {
-	return `import { ${make_import_specifier(HELPERS.dispatcher, bindings.dispatcher)}, ${make_import_specifier(HELPERS.codes, bindings.codes)} } from "svelte-effect-runtime/internal/generators";`;
+	return `import { ${make_import_specifier(HELPERS.dispatcher, bindings.dispatcher)}, ${make_import_specifier(HELPERS.codes, bindings.codes)}, ${make_import_specifier(HELPERS.yieldable, bindings.yieldable)} } from "svelte-effect-runtime/internal/generators";`;
 }
 function make_import_specifier(imported_name, local_name) {
 	if (imported_name === local_name) return imported_name;
@@ -387,6 +407,49 @@ function add_ordered_name(names, name) {
 	names.push(name);
 }
 //#endregion
+//#region src/markup/event-attributes.ts
+/**
+* Checks whether a parsed Svelte attribute has the same event shape that
+* Svelte's compiler recognizes.
+*
+* @example
+* ```ts
+* is_svelte_event_attribute({
+*   type: "Attribute",
+*   name: "onclick",
+*   value: { type: "ExpressionTag" },
+* });
+* ```
+*
+* @since 4.0.0
+* @param attribute - Parsed Svelte attribute with its name and complete value
+*   shape.
+* @returns Whether Svelte treats the attribute as an event attribute.
+*/
+function is_svelte_event_attribute(attribute) {
+	if (attribute.type !== "Attribute" || !attribute.name?.startsWith("on")) return false;
+	const value = attribute.value;
+	return value !== true && !Array.isArray(value) || Array.isArray(value) && value.length === 1 && value[0]?.type === "ExpressionTag";
+}
+/**
+* Normalizes an event-like attribute name to Svelte's lowercase DOM event
+* spelling while keeping the legacy directive prefix intact.
+*
+* @example
+* ```ts
+* normalize_event_attribute_name("onChange");
+* ```
+*
+* @since 3.4.11
+* @param name - Event-like attribute name read from Svelte source or the
+*   parsed AST.
+* @returns Lowercase event attribute spelling for DOM-facing Svelte nodes.
+*/
+function normalize_event_attribute_name(name) {
+	if (name.startsWith("on:")) return `on:${name.slice(3).toLowerCase()}`;
+	return name.toLowerCase();
+}
+//#endregion
 //#region src/markup/transform/classify.ts
 /**
 * Matches sanitized placeholders back to their Svelte AST context.
@@ -443,6 +506,14 @@ function visit_ast_node(node, candidates, matched, classified) {
 			classify_expression(node.expression, "plain", candidates, matched, classified);
 			walk_ast(node.fragment, candidates, matched, classified);
 			return;
+		case "SnippetBlock":
+			walk_ast(node.body, candidates, matched, classified);
+			return;
+		case "SvelteElement":
+			classify_expression(node.tag, "plain", candidates, matched, classified);
+			visit_element_attributes(node, candidates, matched, classified);
+			walk_ast(node.fragment, candidates, matched, classified);
+			return;
 		case "RegularElement":
 		case "Component":
 		case "TitleElement":
@@ -451,7 +522,6 @@ function visit_ast_node(node, candidates, matched, classified) {
 		case "SvelteBoundary":
 		case "SvelteComponent":
 		case "SvelteDocument":
-		case "SvelteElement":
 		case "SvelteFragment":
 		case "SvelteHead":
 		case "SvelteSelf":
@@ -467,28 +537,51 @@ function classify_declaration_tag(node, candidates, matched, classified) {
 }
 function visit_element_attributes(node, candidates, matched, classified) {
 	for (const attr of node.attributes) {
-		if (attr.type === "Attribute" && attr.name && is_event_attribute_name(attr.name)) {
-			visit_attribute_value(attr.value, "event", candidates, matched, classified);
+		if (is_svelte_event_attribute(attr)) {
+			const attribute_name_replacement = make_attribute_name_replacement(node, attr);
+			visit_attribute_value(attr.value, "event", candidates, matched, classified, attribute_name_replacement);
 			continue;
 		}
 		if (attr.type === "OnDirective" && attr.expression) {
-			classify_expression(attr.expression, "event", candidates, matched, classified);
+			const attribute_name_replacement = make_directive_name_replacement(node, attr);
+			classify_expression(attr.expression, "event", candidates, matched, classified, attribute_name_replacement);
 			continue;
 		}
 	}
 }
-function is_event_attribute_name(name) {
-	return name.startsWith("on:") || /^on[a-z]/.test(name);
+function make_attribute_name_replacement(node, attr) {
+	if (!attr.name || !should_normalize_event_attribute_name(node) || attr.start === void 0) return;
+	const normalized_name = normalize_event_attribute_name(attr.name);
+	if (normalized_name === attr.name) return;
+	return {
+		start: attr.start,
+		end: attr.start + attr.name.length,
+		text: normalized_name
+	};
 }
-function visit_attribute_value(value, kind, candidates, matched, classified) {
+function make_directive_name_replacement(node, attr) {
+	if (!attr.name || !should_normalize_event_attribute_name(node) || attr.start === void 0) return;
+	const original_name = `on:${attr.name}`;
+	const normalized_name = normalize_event_attribute_name(original_name);
+	if (normalized_name === original_name) return;
+	return {
+		start: attr.start,
+		end: attr.start + original_name.length,
+		text: normalized_name
+	};
+}
+function should_normalize_event_attribute_name(node) {
+	return node.type !== "Component" && node.type !== "SvelteComponent" && node.type !== "SvelteSelf";
+}
+function visit_attribute_value(value, kind, candidates, matched, classified, attribute_name_replacement) {
 	if (value === true) return;
 	if (Array.isArray(value)) {
-		for (const part of value) if (part.type === "ExpressionTag") classify_expression(part.expression, kind, candidates, matched, classified);
+		for (const part of value) if (part.type === "ExpressionTag") classify_expression(part.expression, kind, candidates, matched, classified, attribute_name_replacement);
 		return;
 	}
-	classify_expression(value.expression, kind, candidates, matched, classified);
+	classify_expression(value.expression, kind, candidates, matched, classified, attribute_name_replacement);
 }
-function classify_expression(expression, kind, candidates, matched, classified) {
+function classify_expression(expression, kind, candidates, matched, classified, attribute_name_replacement) {
 	if (!expression) return;
 	const found_candidates = find_candidates(expression, candidates);
 	for (const candidate of found_candidates) {
@@ -496,7 +589,8 @@ function classify_expression(expression, kind, candidates, matched, classified)
 		matched.add(candidate.placeholder);
 		classified.push({
 			candidate,
-			kind: resolve_candidate_kind(candidate, kind)
+			kind: resolve_candidate_kind(candidate, kind),
+			attribute_name_replacement
 		});
 	}
 }
@@ -529,6 +623,75 @@ function is_record(value) {
 	return typeof value === "object" && value !== null;
 }
 //#endregion
+//#region src/script-transform/ast.ts
+/**
+* Checks whether a node is a `yield*` binary expression.
+*
+* @since 2.0.0
+* @param node - TypeScript AST node to check.
+* @returns Whether the node represents `yield * operand`.
+*/
+function is_yield_star_expression$1(node) {
+	return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AsteriskToken && ts.isIdentifier(node.left) && node.left.text === "yield";
+}
+/**
+* Checks whether a node owns its own yield semantics.
+*
+* @since 2.0.0
+* @param node - TypeScript AST node to check.
+* @returns Whether traversal should stop at this function boundary.
+*/
+function is_function_boundary_node(node) {
+	return ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node);
+}
+/**
+* Returns `true` if the node tree contains a top-level `await`.
+*
+* @since 2.0.0
+* @param node - Root node to search.
+* @returns Whether a top-level await expression was found.
+*/
+function contains_top_level_await(node) {
+	if (ts.isAwaitExpression(node)) return true;
+	return node.getChildren().some((child) => !is_function_boundary_node(child) && contains_top_level_await(child));
+}
+/**
+* Collects top-level `yield*` nodes under an expression.
+*
+* @since 2.0.0
+* @param node - Root node to search.
+* @param on_found - Callback invoked for each matching yield node.
+* @returns Nothing.
+*/
+function collect_yield_star_nodes(node, on_found) {
+	if (is_function_boundary_node(node)) return;
+	if (is_yield_star_expression$1(node)) {
+		on_found(node);
+		return;
+	}
+	node.forEachChild((child) => {
+		collect_yield_star_nodes(child, on_found);
+	});
+}
+/**
+* Finds the first top-level `yield*` expression below a node.
+*
+* @since 2.0.0
+* @param node - Root node to search.
+* @param on_found - Callback invoked with the first matching node.
+* @returns Nothing.
+*/
+function find_yield_star_node(node, on_found) {
+	if (is_function_boundary_node(node)) return;
+	if (is_yield_star_expression$1(node)) {
+		on_found(node);
+		return;
+	}
+	node.forEachChild((child) => {
+		find_yield_star_node(child, on_found);
+	});
+}
+//#endregion
 //#region src/markup/transform/expressions.ts
 /**
 * Strips an event handler arrow function down to its executable body.
@@ -673,7 +836,7 @@ function add_binding_names(name, locals) {
 	}
 }
 function visit_event_body(node, context, result) {
-	if (is_yield_star_expression$1(node)) {
+	if (is_yield_star_expression(node)) {
 		if (context === "top_level") result.has_top_level_yield_star = true;
 		else if (context === "nested_invalid") result.has_nested_invalid_yield_star = true;
 		node.forEachChild((child) => visit_event_body(child, context, result));
@@ -692,7 +855,7 @@ function is_nested_function_boundary(node) {
 function is_generator_function_boundary(node) {
 	return (ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0;
 }
-function is_yield_star_expression$1(node) {
+function is_yield_star_expression(node) {
 	if (ts.isYieldExpression(node)) return node.asteriskToken !== void 0;
 	return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AsteriskToken && ts.isIdentifier(node.left) && node.left.text === "yield";
 }
@@ -937,7 +1100,22 @@ function to_expr_pos(pos, context) {
 * @returns Replacements ready to apply to the original component source.
 */
 function emit_replacements(classified, effect_context, helper_bindings, name_allocator, target) {
-	return classified.map(({ candidate, kind }) => emit_replacement(candidate, kind, effect_context, helper_bindings, name_allocator, target));
+	const expression_replacements = classified.map(({ candidate, kind }) => emit_replacement(candidate, kind, effect_context, helper_bindings, name_allocator, target));
+	return [...unique_attribute_name_replacements(classified).map((replacement) => ({
+		start: replacement.start,
+		end: replacement.end,
+		text: replacement.text
+	})), ...expression_replacements];
+}
+function unique_attribute_name_replacements(classified) {
+	const seen = /* @__PURE__ */ new Set();
+	return classified.map((entry) => entry.attribute_name_replacement).filter((replacement) => {
+		if (!replacement) return false;
+		const key = `${replacement.start}:${replacement.end}:${replacement.text}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
 }
 function emit_replacement(candidate, kind, effect_context, helper_bindings, name_allocator, target) {
 	const normalized = normalize_effect_callback_yields(candidate.expr_text, effect_context);
@@ -953,32 +1131,28 @@ function emit_replacement(candidate, kind, effect_context, helper_bindings, name
 	let helpers;
 	let relocation;
 	if (kind === "await") {
-		const effect = make_effect_helper(normalized_candidate, helper_name);
+		const effect = make_effect_helper(normalized_candidate, helper_name, helper_bindings);
 		replacement_text = emit_promise_expression(id_text, effect, helper_bindings, "undefined", `{ ssr: "pending" }`);
 		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "render") {
-		const effect = make_effect_helper(normalized_candidate, helper_name);
+		const effect = make_effect_helper(normalized_candidate, helper_name, helper_bindings);
 		replacement_text = emit_render_expression(id_text, effect, candidate, helper_bindings, is_server_target);
 		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "render_argument") {
-		const effect = make_effect_helper(normalized_candidate, helper_name);
+		const effect = make_effect_helper(normalized_candidate, helper_name, helper_bindings);
 		replacement_text = emit_await_expression(id_text, effect, helper_bindings, server_fallback(is_server_target, "undefined"));
 		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "each") {
-		const effect = make_effect_helper(normalized_candidate, helper_name);
+		const effect = make_effect_helper(normalized_candidate, helper_name, helper_bindings);
 		replacement_text = emit_await_expression(id_text, effect, helper_bindings, server_fallback(is_server_target, "[]"));
 		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "event") {
 		const event = make_event_handler(normalized_candidate, helper_bindings);
 		replacement_text = event.text;
 		helpers = normalized.helpers;
-		relocation = make_relocation(candidate, replacement_text, {
-			originalStart: 0,
-			originalEnd: candidate.expr_text.length,
-			generatedText: event.expr_text
-		});
+		relocation = make_pending_relocation(candidate, replacement_text, event.expr_text, event.relocation);
 	} else {
-		const effect = make_effect_helper(normalized_candidate, helper_name);
+		const effect = make_effect_helper(normalized_candidate, helper_name, helper_bindings);
 		replacement_text = emit_await_expression(id_text, effect, helper_bindings, server_fallback(is_server_target, "undefined"));
 		helpers = [...normalized.helpers, effect.helper];
 	}
@@ -994,9 +1168,11 @@ function make_event_handler(candidate, helper_bindings) {
 	const expr_text = candidate.expr_text;
 	if (is_callback_function_expression(expr_text)) throw new YieldStarInEventCallbackError(candidate.filename, expr_text);
 	if (analyze_event_body_yield_star(expr_text).has_nested_invalid_yield_star) throw new AsyncEffectInEventCallbackError(candidate.filename, expr_text);
+	const wrapped_expr_text = wrap_yield_stars(expr_text, helper_bindings);
 	return {
-		expr_text,
-		text: `(event) => { ${helper_bindings.dispatcher}.emit({ type: ${helper_bindings.codes}.Markup.Run, fn: function* () { ${expr_text}; } }); }`
+		expr_text: wrapped_expr_text,
+		relocation: make_yield_operand_relocation(expr_text, wrapped_expr_text, helper_bindings),
+		text: `(event) => { ${helper_bindings.dispatcher}.emit({ type: ${helper_bindings.codes}.Markup.Run, fn: function* () { ${wrapped_expr_text}; } }); }`
 	};
 }
 function emit_promise_expression(id_text, effect, helper_bindings, ssr_fallback, options) {
@@ -1021,41 +1197,91 @@ function emit_await_expression(id_text, effect, helper_bindings, ssr_fallback) {
 function server_fallback(is_server_target, fallback) {
 	return is_server_target ? fallback : void 0;
 }
-function make_effect_helper(candidate, helper_name) {
+function make_effect_helper(candidate, helper_name, helper_bindings) {
 	const deps = collect_free_identifiers(candidate.expr_text);
 	const args_text = deps.join(", ");
 	const deps_text = deps.length === 0 ? "[]" : `[${args_text}]`;
 	const call = `${helper_name}()`;
-	const text = `function* ${helper_name}() { return (${candidate.expr_text}); }`;
-	const generated_start = text.indexOf(candidate.expr_text);
+	const effect_text = wrap_yield_stars(candidate.expr_text, helper_bindings);
+	const text = `function* ${helper_name}() { return (${effect_text}); }`;
+	const generated_start = text.indexOf(effect_text);
+	const relocation = make_yield_operand_relocation(candidate.expr_text, effect_text, helper_bindings) ?? {
+		originalStart: 0,
+		originalEnd: candidate.expr_text.length,
+		generatedStart: 0,
+		generatedEnd: effect_text.length
+	};
 	return {
 		call,
 		deps_text,
 		helper: {
 			text,
 			relocation: {
-				originalStart: candidate.start,
-				originalEnd: candidate.end,
-				generatedStartInReplacement: generated_start,
-				generatedEndInReplacement: generated_start + candidate.expr_text.length
+				originalStart: candidate.start + relocation.originalStart,
+				originalEnd: candidate.start + relocation.originalEnd,
+				generatedStartInReplacement: generated_start + relocation.generatedStart,
+				generatedEndInReplacement: generated_start + relocation.generatedEnd
 			}
 		}
 	};
 }
+function wrap_yield_stars(text, helper_bindings) {
+	const source_file = ts.createSourceFile("markup-yield.ts", text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const replacements = [];
+	collect_yield_star_nodes(source_file, (node) => {
+		const yield_text = text.slice(node.getStart(source_file), node.end).trim();
+		replacements.push({
+			start: node.getStart(source_file),
+			end: node.end,
+			text: `yield* ${helper_bindings.yieldable}(${strip_yield_star(yield_text)})`
+		});
+	});
+	if (replacements.length === 0) return text;
+	replacements.sort((a, b) => b.start - a.start);
+	let output = text;
+	for (const replacement of replacements) output = output.slice(0, replacement.start) + replacement.text + output.slice(replacement.end);
+	return output;
+}
+function strip_yield_star(yield_text) {
+	return yield_text.replace(/^yield\s*\*\s*/, "");
+}
+function make_yield_operand_relocation(original_text, generated_text, helper_bindings) {
+	const source_file = ts.createSourceFile("markup-yield-relocation.ts", original_text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	let yield_node;
+	collect_yield_star_nodes(source_file, (node) => {
+		yield_node ??= node;
+	});
+	if (!yield_node || !ts.isBinaryExpression(yield_node)) return;
+	const operand = yield_node.right;
+	const original_start = operand.getStart(source_file);
+	const original_end = operand.end;
+	const operand_text = original_text.slice(original_start, original_end).trim();
+	const wrapper_text = `${helper_bindings.yieldable}(${operand_text})`;
+	const wrapper_start = generated_text.indexOf(wrapper_text);
+	if (wrapper_start === -1) return;
+	const generated_start = wrapper_start + wrapper_text.indexOf(operand_text);
+	return {
+		originalStart: original_start,
+		originalEnd: original_end,
+		generatedStart: generated_start,
+		generatedEnd: generated_start + operand_text.length
+	};
+}
 function make_cache_id(candidate) {
 	return `${candidate.filename.replace(/[?#].*$/, "")}:${candidate.start}:${candidate.end}`;
 }
 function make_helper_name(candidate, name_allocator) {
 	return name_allocator.reserve(`__SER___markup_effect_${candidate.start}_${candidate.end}`);
 }
-function make_relocation(candidate, replacement_text, inner) {
-	const generated_start = replacement_text.indexOf(inner.generatedText);
+function make_pending_relocation(candidate, replacement_text, expression_text, relocation) {
+	if (!relocation) return;
+	const generated_start = replacement_text.indexOf(expression_text);
 	if (generated_start === -1) return;
 	return {
-		originalStart: candidate.start + inner.originalStart,
-		originalEnd: candidate.start + inner.originalEnd,
-		generatedStartInReplacement: generated_start,
-		generatedEndInReplacement: generated_start + inner.generatedText.length
+		originalStart: candidate.start + relocation.originalStart,
+		originalEnd: candidate.start + relocation.originalEnd,
+		generatedStartInReplacement: generated_start + relocation.generatedStart,
+		generatedEndInReplacement: generated_start + relocation.generatedEnd
 	};
 }
 //#endregion
@@ -1155,75 +1381,6 @@ function is_rune_root(name) {
 	return name === "$bindable" || name === "$derived" || name === "$effect" || name === "$host" || name === "$inspect" || name === "$props" || name === "$state";
 }
 //#endregion
-//#region src/script-transform/ast.ts
-/**
-* Checks whether a node is a `yield*` binary expression.
-*
-* @since 2.0.0
-* @param node - TypeScript AST node to check.
-* @returns Whether the node represents `yield * operand`.
-*/
-function is_yield_star_expression(node) {
-	return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AsteriskToken && ts.isIdentifier(node.left) && node.left.text === "yield";
-}
-/**
-* Checks whether a node owns its own yield semantics.
-*
-* @since 2.0.0
-* @param node - TypeScript AST node to check.
-* @returns Whether traversal should stop at this function boundary.
-*/
-function is_function_boundary_node(node) {
-	return ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node);
-}
-/**
-* Returns `true` if the node tree contains a top-level `await`.
-*
-* @since 2.0.0
-* @param node - Root node to search.
-* @returns Whether a top-level await expression was found.
-*/
-function contains_top_level_await(node) {
-	if (ts.isAwaitExpression(node)) return true;
-	return node.getChildren().some((child) => !is_function_boundary_node(child) && contains_top_level_await(child));
-}
-/**
-* Collects top-level `yield*` nodes under an expression.
-*
-* @since 2.0.0
-* @param node - Root node to search.
-* @param on_found - Callback invoked for each matching yield node.
-* @returns Nothing.
-*/
-function collect_yield_star_nodes(node, on_found) {
-	if (is_function_boundary_node(node)) return;
-	if (is_yield_star_expression(node)) {
-		on_found(node);
-		return;
-	}
-	node.forEachChild((child) => {
-		collect_yield_star_nodes(child, on_found);
-	});
-}
-/**
-* Finds the first top-level `yield*` expression below a node.
-*
-* @since 2.0.0
-* @param node - Root node to search.
-* @param on_found - Callback invoked with the first matching node.
-* @returns Nothing.
-*/
-function find_yield_star_node(node, on_found) {
-	if (is_function_boundary_node(node)) return;
-	if (is_yield_star_expression(node)) {
-		on_found(node);
-		return;
-	}
-	node.forEachChild((child) => {
-		find_yield_star_node(child, on_found);
-	});
-}
-//#endregion
 //#region src/markup/transform/scan.ts
 /**
 * Replaces markup `yield*` expressions with placeholders before Svelte parses
@@ -1247,26 +1404,13 @@ function find_yield_star_node(node, on_found) {
 */
 function sanitize_markup(content, filename) {
 	const candidates = [];
-	const excluded_ranges = collect_excluded_ranges(content);
+	const source_scan = scan_svelte_effect_source(content, filename);
 	const magic = new MagicString(content);
 	let helper_index = 0;
-	let cursor = 0;
-	while (cursor < content.length) {
-		const open = content.indexOf("{", cursor);
-		if (open === -1) break;
-		/** Skip braces inside <script> and <style> blocks. */
-		const excluded_range = find_excluded_range(excluded_ranges, open);
-		if (excluded_range) {
-			cursor = excluded_range.end;
-			continue;
-		}
-		/** Find the matching closing brace. */
-		const close = find_closing_brace(content, open + 1);
-		if (close === -1) {
-			cursor = open + 1;
-			continue;
-		}
-		const inner = content.slice(open + 1, close);
+	for (const expression of source_scan.markup_expressions) {
+		const open = expression.open;
+		const close = expression.close;
+		const inner = expression.inner;
 		const trimmed = inner.trimStart();
 		const leading_ws = inner.length - trimmed.length;
 		const tag_info = get_tag_info(trimmed);
@@ -1285,16 +1429,12 @@ function sanitize_markup(content, filename) {
 				});
 				magic.overwrite(declaration_yield.start, declaration_yield.end, placeholder);
 			}
-			cursor = close + 1;
 			continue;
 		}
 		let expr_body = trimmed.slice(tag_info.prefix_length);
 		/** For @const, only use the RHS after `=` as the expression body. */
 		const equal_idx = tag_info.kind === "plain" && trimmed.startsWith("@const ") ? expr_body.indexOf("=") : -1;
-		if (!((is_event_callback_expression(inner) ? analyze_event_yield(inner) : void 0)?.has_top_level_yield_star ?? contains_yield_star_in_text(expr_body))) {
-			cursor = close + 1;
-			continue;
-		}
+		if (!((is_event_callback_expression(inner) ? analyze_event_yield(inner) : void 0)?.has_top_level_yield_star ?? contains_yield_star_in_text(expr_body))) continue;
 		/** The expression starts after the tag prefix. For @const, after the `=`. */
 		let extra_prefix = 0;
 		if (equal_idx !== -1) {
@@ -1317,10 +1457,7 @@ function sanitize_markup(content, filename) {
 			if (boundary !== Infinity) expr_end = expr_start + boundary;
 		}
 		const expr_text = content.slice(expr_start, expr_end).trim();
-		if (expr_text.length === 0) {
-			cursor = close + 1;
-			continue;
-		}
+		if (expr_text.length === 0) continue;
 		validate_expression_yield_usage(expr_text, filename);
 		if (key === "render" && !/^\s*yield\s*\*/.test(expr_text)) {
 			const render_arg_yields = collect_expression_yield_expressions(content, expr_start, expr_text, filename);
@@ -1338,7 +1475,6 @@ function sanitize_markup(content, filename) {
 					});
 					magic.overwrite(render_arg_yield.start, render_arg_yield.end, placeholder);
 				}
-				cursor = close + 1;
 				continue;
 			}
 		}
@@ -1354,7 +1490,6 @@ function sanitize_markup(content, filename) {
 			key
 		});
 		magic.overwrite(expr_start, expr_end, key === "render" ? `${placeholder}()` : placeholder);
-		cursor = close + 1;
 	}
 	return {
 		code: magic.toString(),
@@ -1382,108 +1517,6 @@ function collect_expression_yield_expressions(content, expr_start, expr_text, fi
 	});
 	return expressions;
 }
-function collect_excluded_ranges(content) {
-	const ranges = [
-		...collect_tag_ranges(content, "script"),
-		...collect_tag_ranges(content, "style"),
-		...collect_html_comment_ranges(content)
-	];
-	ranges.sort((a, b) => a.start - b.start);
-	return merge_ranges(ranges);
-}
-function collect_tag_ranges(content, tag) {
-	const pattern = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}\\s*>`, "gi");
-	return [...content.matchAll(pattern)].flatMap((match) => {
-		if (match.index === void 0) return [];
-		return [{
-			start: match.index,
-			end: match.index + match[0].length
-		}];
-	});
-}
-function collect_html_comment_ranges(content) {
-	const ranges = [];
-	let cursor = 0;
-	while (cursor < content.length) {
-		const start = content.indexOf("<!--", cursor);
-		if (start === -1) break;
-		const close = content.indexOf("-->", start + 4);
-		const end = close === -1 ? content.length : close + 3;
-		ranges.push({
-			start,
-			end
-		});
-		cursor = end;
-	}
-	return ranges;
-}
-function merge_ranges(ranges) {
-	const merged = [];
-	for (const range of ranges) {
-		const previous = merged.at(-1);
-		if (!previous || range.start > previous.end) {
-			merged.push({ ...range });
-			continue;
-		}
-		previous.end = Math.max(previous.end, range.end);
-	}
-	return merged;
-}
-function find_excluded_range(ranges, pos) {
-	let low = 0;
-	let high = ranges.length - 1;
-	while (low <= high) {
-		const mid = Math.floor((low + high) / 2);
-		const range = ranges[mid];
-		if (pos <= range.start) {
-			high = mid - 1;
-			continue;
-		}
-		if (pos >= range.end) {
-			low = mid + 1;
-			continue;
-		}
-		return range;
-	}
-}
-/** Brace matching helpers for extracting complete markup expressions. */
-function find_closing_brace(content, start) {
-	let depth = 0;
-	for (let i = start; i < content.length; i += 1) {
-		const ch = content[i];
-		if (ch === "{" && content[i - 1] !== "$") depth += 1;
-		else if (ch === "}") {
-			if (depth === 0) return i;
-			depth -= 1;
-		} else if (ch === "'" || ch === "\"" || ch === "`") {
-			i = skip_string(content, i, ch);
-			if (i === -1) return -1;
-		} else if (ch === "/" && content[i + 1] === "/") i = skip_line_comment(content, i);
-		else if (ch === "/" && content[i + 1] === "*") {
-			i = skip_block_comment(content, i);
-			if (i === -1) return -1;
-		}
-	}
-	return -1;
-}
-function skip_string(content, start, quote) {
-	for (let i = start + 1; i < content.length; i += 1) {
-		if (content[i] === "\\") {
-			i += 1;
-			continue;
-		}
-		if (content[i] === quote) return i;
-	}
-	return -1;
-}
-function skip_line_comment(content, start) {
-	for (let i = start + 2; i < content.length; i += 1) if (content[i] === "\n") return i;
-	return content.length;
-}
-function skip_block_comment(content, start) {
-	for (let i = start + 2; i < content.length; i += 1) if (content[i] === "*" && content[i + 1] === "/") return i + 1;
-	return -1;
-}
 function get_tag_info(trimmed) {
 	if (trimmed.startsWith("#each ")) return {
 		kind: "each",
@@ -1498,6 +1531,10 @@ function get_tag_info(trimmed) {
 		prefix_length: 8
 	};
 	/** Strip prefix-only tags — the expression starts after the tag keyword. */
+	if (trimmed.startsWith("@attach ")) return {
+		kind: "plain",
+		prefix_length: 8
+	};
 	if (trimmed.startsWith("#if ")) return {
 		kind: "plain",
 		prefix_length: 4
@@ -1522,6 +1559,10 @@ function get_tag_info(trimmed) {
 		kind: "plain",
 		prefix_length: 7
 	};
+	if (trimmed.startsWith("...")) return {
+		kind: "plain",
+		prefix_length: 3
+	};
 	return {
 		kind: "plain",
 		prefix_length: 0
@@ -1644,6 +1685,6 @@ function transform_markup_effect(content, filename, options = {}) {
 	};
 }
 //#endregion
-export { is_yield_star_expression as a, slice as c, collect_top_level_binding_names as d, has_local_import_binding as f, find_yield_star_node as i, slice_start as l, collect_yield_star_nodes as n, validate_rune_yield_usage as o, make_imports as p, contains_top_level_await as r, create_source_map as s, transform_markup_effect as t, collect_free_identifiers as u };
+export { slice_start as a, contains_top_level_await as c, collect_top_level_binding_names as d, has_local_import_binding as f, slice as i, find_yield_star_node as l, validate_rune_yield_usage as n, collect_free_identifiers as o, make_imports as p, create_source_map as r, collect_yield_star_nodes as s, transform_markup_effect as t, is_yield_star_expression$1 as u };
 
-//# sourceMappingURL=transform-CEK6Ccll.js.map
+//# sourceMappingURL=transform-jNUr65K9.js.map