svelte-effect-runtime 1.6.2 → 2.0.0-beta.1

package/.dist/chunks/transform-BtlxgJrg.js

@@ -0,0 +1,836 @@
+import { contains_top_level_yield_star } from "../detect.js";
+import { parse } from "svelte/compiler";
+import MagicString from "magic-string";
+import ts from "typescript";
+//#region src/markup/transform/constants.ts
+const HELPERS = {
+	value: "__ser_markup_value",
+	promise: "__ser_markup_promise",
+	run: "__ser_markup_run"
+};
+//#endregion
+//#region src/markup/transform/apply.ts
+function create_source_map(magic, filename) {
+	return magic.generateMap({
+		hires: true,
+		includeContent: true,
+		source: filename
+	});
+}
+function blank_script_blocks(content) {
+	return content.replace(/<script\b[^>]*>[\s\S]*?<\/script\s*>/gi, (match) => {
+		return match.split("\n").map((l) => " ".repeat(l.length)).join("\n");
+	});
+}
+function inject_helpers(magic, content, helpers = []) {
+	if (content.includes(HELPERS.value)) return;
+	const helper_segments = [
+		`import { value as ${HELPERS.value} } from "svelte-effect-runtime/internal/generators";`,
+		`import { promise as ${HELPERS.promise} } from "svelte-effect-runtime/internal/generators";`,
+		`import { run as ${HELPERS.run} } from "svelte-effect-runtime/internal/generators";`,
+		...helpers
+	].map((helper) => typeof helper === "string" ? { text: helper } : helper);
+	const helper_block = helper_segments.map((segment) => segment.text).join("\n");
+	const script_tag = find_instance_script_tag(content);
+	if (script_tag) {
+		const text = `\n${helper_block}\n`;
+		magic.appendLeft(script_tag.end, text);
+		return {
+			start: script_tag.end,
+			text,
+			relocations: make_insertion_relocations(helper_segments, "\n")
+		};
+	} else {
+		const text = `<script>\n${helper_block}\n<\/script>\n\n`;
+		magic.prepend(text);
+		return {
+			start: 0,
+			text,
+			relocations: make_insertion_relocations(helper_segments, "<script>\n")
+		};
+	}
+}
+function create_relocations(replacements, helper_insertion) {
+	const edits = [helper_insertion && {
+		start: helper_insertion.start,
+		removedLength: 0,
+		insertedLength: helper_insertion.text.length
+	}, ...replacements.map((replacement) => ({
+		start: replacement.start,
+		removedLength: replacement.end - replacement.start,
+		insertedLength: replacement.text.length
+	}))].filter(Boolean);
+	const replacement_relocations = replacements.flatMap((replacement) => {
+		if (!replacement.relocation) return [];
+		const delta_before = edits.filter((edit) => edit.start < replacement.start).reduce((total, edit) => total + edit.insertedLength - edit.removedLength, 0);
+		const generated_start = replacement.start + delta_before;
+		return [{
+			originalStart: replacement.relocation.originalStart,
+			originalEnd: replacement.relocation.originalEnd,
+			generatedStart: generated_start + replacement.relocation.generatedStartInReplacement,
+			generatedEnd: generated_start + replacement.relocation.generatedEndInReplacement
+		}];
+	});
+	const helper_relocations = helper_insertion?.relocations?.map((relocation) => ({
+		originalStart: relocation.originalStart,
+		originalEnd: relocation.originalEnd,
+		generatedStart: helper_insertion.start + relocation.generatedStartInReplacement,
+		generatedEnd: helper_insertion.start + relocation.generatedEndInReplacement
+	})) ?? [];
+	return [...replacement_relocations, ...helper_relocations];
+}
+function make_insertion_relocations(segments, prefix) {
+	const relocations = [];
+	let offset = prefix.length;
+	for (const segment of segments) {
+		if (segment.relocation) relocations.push({
+			originalStart: segment.relocation.originalStart,
+			originalEnd: segment.relocation.originalEnd,
+			generatedStartInReplacement: offset + segment.relocation.generatedStartInReplacement,
+			generatedEndInReplacement: offset + segment.relocation.generatedEndInReplacement
+		});
+		offset += segment.text.length + 1;
+	}
+	return relocations;
+}
+function find_instance_script_tag(content) {
+	for (const match of content.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi)) {
+		if (match.index === void 0) continue;
+		const attrs = match[1] ?? "";
+		if (/\bcontext\s*=\s*["']module["']/.test(attrs) || /\bmodule\b/.test(attrs)) continue;
+		const open_end = match[0].indexOf(">") + 1;
+		return {
+			start: match.index + open_end,
+			end: match.index + match[0].length - 9
+		};
+	}
+}
+//#endregion
+//#region src/markup/transform/classify.ts
+/**
+* Matches sanitized placeholders back to their Svelte AST context.
+*
+* @since 2.0.0
+* @param ast - Parsed Svelte AST for the sanitized component markup.
+* @param candidates - Placeholder candidates produced by the scanner.
+* @returns Candidates paired with the markup context that determines how they
+*   should be emitted.
+*/
+function classify_candidates(ast, candidates) {
+	const by_placeholder = new Map(candidates.map((candidate) => [candidate.placeholder, candidate]));
+	const classified = [];
+	const matched = /* @__PURE__ */ new Set();
+	walk_ast(ast.fragment, by_placeholder, matched, classified);
+	return classified;
+}
+function walk_ast(fragment, candidates, matched, classified) {
+	for (const node of fragment.nodes) visit_ast_node(node, candidates, matched, classified);
+}
+function visit_ast_node(node, candidates, matched, classified) {
+	switch (node.type) {
+		case "ExpressionTag":
+			classify_expression(node.expression, "plain", candidates, matched, classified);
+			return;
+		case "IfBlock":
+			classify_expression(node.test, "plain", candidates, matched, classified);
+			walk_ast(node.consequent, candidates, matched, classified);
+			if (node.alternate) walk_ast(node.alternate, candidates, matched, classified);
+			return;
+		case "EachBlock":
+			classify_expression(node.expression, "each", candidates, matched, classified);
+			walk_ast(node.body, candidates, matched, classified);
+			if (node.fallback) walk_ast(node.fallback, candidates, matched, classified);
+			return;
+		case "AwaitBlock":
+			classify_expression(node.expression, "await", candidates, matched, classified);
+			if (node.pending) walk_ast(node.pending, candidates, matched, classified);
+			if (node.then) walk_ast(node.then, candidates, matched, classified);
+			if (node.catch) walk_ast(node.catch, candidates, matched, classified);
+			return;
+		case "RenderTag":
+			classify_expression(node.expression, "render", candidates, matched, classified);
+			return;
+		case "HtmlTag":
+			classify_expression(node.expression, "plain", candidates, matched, classified);
+			return;
+		case "DebugTag":
+			classify_debug_tag(node, candidates, matched, classified);
+			return;
+		case "ConstTag":
+		case "DeclarationTag":
+			classify_declaration_tag(node, candidates, matched, classified);
+			return;
+		case "KeyBlock":
+			classify_expression(node.expression, "plain", candidates, matched, classified);
+			walk_ast(node.fragment, candidates, matched, classified);
+			return;
+		case "RegularElement":
+		case "Component":
+		case "TitleElement":
+		case "SlotElement":
+		case "SvelteBody":
+		case "SvelteBoundary":
+		case "SvelteComponent":
+		case "SvelteDocument":
+		case "SvelteElement":
+		case "SvelteFragment":
+		case "SvelteHead":
+		case "SvelteSelf":
+		case "SvelteWindow":
+			visit_element_attributes(node, candidates, matched, classified);
+			walk_ast(node.fragment, candidates, matched, classified);
+			return;
+		default: return;
+	}
+}
+function classify_debug_tag(node, candidates, matched, classified) {
+	const idents = node.identifiers;
+	if (!idents || idents.length === 0) return;
+	for (const ident of idents) classify_expression(ident, "plain", candidates, matched, classified);
+}
+function classify_declaration_tag(node, candidates, matched, classified) {
+	for (const decl of node.declaration.declarations) {
+		if (!decl.init) continue;
+		classify_expression(decl.init, "plain", candidates, matched, classified);
+	}
+}
+function visit_element_attributes(node, candidates, matched, classified) {
+	for (const attr of node.attributes) {
+		if (attr.type === "Attribute" && attr.name && (attr.name.startsWith("on:") || /^on[a-z]/.test(attr.name))) {
+			visit_attribute_value(attr.value, "event", candidates, matched, classified);
+			continue;
+		}
+		if (attr.type === "OnDirective" && attr.expression) {
+			classify_expression(attr.expression, "event", candidates, matched, classified);
+			continue;
+		}
+	}
+}
+function visit_attribute_value(value, kind, candidates, matched, classified) {
+	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);
+		return;
+	}
+	classify_expression(value.expression, kind, candidates, matched, classified);
+}
+function classify_expression(expression, kind, candidates, matched, classified) {
+	if (!expression) return;
+	const candidate = find_candidate(expression, candidates);
+	if (!candidate || matched.has(candidate.placeholder)) return;
+	matched.add(candidate.placeholder);
+	classified.push({
+		candidate,
+		kind
+	});
+}
+function find_candidate(expression, candidates) {
+	if (expression.type === "Identifier" && expression.name) return candidates.get(expression.name);
+	if (expression.type === "CallExpression" && expression.callee?.type === "Identifier" && expression.callee.name) return candidates.get(expression.callee.name);
+}
+//#endregion
+//#region src/markup/transform/expressions.ts
+/**
+* Strips an event handler arrow function down to its executable body.
+*
+* @since 2.0.0
+* @param expr - Event handler expression text from the original markup.
+* @returns Handler parameters, body text, and body offsets inside `expr`.
+*/
+function strip_arrow_function(expr) {
+	const arrow_idx = expr.indexOf("=>");
+	if (arrow_idx === -1) return {
+		params: "()",
+		body: expr,
+		body_start: 0,
+		body_end: expr.length
+	};
+	const params = expr.slice(0, arrow_idx).trim();
+	const raw_body = expr.slice(arrow_idx + 2);
+	const leading_ws = raw_body.length - raw_body.trimStart().length;
+	let body_start = arrow_idx + 2 + leading_ws;
+	let body_end = expr.length - (raw_body.length - raw_body.trimEnd().length);
+	let body = expr.slice(body_start, body_end);
+	if (body.startsWith("{") && body.endsWith("}")) {
+		body_start += 1;
+		body_end -= 1;
+		body = body.slice(1, -1);
+	}
+	const body_leading_ws = body.length - body.trimStart().length;
+	const body_trailing_ws = body.length - body.trimEnd().length;
+	body_start += body_leading_ws;
+	body_end -= body_trailing_ws;
+	body = body.trim();
+	if (body.endsWith(";")) {
+		body = body.slice(0, -1);
+		body_end -= 1;
+	}
+	return {
+		params,
+		body,
+		body_start,
+		body_end
+	};
+}
+/**
+* Classifies `yield*` placement inside an event handler body.
+*
+* @example
+* ```ts
+* analyze_event_body_yield_star("yield* save()");
+* ```
+*
+* @since 2.0.0
+* @param body - Event handler body text after the outer arrow has been
+*   stripped.
+* @returns Whether the body has top-level yield* expressions and whether any
+*   yield* appears inside a nested non-generator callback.
+*/
+function analyze_event_body_yield_star(body) {
+	const wrapped = `function* __ser_event() { ${body}; }`;
+	const stmt = ts.createSourceFile("event.ts", wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).statements[0];
+	if (!ts.isFunctionDeclaration(stmt) || !stmt.body) return {
+		has_top_level_yield_star: false,
+		has_nested_invalid_yield_star: /\byield\s*\*/.test(body)
+	};
+	const result = {
+		has_top_level_yield_star: false,
+		has_nested_invalid_yield_star: false
+	};
+	visit_event_body(stmt.body, "top_level", result);
+	return result;
+}
+/**
+* Collects free identifiers that must be captured as reactive dependencies.
+*
+* @since 2.0.0
+* @param expr_text - Markup expression text to inspect.
+* @returns Identifier names referenced by the expression.
+*/
+function collect_free_identifiers(expr_text) {
+	const wrapped = `function* __w() { return (${expr_text}); }`;
+	let sf;
+	try {
+		sf = ts.createSourceFile("expr.ts", wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	} catch {
+		return [];
+	}
+	const fn = sf.statements[0];
+	if (!ts.isFunctionDeclaration(fn) || !fn.body) return [];
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	visit_ids(fn.body, seen, ids);
+	return ids;
+}
+function visit_ids(node, seen, ids) {
+	if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) return;
+	if (ts.isIdentifier(node)) {
+		if (node.text === "yield" || node.text === "undefined" || node.text === "null" || node.text === "true" || node.text === "false" || node.text === "this") return;
+		if (is_property_access_name(node)) return;
+		if (!seen.has(node.text)) {
+			seen.add(node.text);
+			ids.push(node.text);
+		}
+		return;
+	}
+	node.forEachChild((child) => visit_ids(child, seen, ids));
+}
+function visit_event_body(node, context, result) {
+	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));
+		return;
+	}
+	if (is_nested_function_boundary(node)) {
+		const next_context = is_generator_function_boundary(node) ? "nested_generator" : "nested_invalid";
+		node.forEachChild((child) => visit_event_body(child, next_context, result));
+		return;
+	}
+	node.forEachChild((child) => visit_event_body(child, context, result));
+}
+function is_nested_function_boundary(node) {
+	return ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(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(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";
+}
+function is_property_access_name(node) {
+	const parent = node.parent;
+	return ts.isPropertyAccessExpression(parent) && parent.name === node || ts.isPropertyAssignment(parent) && parent.name === node || ts.isBindingElement(parent) && parent.propertyName === node || ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent);
+}
+//#endregion
+//#region src/markup/transform/emit.ts
+/**
+* Emits source edits for classified markup Effect expressions.
+*
+* @since 2.0.0
+* @param classified - Candidates paired with their Svelte markup context.
+* @returns Replacements ready to apply to the original component source.
+*/
+function emit_replacements(classified) {
+	return classified.map(({ candidate, kind }) => emit_replacement(candidate, kind));
+}
+function emit_replacement(candidate, kind) {
+	const id = make_cache_id(candidate);
+	const id_text = JSON.stringify(id);
+	const helper_name = make_helper_name(candidate);
+	let replacement_text;
+	let helpers;
+	let relocation;
+	if (kind === "await") {
+		const effect = make_effect_helper(candidate, helper_name);
+		replacement_text = emit_promise_expression(id_text, effect);
+		helpers = [effect.helper];
+	} else if (kind === "render") {
+		const effect = make_effect_helper(candidate, helper_name);
+		replacement_text = emit_render_expression(id_text, effect);
+		helpers = [effect.helper];
+	} else if (kind === "each") {
+		const effect = make_effect_helper(candidate, helper_name);
+		replacement_text = emit_each_expression(id_text, effect);
+		helpers = [effect.helper];
+	} else if (kind === "event") {
+		const event = strip_arrow_function(candidate.expr_text);
+		replacement_text = `${event.params} => { void ${HELPERS.run}(function* () { ${event.body}; }); }`;
+		helpers = [];
+		relocation = make_relocation(candidate, replacement_text, {
+			originalStart: event.body_start,
+			originalEnd: event.body_end,
+			generatedText: event.body
+		});
+	} else {
+		const effect = make_effect_helper(candidate, helper_name);
+		replacement_text = emit_each_expression(id_text, effect);
+		helpers = [effect.helper];
+	}
+	return {
+		start: candidate.start,
+		end: candidate.end,
+		text: replacement_text,
+		helpers,
+		relocation
+	};
+}
+function emit_promise_expression(id_text, effect) {
+	return `${HELPERS.promise}(${id_text}, ${effect.deps_text}, () => ${effect.call})`;
+}
+function emit_render_expression(id_text, effect) {
+	return `(await ${emit_promise_expression(id_text, effect)})()`;
+}
+function emit_each_expression(id_text, effect) {
+	return `await ${emit_promise_expression(id_text, effect)}`;
+}
+function make_effect_helper(candidate, helper_name) {
+	const deps = collect_free_identifiers(candidate.expr_text);
+	const params_text = deps.join(", ");
+	const args_text = deps.join(", ");
+	const deps_text = deps.length === 0 ? "[]" : `[${args_text}]`;
+	const call = `${helper_name}(${args_text})`;
+	const text = `function* ${helper_name}(${params_text}) { return (${candidate.expr_text}); }`;
+	const generated_start = text.indexOf(candidate.expr_text);
+	return {
+		call,
+		deps_text,
+		helper: {
+			text,
+			relocation: {
+				originalStart: candidate.start,
+				originalEnd: candidate.end,
+				generatedStartInReplacement: generated_start,
+				generatedEndInReplacement: generated_start + candidate.expr_text.length
+			}
+		}
+	};
+}
+function make_cache_id(candidate) {
+	return `${candidate.filename}:${candidate.start}:${candidate.end}`;
+}
+function make_helper_name(candidate) {
+	return `__ser_markup_effect_${candidate.start}_${candidate.end}`;
+}
+function make_relocation(candidate, replacement_text, inner) {
+	const generated_start = replacement_text.indexOf(inner.generatedText);
+	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
+	};
+}
+//#endregion
+//#region src/error.ts
+/**
+* Base error class for all preprocessor errors emitted during script and
+* markup transformation. Carries the source filename so error messages can
+* reference the affected file.
+*
+* @since 2.0.0
+*/
+var PreprocessError = class extends Error {
+	/**
+	* The source filename that triggered this error.
+	*
+	* @since 2.0.0
+	*/
+	filename;
+	constructor(message, filename) {
+		super(message);
+		this.name = "PreprocessError";
+		this.filename = filename;
+	}
+};
+/**
+* Thrown when `await` is used at the top level of a `<script effect>` block.
+* Top-level `await` is not supported — users should use
+* `yield* Effect.promise(...)` or `yield* Effect.tryPromise(...)` instead.
+*
+* @since 2.0.0
+*/
+var TopLevelAwaitError = class extends PreprocessError {
+	/**
+	* The full text of the problematic statement containing the `await`.
+	*
+	* @since 2.0.0
+	*/
+	statement_text;
+	constructor(filename, statement_text) {
+		super([
+			`${filename}: top-level await is not supported in <script effect>.`,
+			`Use yield* Effect.promise(...) or yield* Effect.tryPromise(...) instead.`,
+			"",
+			`Problematic statement:`,
+			statement_text
+		].join("\n"), filename);
+		this.name = "TopLevelAwaitError";
+		this.statement_text = statement_text;
+	}
+};
+/**
+* Thrown when an event handler contains `yield*` inside a nested callback that
+* is not itself a generator function.
+*
+* @example
+* ```ts
+* throw new NestedYieldStarInEventHandlerError(
+*   "Component.svelte",
+*   "Effect.try(() => yield* save())",
+* );
+* ```
+*
+* @since 2.0.0
+*/
+var NestedYieldStarInEventHandlerError = class extends PreprocessError {
+	/**
+	* The full text of the problematic event handler body.
+	*
+	* @since 2.0.0
+	*/
+	expression_text;
+	constructor(filename, expression_text) {
+		super([
+			`${filename}: yield* cannot be used inside a nested non-generator callback in a markup event handler.`,
+			`Move the yield* to the event handler body. Effect.try and Effect.sync callbacks are plain synchronous JavaScript; do not call Effect-returning functions inside them.`,
+			"",
+			`Run the remote Effect directly:`,
+			`  onclick={() => yield* UpvotePost(id)}`,
+			"",
+			`Recover from remote failures by composing the Effect value:`,
+			`  onclick={() => yield* UpvotePost(id).pipe(Effect.catch(() => Effect.void))}`,
+			"",
+			`Problematic expression:`,
+			expression_text
+		].join("\n"), filename);
+		this.name = "NestedYieldStarInEventHandlerError";
+		this.expression_text = expression_text;
+	}
+};
+//#endregion
+//#region src/markup/transform/scan.ts
+function sanitize_markup(content, filename) {
+	const candidates = [];
+	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. */
+		if (is_inside_excluded_block(content, open)) {
+			cursor = open + 1;
+			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);
+		const trimmed = inner.trimStart();
+		const leading_ws = inner.length - trimmed.length;
+		const tag_info = get_tag_info(trimmed);
+		const declaration_initializers = collect_declaration_initializers(content, open, leading_ws, trimmed);
+		if (declaration_initializers.length > 0) {
+			for (const initializer of declaration_initializers) {
+				const placeholder = `__ser_markup_placeholder_${helper_index}`;
+				helper_index += 1;
+				candidates.push({
+					placeholder,
+					start: initializer.start,
+					end: initializer.end,
+					expr_text: initializer.expr_text,
+					filename,
+					key: "plain"
+				});
+				magic.overwrite(initializer.start, initializer.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_expression(inner) ? analyze_event_yield(inner, filename) : void 0)?.has_top_level_yield_star ?? contains_yield_star_in_text(expr_body))) {
+			cursor = close + 1;
+			continue;
+		}
+		/** The expression starts after the tag prefix. For @const, after the `=`. */
+		let extra_prefix = 0;
+		if (equal_idx !== -1) {
+			const after_eq_raw = expr_body.slice(equal_idx + 1);
+			expr_body = after_eq_raw.trimStart();
+			extra_prefix = equal_idx + 1 + (after_eq_raw.length - expr_body.length);
+		}
+		const expr_start = open + 1 + leading_ws + tag_info.prefix_length + extra_prefix;
+		/** For each/await, the expression ends before ` as ` or ` then `/` catch `. */
+		let expr_end = close;
+		const key = tag_info.kind;
+		if (key === "each") {
+			const as_idx = expr_body.lastIndexOf(" as ");
+			if (as_idx !== -1) expr_end = expr_start + as_idx;
+		}
+		if (key === "await") {
+			const then_idx = expr_body.indexOf(" then ");
+			const catch_idx = expr_body.indexOf(" catch ");
+			const boundary = Math.min(then_idx === -1 ? Infinity : then_idx, catch_idx === -1 ? Infinity : catch_idx);
+			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;
+		}
+		/** Create a placeholder and replace the expression (preserving tag prefixes). */
+		const placeholder = `__ser_markup_placeholder_${helper_index}`;
+		helper_index += 1;
+		candidates.push({
+			placeholder,
+			start: expr_start,
+			end: expr_end,
+			expr_text,
+			filename,
+			key
+		});
+		magic.overwrite(expr_start, expr_end, key === "render" ? `${placeholder}()` : placeholder);
+		cursor = close + 1;
+	}
+	return {
+		code: magic.toString(),
+		candidates
+	};
+}
+function is_inside_excluded_block(content, pos) {
+	const script = find_tag_end(content, "script", pos);
+	const style = find_tag_end(content, "style", pos);
+	return script !== void 0 && pos < script.end && pos > script.start || style !== void 0 && pos < style.end && pos > style.start;
+}
+function find_tag_end(content, tag, after_pos) {
+	const pattern = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}\\s*>`, "gi");
+	for (const match of content.matchAll(pattern)) {
+		if (match.index === void 0) continue;
+		const end_pos = match.index + match[0].length;
+		if (match.index <= after_pos && after_pos < end_pos) return {
+			start: match.index,
+			end: end_pos
+		};
+	}
+}
+/** 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",
+		prefix_length: 6
+	};
+	if (trimmed.startsWith("#await ")) return {
+		kind: "await",
+		prefix_length: 7
+	};
+	if (trimmed.startsWith("@render ")) return {
+		kind: "render",
+		prefix_length: 8
+	};
+	/** Strip prefix-only tags — the expression starts after the tag keyword. */
+	if (trimmed.startsWith("#if ")) return {
+		kind: "plain",
+		prefix_length: 4
+	};
+	if (trimmed.startsWith(":else if ")) return {
+		kind: "plain",
+		prefix_length: 9
+	};
+	if (trimmed.startsWith("#key ")) return {
+		kind: "plain",
+		prefix_length: 5
+	};
+	if (trimmed.startsWith("@const ")) return {
+		kind: "plain",
+		prefix_length: 7
+	};
+	if (trimmed.startsWith("@html ")) return {
+		kind: "plain",
+		prefix_length: 6
+	};
+	if (trimmed.startsWith("@debug ")) return {
+		kind: "plain",
+		prefix_length: 7
+	};
+	return {
+		kind: "plain",
+		prefix_length: 0
+	};
+}
+function collect_declaration_initializers(content, open, leading_ws, trimmed) {
+	if (!is_declaration_tag_text(trimmed)) return [];
+	const source_file = ts.createSourceFile("declaration-tag.ts", `${trimmed};`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const stmt = source_file.statements[0];
+	if (!stmt || !ts.isVariableStatement(stmt)) return [];
+	const tag_start = open + 1 + leading_ws;
+	return stmt.declarationList.declarations.filter((decl) => decl.initializer && contains_top_level_yield_star(decl.initializer)).map((decl) => {
+		const initializer = decl.initializer;
+		const start = tag_start + initializer.getStart(source_file);
+		const end = tag_start + initializer.end;
+		return {
+			start,
+			end,
+			expr_text: content.slice(start, end).trim()
+		};
+	});
+}
+function is_declaration_tag_text(trimmed) {
+	return /^(?:const|let)\s/.test(trimmed);
+}
+function is_event_expression(inner) {
+	const trimmed = inner.trimStart();
+	return /^(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/.test(trimmed);
+}
+function analyze_event_yield(inner, filename) {
+	const event = strip_arrow_function(inner);
+	const analysis = analyze_event_body_yield_star(event.body);
+	if (analysis.has_nested_invalid_yield_star) throw new NestedYieldStarInEventHandlerError(filename, event.body);
+	return { has_top_level_yield_star: analysis.has_top_level_yield_star };
+}
+function contains_yield_star_in_text(text) {
+	if (!/\byield\s*\*/.test(text)) return false;
+	try {
+		const stmt = ts.createSourceFile("expr.ts", `const x = ${text};`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).statements[0];
+		if (!ts.isVariableStatement(stmt)) return false;
+		const decl = stmt.declarationList.declarations[0];
+		if (!decl?.initializer) return false;
+		return contains_top_level_yield_star(decl.initializer);
+	} catch {
+		return true;
+	}
+}
+/** Free identifier collection helpers for generated closures. */
+//#endregion
+//#region src/markup/transform/index.ts
+/**
+* Transforms Svelte markup containing `{yield* expr}` brace expressions
+* into calls to the markup runtime helpers (`value`, `promise`, `run`).
+*
+* Strategy: first find all brace expressions containing `yield*` via
+* character scanning, replace them with placeholder identifiers, then
+* parse the sanitized markup with Svelte's AST to determine the correct
+* context for each placeholder (plain expression, #each, #await, event
+* handler, etc.).
+*
+* @since 2.0.0
+* @param content - The raw `.svelte` file content.
+* @param filename - The source filename, used in error messages.
+* @returns The transformed markup and a flag indicating whether yield* was
+*   found.
+*/
+function transform_markup_effect(content, filename) {
+	if (!/\byield\s*\*/.test(content)) return {
+		code: content,
+		has_yield: false
+	};
+	/** Find all brace expressions containing yield* and replace with placeholders. */
+	const work = sanitize_markup(content, filename);
+	if (work.candidates.length === 0) return {
+		code: content,
+		has_yield: false
+	};
+	const replacements = emit_replacements(classify_candidates(parse(blank_script_blocks(work.code), {
+		filename,
+		modern: true
+	}), work.candidates));
+	const helpers = replacements.flatMap((replacement) => replacement.helpers ?? []);
+	const magic = new MagicString(content);
+	replacements.sort((a, b) => b.start - a.start);
+	for (const r of replacements) magic.overwrite(r.start, r.end, r.text);
+	const relocations = create_relocations(replacements, inject_helpers(magic, content, helpers));
+	return {
+		code: magic.toString(),
+		has_yield: true,
+		map: create_source_map(magic, filename),
+		relocations
+	};
+}
+//#endregion
+export { TopLevelAwaitError as n, transform_markup_effect as t };
+
+//# sourceMappingURL=transform-BtlxgJrg.js.map