svelte-effect-runtime 2.4.0 → 2.5.0

package/.dist/chunks/{transform-s9gKPYu5.js → transform-Cx5bjmP6.js}

@@ -2,6 +2,88 @@ 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/preprocess/imports.ts
+/**
+* Builds the import statements injected by the script preprocessor.
+*
+* @since 2.0.0
+* @param has_effect_import - Whether the user already imports `Effect`.
+* @param has_dispatcher_import - Whether the user already imports
+*   `get_dispatcher`.
+* @param has_untrack_import - Whether the user already imports `untrack`.
+* @returns Newline-separated import statements to inject.
+*/
+function make_imports(has_effect_import, has_dispatcher_import, has_untrack_import, bindings = {
+	cancel: "__SER___cancel",
+	dispatcher: "get_dispatcher",
+	dispatcher_value: "__SER___dispatcher",
+	effect: "Effect",
+	program: "__SER___program",
+	untrack: "untrack"
+}) {
+	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 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 [
+		!has_dispatcher_import && dispatcher_import,
+		!has_untrack_import && untrack_import,
+		effect_import
+	].filter(Boolean).join("\n");
+}
+/**
+* Checks whether a source file imports a local binding from a module.
+*
+* @since 2.0.0
+* @param source_file - Parsed TypeScript source file to inspect.
+* @param module_name - Module specifier to match.
+* @param local_name - Local binding name to look for.
+* @returns Whether that binding is already locally available.
+*/
+function has_local_import_binding(source_file, module_name, local_name) {
+	return source_file.statements.some((stmt) => {
+		if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier) || stmt.moduleSpecifier.text !== module_name) return false;
+		const clause = stmt.importClause;
+		if (!clause || clause.isTypeOnly) return false;
+		if (clause.name?.text === local_name) return true;
+		const named_bindings = clause.namedBindings;
+		if (!named_bindings) return false;
+		if (ts.isNamespaceImport(named_bindings)) return named_bindings.name.text === local_name;
+		return named_bindings.elements.some((element) => !element.isTypeOnly && element.name.text === local_name);
+	});
+}
+/**
+* Collects every local binding declared at module top level.
+*
+* @since 2.4.2
+* @param source_file - Parsed TypeScript source file to inspect.
+* @returns Top-level names declared by imports, declarations, and variables.
+*/
+function collect_top_level_binding_names(source_file) {
+	return source_file.statements.flatMap(collect_statement_binding_names);
+}
+function collect_statement_binding_names(stmt) {
+	if (ts.isImportDeclaration(stmt)) return collect_import_binding_names(stmt);
+	if (ts.isVariableStatement(stmt)) return stmt.declarationList.declarations.flatMap((decl) => collect_binding_name_text(decl.name));
+	if (ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt) || ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt) || ts.isEnumDeclaration(stmt) || ts.isModuleDeclaration(stmt)) return stmt.name ? [stmt.name.text] : [];
+	return [];
+}
+function collect_import_binding_names(stmt) {
+	const clause = stmt.importClause;
+	if (!clause) return [];
+	return [
+		clause.name?.text,
+		clause.namedBindings && ts.isNamespaceImport(clause.namedBindings) ? clause.namedBindings.name.text : void 0,
+		clause.namedBindings && ts.isNamedImports(clause.namedBindings) ? clause.namedBindings.elements.map((element) => element.name.text) : void 0
+	].flat().filter((name) => name !== void 0);
+}
+function collect_binding_name_text(name) {
+	if (ts.isIdentifier(name)) return [name.text];
+	return name.elements.flatMap((element) => {
+		if (ts.isOmittedExpression(element)) return [];
+		return collect_binding_name_text(element.name);
+	});
+}
+//#endregion
 //#region src/markup/transform/constants.ts
 const HELPERS = {
 	value: "__SER___markup_value",
@@ -22,14 +104,13 @@ function blank_script_blocks(content) {
 		return match.split("\n").map((l) => " ".repeat(l.length)).join("\n");
 	});
 }
-function inject_helpers(magic, content, helpers = []) {
-	if (content.includes(HELPERS.value)) return;
+function inject_helpers(magic, content, helpers = [], bindings = HELPERS) {
 	const import_helpers = unique_import_helpers(helpers);
 	const local_helpers = helpers.filter((helper) => !is_import_helper(helper));
 	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";`,
+		`import { value as ${bindings.value} } from "svelte-effect-runtime/internal/generators";`,
+		`import { promise as ${bindings.promise} } from "svelte-effect-runtime/internal/generators";`,
+		`import { run as ${bindings.run} } from "svelte-effect-runtime/internal/generators";`,
 		...import_helpers,
 		...local_helpers
 	].map((helper) => typeof helper === "string" ? { text: helper } : helper);
@@ -53,6 +134,18 @@ function inject_helpers(magic, content, helpers = []) {
 		};
 	}
 }
+function make_markup_helper_bindings(content) {
+	const script_tag = find_instance_script_tag(content);
+	const name_allocator = make_name_allocator(script_tag ? collect_script_binding_names(content.slice(script_tag.start, script_tag.end)) : []);
+	return {
+		bindings: {
+			value: name_allocator.reserve(HELPERS.value),
+			promise: name_allocator.reserve(HELPERS.promise),
+			run: name_allocator.reserve(HELPERS.run)
+		},
+		name_allocator
+	};
+}
 function create_relocations(replacements, helper_insertion) {
 	const edits = [helper_insertion && {
 		start: helper_insertion.start,
@@ -120,6 +213,22 @@ function unique_import_helpers(helpers) {
 function is_import_helper(helper) {
 	return helper.text.trimStart().startsWith("import ");
 }
+function collect_script_binding_names(script_content) {
+	return collect_top_level_binding_names(ts.createSourceFile("markup-script.ts", script_content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS));
+}
+function make_name_allocator(initial_names) {
+	const used_names = new Set(initial_names);
+	return { reserve(name) {
+		let candidate = name;
+		let suffix = 1;
+		while (used_names.has(candidate)) {
+			candidate = `${name}_${suffix}`;
+			suffix += 1;
+		}
+		used_names.add(candidate);
+		return candidate;
+	} };
+}
 //#endregion
 //#region src/markup/transform/classify.ts
 /**
@@ -168,9 +277,7 @@ function visit_ast_node(node, candidates, matched, classified) {
 		case "HtmlTag":
 			classify_expression(node.expression, "plain", candidates, matched, classified);
 			return;
-		case "DebugTag":
-			classify_debug_tag(node, candidates, matched, classified);
-			return;
+		case "DebugTag": return;
 		case "ConstTag":
 		case "DeclarationTag":
 			classify_declaration_tag(node, candidates, matched, classified);
@@ -198,11 +305,6 @@ function visit_ast_node(node, candidates, matched, classified) {
 		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;
@@ -240,10 +342,14 @@ function classify_expression(expression, kind, candidates, matched, classified)
 		matched.add(candidate.placeholder);
 		classified.push({
 			candidate,
-			kind
+			kind: resolve_candidate_kind(candidate, kind)
 		});
 	}
 }
+function resolve_candidate_kind(candidate, context_kind) {
+	if (candidate.key === "render_argument") return "render_argument";
+	return context_kind;
+}
 function find_candidates(expression, candidates) {
 	const found = [];
 	visit_expression_value(expression, candidates, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), found);
@@ -589,6 +695,39 @@ var YieldStarInEventCallbackError = class extends PreprocessError {
 		this.expression_text = expression_text;
 	}
 };
+/**
+* Thrown when async Effect work appears in a markup position SER cannot lower
+* safely.
+*
+* @example
+* ```ts
+* throw new UnsupportedMarkupEffectPositionError(
+*   "Component.svelte",
+*   "value={yield* load()}",
+* );
+* ```
+*
+* @since 2.4.2
+*/
+var UnsupportedMarkupEffectPositionError = class extends PreprocessError {
+	/**
+	* The unsupported markup expression text.
+	*
+	* @since 2.4.2
+	*/
+	expression_text;
+	constructor(filename, expression_text) {
+		super([
+			make_error_message("UNSUPPORTED_MARKUP_EFFECT_POSITION", `${filename}: yield* cannot be used in this markup position.`),
+			`Move the Effect work into a supported expression tag, block expression, render expression, declaration tag, or event handler.`,
+			"",
+			`Problematic expression:`,
+			expression_text
+		].join("\n"), filename);
+		this.name = "UnsupportedMarkupEffectPositionError";
+		this.expression_text = expression_text;
+	}
+};
 //#endregion
 //#region src/markup/transform/expressions.ts
 /**
@@ -693,22 +832,45 @@ function collect_free_identifiers(expr_text) {
 	const fn = sf.statements[0];
 	if (!ts.isFunctionDeclaration(fn) || !fn.body) return [];
 	const ids = [];
+	const locals = /* @__PURE__ */ new Set();
 	const seen = /* @__PURE__ */ new Set();
-	visit_ids(fn.body, seen, ids);
+	visit_ids(fn.body, locals, seen, ids);
 	return ids;
 }
-function visit_ids(node, seen, ids) {
-	if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) return;
+function visit_ids(node, locals, seen, ids) {
+	if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) {
+		const scoped = new Set(locals);
+		if (ts.isFunctionDeclaration(node) && node.name) scoped.add(node.name.text);
+		for (const parameter of node.parameters) add_binding_names(parameter.name, scoped);
+		if (node.body) visit_ids(node.body, scoped, seen, ids);
+		return;
+	}
+	if (ts.isVariableDeclaration(node)) {
+		if (node.initializer) visit_ids(node.initializer, locals, seen, ids);
+		add_binding_names(node.name, locals);
+		return;
+	}
+	if (ts.isTypeReferenceNode(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)) {
+		if (!locals.has(node.text) && !seen.has(node.text)) {
 			seen.add(node.text);
 			ids.push(node.text);
 		}
 		return;
 	}
-	node.forEachChild((child) => visit_ids(child, seen, ids));
+	node.forEachChild((child) => visit_ids(child, locals, seen, ids));
+}
+function add_binding_names(name, locals) {
+	if (ts.isIdentifier(name)) {
+		locals.add(name.text);
+		return;
+	}
+	for (const element of name.elements) {
+		if (ts.isOmittedExpression(element)) continue;
+		add_binding_names(element.name, locals);
+	}
 }
 function visit_event_body(node, context, result) {
 	if (is_yield_star_expression$1(node)) {
@@ -973,10 +1135,10 @@ function to_expr_pos(pos, context) {
 *   expression rewrites.
 * @returns Replacements ready to apply to the original component source.
 */
-function emit_replacements(classified, effect_context) {
-	return classified.map(({ candidate, kind }) => emit_replacement(candidate, kind, effect_context));
+function emit_replacements(classified, effect_context, helper_bindings, name_allocator) {
+	return classified.map(({ candidate, kind }) => emit_replacement(candidate, kind, effect_context, helper_bindings, name_allocator));
 }
-function emit_replacement(candidate, kind, effect_context) {
+function emit_replacement(candidate, kind, effect_context, helper_bindings, name_allocator) {
 	const normalized = normalize_effect_callback_yields(candidate.expr_text, effect_context);
 	const normalized_candidate = {
 		...candidate,
@@ -984,24 +1146,28 @@ function emit_replacement(candidate, kind, effect_context) {
 	};
 	const id = make_cache_id(candidate);
 	const id_text = JSON.stringify(id);
-	const helper_name = make_helper_name(candidate);
+	const helper_name = make_helper_name(candidate, name_allocator);
 	let replacement_text;
 	let helpers;
 	let relocation;
 	if (kind === "await") {
 		const effect = make_effect_helper(normalized_candidate, helper_name);
-		replacement_text = emit_promise_expression(id_text, effect);
+		replacement_text = emit_promise_expression(id_text, effect, helper_bindings);
 		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "render") {
 		const effect = make_effect_helper(normalized_candidate, helper_name);
-		replacement_text = emit_render_expression(id_text, effect);
+		replacement_text = emit_render_expression(id_text, effect, candidate, helper_bindings);
+		helpers = [...normalized.helpers, effect.helper];
+	} else if (kind === "render_argument") {
+		const effect = make_effect_helper(normalized_candidate, helper_name);
+		replacement_text = emit_each_expression(id_text, effect, helper_bindings);
 		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "each") {
 		const effect = make_effect_helper(normalized_candidate, helper_name);
-		replacement_text = emit_each_expression(id_text, effect);
+		replacement_text = emit_each_expression(id_text, effect, helper_bindings);
 		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "event") {
-		const event = make_event_handler(normalized_candidate);
+		const event = make_event_handler(normalized_candidate, helper_bindings);
 		replacement_text = event.text;
 		helpers = normalized.helpers;
 		relocation = make_relocation(candidate, replacement_text, {
@@ -1011,7 +1177,7 @@ function emit_replacement(candidate, kind, effect_context) {
 		});
 	} else {
 		const effect = make_effect_helper(normalized_candidate, helper_name);
-		replacement_text = emit_each_expression(id_text, effect);
+		replacement_text = emit_each_expression(id_text, effect, helper_bindings);
 		helpers = [...normalized.helpers, effect.helper];
 	}
 	return {
@@ -1022,31 +1188,32 @@ function emit_replacement(candidate, kind, effect_context) {
 		relocation
 	};
 }
-function make_event_handler(candidate) {
+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);
 	return {
 		expr_text,
-		text: `(event) => { ${HELPERS.run}(function* () { ${expr_text}; }); }`
+		text: `(event) => { ${helper_bindings.run}(function* () { ${expr_text}; }); }`
 	};
 }
-function emit_promise_expression(id_text, effect) {
-	return `${HELPERS.promise}(${id_text}, ${effect.deps_text}, () => ${effect.call})`;
+function emit_promise_expression(id_text, effect, helper_bindings) {
+	return `${helper_bindings.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_render_expression(id_text, effect, candidate, helper_bindings) {
+	const expression = emit_promise_expression(id_text, effect, helper_bindings);
+	if (/^\s*yield\s*\*/.test(candidate.expr_text)) return `(await ${expression})()`;
+	return `await ${expression}`;
 }
-function emit_each_expression(id_text, effect) {
-	return `await ${emit_promise_expression(id_text, effect)}`;
+function emit_each_expression(id_text, effect, helper_bindings) {
+	return `await ${emit_promise_expression(id_text, effect, helper_bindings)}`;
 }
 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 call = `${helper_name}()`;
+	const text = `function* ${helper_name}() { return (${candidate.expr_text}); }`;
 	const generated_start = text.indexOf(candidate.expr_text);
 	return {
 		call,
@@ -1063,10 +1230,10 @@ function make_effect_helper(candidate, helper_name) {
 	};
 }
 function make_cache_id(candidate) {
-	return `${candidate.filename}:${candidate.start}:${candidate.end}`;
+	return `${candidate.filename.replace(/[?#].*$/, "")}:${candidate.start}:${candidate.end}`;
 }
-function make_helper_name(candidate) {
-	return `__SER___markup_effect_${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);
@@ -1174,7 +1341,7 @@ function sanitize_markup(content, filename) {
 		const open = content.indexOf("{", cursor);
 		if (open === -1) break;
 		/** Skip braces inside <script> and <style> blocks. */
-		if (is_inside_excluded_block(content, open)) {
+		if (is_inside_excluded_block(content, open) || is_inside_html_comment(content, open)) {
 			cursor = open + 1;
 			continue;
 		}
@@ -1239,6 +1406,26 @@ function sanitize_markup(content, filename) {
 			cursor = close + 1;
 			continue;
 		}
+		if (key === "render" && !/^\s*yield\s*\*/.test(expr_text)) {
+			const render_arg_yields = collect_expression_yield_expressions(content, expr_start, expr_text);
+			if (render_arg_yields.length > 0) {
+				for (const render_arg_yield of render_arg_yields) {
+					const placeholder = `__SER___markup_placeholder_${helper_index}`;
+					helper_index += 1;
+					candidates.push({
+						placeholder,
+						start: render_arg_yield.start,
+						end: render_arg_yield.end,
+						expr_text: render_arg_yield.expr_text,
+						filename,
+						key: "render_argument"
+					});
+					magic.overwrite(render_arg_yield.start, render_arg_yield.end, placeholder);
+				}
+				cursor = close + 1;
+				continue;
+			}
+		}
 		/** Create a placeholder and replace the expression (preserving tag prefixes). */
 		const placeholder = `__SER___markup_placeholder_${helper_index}`;
 		helper_index += 1;
@@ -1258,11 +1445,36 @@ function sanitize_markup(content, filename) {
 		candidates
 	};
 }
+function collect_expression_yield_expressions(content, expr_start, expr_text) {
+	const source_file = ts.createSourceFile("markup-expression.ts", `const __SER___expr = ${expr_text};`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const stmt = source_file.statements[0];
+	if (!stmt || !ts.isVariableStatement(stmt)) return [];
+	const initializer = stmt.declarationList.declarations[0]?.initializer;
+	if (!initializer || !contains_top_level_yield_star(initializer)) return [];
+	const prefix_length = source_file.text.indexOf(expr_text);
+	const expressions = [];
+	collect_yield_star_nodes(initializer, (yield_node) => {
+		const start = expr_start + yield_node.getStart(source_file) - prefix_length;
+		const end = expr_start + yield_node.end - prefix_length;
+		const yielded_text = content.slice(start, end).trim();
+		expressions.push({
+			start,
+			end,
+			expr_text: yielded_text
+		});
+	});
+	return expressions;
+}
 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 is_inside_html_comment(content, pos) {
+	const open = content.lastIndexOf("<!--", pos);
+	const close = content.lastIndexOf("-->", pos);
+	return open !== -1 && open > close;
+}
 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)) {
@@ -1388,6 +1600,7 @@ function is_event_callback_expression(inner) {
 function analyze_event_yield(inner) {
 	const event = strip_arrow_function(inner);
 	const analysis = analyze_event_body_yield_star(event.body);
+	if (new RegExp(`${HELPERS.run}(?:_\\d+)?\\(function\\*`).test(event.body)) return { has_top_level_yield_star: false };
 	return { has_top_level_yield_star: analysis.has_top_level_yield_star || analysis.has_nested_invalid_yield_star || /\byield\s*\*/.test(event.body) };
 }
 function contains_yield_star_in_text(text) {
@@ -1429,19 +1642,25 @@ function transform_markup_effect(content, filename) {
 	/** Find all brace expressions containing yield* and replace with placeholders. */
 	const work = sanitize_markup(content, filename);
 	const effect_context = collect_effect_callback_bindings(content);
+	const helper_context = make_markup_helper_bindings(content);
 	if (work.candidates.length === 0) return {
 		code: content,
 		has_yield: false
 	};
-	const replacements = emit_replacements(classify_candidates(parse(blank_script_blocks(work.code), {
+	/** Match placeholders to their AST context and build replacements. */
+	const classified = classify_candidates(parse(blank_script_blocks(work.code), {
 		filename,
 		modern: true
-	}), work.candidates), effect_context);
+	}), work.candidates);
+	const matched = new Set(classified.map(({ candidate }) => candidate.placeholder));
+	const unmatched = work.candidates.find((candidate) => !matched.has(candidate.placeholder));
+	if (unmatched) throw new UnsupportedMarkupEffectPositionError(filename, unmatched.expr_text);
+	const replacements = emit_replacements(classified, effect_context, helper_context.bindings, helper_context.name_allocator);
 	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));
+	const relocations = create_relocations(replacements, inject_helpers(magic, content, helpers, helper_context.bindings));
 	return {
 		code: magic.toString(),
 		has_yield: true,
@@ -1450,6 +1669,6 @@ function transform_markup_effect(content, filename) {
 	};
 }
 //#endregion
-export { find_yield_star_node as a, AsyncEffectInSyncRuneError as c, extract_binding_names as i, AwaitInEffectWorkError as l, collect_yield_star_nodes as n, is_yield_star_expression as o, contains_top_level_await as r, collect_free_identifiers as s, transform_markup_effect as t };
+export { find_yield_star_node as a, AsyncEffectInSyncRuneError as c, collect_top_level_binding_names as d, has_local_import_binding as f, extract_binding_names as i, AwaitInEffectWorkError as l, collect_yield_star_nodes as n, is_yield_star_expression as o, make_imports as p, contains_top_level_await as r, collect_free_identifiers as s, transform_markup_effect as t, PreprocessError as u };
 
-//# sourceMappingURL=transform-s9gKPYu5.js.map
+//# sourceMappingURL=transform-Cx5bjmP6.js.map