lumen-plus 0.0.4 → 0.0.5

package/dist/utils/node_modules/svelte/src/compiler/migrate/index.js

@@ -1,1996 +0,0 @@
-/** @import { VariableDeclarator, Node, Identifier, AssignmentExpression, LabeledStatement, ExpressionStatement } from 'estree' */
-/** @import { Visitors } from 'zimmerframe' */
-/** @import { ComponentAnalysis } from '../phases/types.js' */
-/** @import { Scope } from '../phases/scope.js' */
-/** @import { AST, Binding, ValidatedCompileOptions } from '#compiler' */
-import MagicString from 'magic-string';
-import { walk } from 'zimmerframe';
-import { parse } from '../phases/1-parse/index.js';
-import { regex_valid_component_name } from '../phases/1-parse/state/element.js';
-import { analyze_component } from '../phases/2-analyze/index.js';
-import { get_rune } from '../phases/scope.js';
-import { reset, UNKNOWN_FILENAME } from '../state.js';
-import {
-	extract_identifiers,
-	extract_all_identifiers_from_expression,
-	is_text_attribute
-} from '../utils/ast.js';
-import { migrate_svelte_ignore } from '../utils/extract_svelte_ignore.js';
-import { validate_component_options } from '../validate-options.js';
-import { is_reserved, is_svg, is_void } from '../../utils.js';
-import { regex_is_valid_identifier } from '../phases/patterns.js';
-
-const regex_style_tags = /(<style[^>]+>)([\S\s]*?)(<\/style>)/g;
-const style_placeholder = '/*$$__STYLE_CONTENT__$$*/';
-
-let has_migration_task = false;
-
-class MigrationError extends Error {
-	/**
-	 * @param {string} msg
-	 */
-	constructor(msg) {
-		super(msg);
-	}
-}
-
-/**
- *
- * @param {State} state
- */
-function migrate_css(state) {
-	if (!state.analysis.css.ast?.start) return;
-	const css_contents = state.str
-		.snip(state.analysis.css.ast.start, /** @type {number} */ (state.analysis.css.ast?.end))
-		.toString();
-	let code = css_contents;
-	let starting = 0;
-
-	// since we already blank css we can't work directly on `state.str` so we will create a copy that we can update
-	const str = new MagicString(code);
-	while (code) {
-		if (
-			code.startsWith(':has') ||
-			code.startsWith(':is') ||
-			code.startsWith(':where') ||
-			code.startsWith(':not')
-		) {
-			let start = code.indexOf('(') + 1;
-			let is_global = false;
-
-			const global_str = ':global';
-			const next_global = code.indexOf(global_str);
-			const str_between = code.substring(start, next_global);
-			if (!str_between.trim()) {
-				is_global = true;
-				start += global_str.length;
-			} else {
-				const prev_global = css_contents.lastIndexOf(global_str, starting);
-				if (prev_global > -1) {
-					const end =
-						find_closing_parenthesis(css_contents.indexOf('(', prev_global) + 1, css_contents) -
-						starting;
-					if (end > start) {
-						starting += end;
-						code = code.substring(end);
-						continue;
-					}
-				}
-			}
-
-			const end = find_closing_parenthesis(start, code);
-			if (start && end) {
-				if (!is_global && !code.startsWith(':not')) {
-					str.prependLeft(starting + start, ':global(');
-					str.appendRight(starting + end - 1, ')');
-				}
-				starting += end - 1;
-				code = code.substring(end - 1);
-				continue;
-			}
-		}
-		starting++;
-		code = code.substring(1);
-	}
-	state.str.update(state.analysis.css.ast?.start, state.analysis.css.ast?.end, str.toString());
-}
-
-/**
- * @param {number} start
- * @param {string} code
- */
-function find_closing_parenthesis(start, code) {
-	let parenthesis = 1;
-	let end = start;
-	let char = code[end];
-	// find the closing parenthesis
-	while (parenthesis !== 0 && char) {
-		if (char === '(') parenthesis++;
-		if (char === ')') parenthesis--;
-		end++;
-		char = code[end];
-	}
-	return end;
-}
-
-/**
- * Does a best-effort migration of Svelte code towards using runes, event attributes and render tags.
- * May throw an error if the code is too complex to migrate automatically.
- *
- * @param {string} source
- * @param {{ filename?: string, use_ts?: boolean }} [options]
- * @returns {{ code: string; }}
- */
-export function migrate(source, { filename, use_ts } = {}) {
-	let og_source = source;
-	try {
-		has_migration_task = false;
-		// Blank CSS, could contain SCSS or similar that needs a preprocessor.
-		// Since we don't care about CSS in this migration, we'll just ignore it.
-		/** @type {Array<[number, string]>} */
-		const style_contents = [];
-		source = source.replace(regex_style_tags, (_, start, content, end, idx) => {
-			style_contents.push([idx + start.length, content]);
-			return start + style_placeholder + end;
-		});
-
-		reset({ warning: () => false, filename });
-
-		let parsed = parse(source);
-
-		const { customElement: customElementOptions, ...parsed_options } = parsed.options || {};
-
-		/** @type {ValidatedCompileOptions} */
-		const combined_options = {
-			...validate_component_options({}, ''),
-			...parsed_options,
-			customElementOptions,
-			filename: filename ?? UNKNOWN_FILENAME,
-			experimental: {
-				async: true
-			}
-		};
-
-		const str = new MagicString(source);
-		const analysis = analyze_component(parsed, source, combined_options);
-		const indent = guess_indent(source);
-
-		str.replaceAll(/(<svelte:options\s.*?\s?)accessors\s?/g, (_, $1) => $1);
-
-		for (const content of style_contents) {
-			str.overwrite(content[0], content[0] + style_placeholder.length, content[1]);
-		}
-
-		/** @type {State} */
-		let state = {
-			scope: analysis.instance.scope,
-			analysis,
-			filename,
-			str,
-			indent,
-			props: [],
-			props_insertion_point: parsed.instance?.content.start ?? 0,
-			has_props_rune: false,
-			has_type_or_fallback: false,
-			end: source.length,
-			names: {
-				props: analysis.root.unique('props').name,
-				rest: analysis.root.unique('rest').name,
-
-				// event stuff
-				run: analysis.root.unique('run').name,
-				handlers: analysis.root.unique('handlers').name,
-				stopImmediatePropagation: analysis.root.unique('stopImmediatePropagation').name,
-				preventDefault: analysis.root.unique('preventDefault').name,
-				stopPropagation: analysis.root.unique('stopPropagation').name,
-				once: analysis.root.unique('once').name,
-				self: analysis.root.unique('self').name,
-				trusted: analysis.root.unique('trusted').name,
-				createBubbler: analysis.root.unique('createBubbler').name,
-				bubble: analysis.root.unique('bubble').name,
-				passive: analysis.root.unique('passive').name,
-				nonpassive: analysis.root.unique('nonpassive').name
-			},
-			legacy_imports: new Set(),
-			script_insertions: new Set(),
-			derived_components: new Map(),
-			derived_conflicting_slots: new Map(),
-			derived_labeled_statements: new Set(),
-			has_svelte_self: false,
-			uses_ts:
-				// Some people could use jsdoc but have a tsconfig.json, so double-check file for jsdoc indicators
-				(use_ts && !source.includes('@type {')) ||
-				!!parsed.instance?.attributes.some(
-					(attr) => attr.name === 'lang' && /** @type {any} */ (attr).value[0].data === 'ts'
-				)
-		};
-
-		if (parsed.module) {
-			const context = parsed.module.attributes.find((attr) => attr.name === 'context');
-			if (context) {
-				state.str.update(context.start, context.end, 'module');
-			}
-		}
-
-		if (parsed.instance) {
-			walk(parsed.instance.content, state, instance_script);
-		}
-
-		state = { ...state, scope: analysis.template.scope };
-		walk(parsed.fragment, state, template);
-
-		let insertion_point = parsed.instance
-			? /** @type {number} */ (parsed.instance.content.start)
-			: 0;
-
-		const need_script =
-			state.legacy_imports.size > 0 ||
-			state.derived_components.size > 0 ||
-			state.derived_conflicting_slots.size > 0 ||
-			state.script_insertions.size > 0 ||
-			state.props.length > 0 ||
-			analysis.uses_rest_props ||
-			analysis.uses_props ||
-			state.has_svelte_self;
-
-		const need_ts_tag =
-			state.uses_ts &&
-			(!parsed.instance || !parsed.instance.attributes.some((attr) => attr.name === 'lang'));
-
-		if (!parsed.instance && need_script) {
-			str.appendRight(0, need_ts_tag ? '<script lang="ts">' : '<script>');
-		}
-
-		if (state.has_svelte_self && filename) {
-			const file = filename.split('/').pop();
-			str.appendRight(
-				insertion_point,
-				`\n${indent}import ${state.analysis.name} from './${file}';`
-			);
-		}
-
-		const specifiers = [...state.legacy_imports].map((imported) => {
-			const local = state.names[imported];
-			return imported === local ? imported : `${imported} as ${local}`;
-		});
-
-		const legacy_import = `import { ${specifiers.join(', ')} } from 'svelte/legacy';\n`;
-
-		if (state.legacy_imports.size > 0) {
-			str.appendRight(insertion_point, `\n${indent}${legacy_import}`);
-		}
-
-		if (state.script_insertions.size > 0) {
-			str.appendRight(
-				insertion_point,
-				`\n${indent}${[...state.script_insertions].join(`\n${indent}`)}`
-			);
-		}
-
-		insertion_point = state.props_insertion_point;
-
-		/**
-		 * @param {"derived"|"props"|"bindable"} rune
-		 */
-		function check_rune_binding(rune) {
-			const has_rune_binding = !!state.scope.get(rune);
-			if (has_rune_binding) {
-				throw new MigrationError(
-					`migrating this component would require adding a \`$${rune}\` rune but there's already a variable named ${rune}.\n     Rename the variable and try again or migrate by hand.`
-				);
-			}
-		}
-
-		if (state.props.length > 0 || analysis.uses_rest_props || analysis.uses_props) {
-			const has_many_props = state.props.length > 3;
-			const newline_separator = `\n${indent}${indent}`;
-			const props_separator = has_many_props ? newline_separator : ' ';
-			let props = '';
-			if (analysis.uses_props) {
-				props = `...${state.names.props}`;
-			} else {
-				props = state.props
-					.filter((prop) => !prop.type_only)
-					.map((prop) => {
-						let prop_str =
-							prop.local === prop.exported ? prop.local : `${prop.exported}: ${prop.local}`;
-						if (prop.bindable) {
-							check_rune_binding('bindable');
-							prop_str += ` = $bindable(${prop.init})`;
-						} else if (prop.init) {
-							prop_str += ` = ${prop.init}`;
-						}
-						return prop_str;
-					})
-					.join(`,${props_separator}`);
-
-				if (analysis.uses_rest_props) {
-					props += `${state.props.length > 0 ? `,${props_separator}` : ''}...${state.names.rest}`;
-				}
-			}
-
-			if (state.has_props_rune) {
-				// some render tags or forwarded event attributes to add
-				str.appendRight(insertion_point, ` ${props},`);
-			} else {
-				const type_name = state.scope.root.unique('Props').name;
-				let type = '';
-
-				// Try to infer when we don't want to add types (e.g. user doesn't use types, or this is a zero-types +page.svelte)
-				if (state.has_type_or_fallback || state.props.every((prop) => prop.slot_name)) {
-					if (state.uses_ts) {
-						type = `interface ${type_name} {${newline_separator}${state.props
-							.map((prop) => {
-								const comment = prop.comment ? `${prop.comment}${newline_separator}` : '';
-								return `${comment}${prop.exported}${prop.optional ? '?' : ''}: ${prop.type};${prop.trailing_comment ? ' ' + prop.trailing_comment : ''}`;
-							})
-							.join(newline_separator)}`;
-						if (analysis.uses_props || analysis.uses_rest_props) {
-							type += `${state.props.length > 0 ? newline_separator : ''}[key: string]: any`;
-						}
-						type += `\n${indent}}`;
-					} else {
-						type = `/**\n${indent} * @typedef {Object} ${type_name}${state.props
-							.map((prop) => {
-								return `\n${indent} * @property {${prop.type}} ${prop.optional ? `[${prop.exported}]` : prop.exported}${prop.comment ? ` - ${prop.comment}` : ''}${prop.trailing_comment ? ` - ${prop.trailing_comment.trim()}` : ''}`;
-							})
-							.join(``)}\n${indent} */`;
-					}
-				}
-
-				let props_declaration = `let {${props_separator}${props}${has_many_props ? `\n${indent}` : ' '}}`;
-				if (state.uses_ts) {
-					if (type) {
-						props_declaration = `${type}\n\n${indent}${props_declaration}`;
-					}
-					check_rune_binding('props');
-					props_declaration = `${props_declaration}${type ? `: ${type_name}` : ''} = $props();`;
-				} else {
-					if (type) {
-						props_declaration = `${state.props.length > 0 ? `${type}\n\n${indent}` : ''}/** @type {${state.props.length > 0 ? type_name : ''}${analysis.uses_props || analysis.uses_rest_props ? `${state.props.length > 0 ? ' & ' : ''}{ [key: string]: any }` : ''}} */\n${indent}${props_declaration}`;
-					}
-					check_rune_binding('props');
-					props_declaration = `${props_declaration} = $props();`;
-				}
-
-				props_declaration = `\n${indent}${props_declaration}`;
-				str.appendRight(insertion_point, props_declaration);
-			}
-
-			if (parsed.instance && need_ts_tag) {
-				str.appendRight(parsed.instance.start + '<script'.length, ' lang="ts"');
-			}
-		}
-
-		/**
-		 * If true, then we need to move all reactive statements to the end of the script block,
-		 * in their correct order. Svelte 4 reordered reactive statements, $derived/$effect.pre
-		 * don't have this behavior.
-		 */
-		let needs_reordering = false;
-
-		for (const [node, { dependencies }] of state.analysis.reactive_statements) {
-			/** @type {Binding[]} */
-			let ids = [];
-			if (
-				node.body.type === 'ExpressionStatement' &&
-				node.body.expression.type === 'AssignmentExpression'
-			) {
-				ids = extract_identifiers(node.body.expression.left)
-					.map((id) => state.scope.get(id.name))
-					.filter((id) => !!id);
-			}
-
-			if (
-				dependencies.some(
-					(dep) =>
-						!ids.includes(dep) &&
-						(dep.kind === 'prop' || dep.kind === 'bindable_prop'
-							? state.props_insertion_point
-							: /** @type {number} */ (dep.node.start)) > /** @type {number} */ (node.start)
-				)
-			) {
-				needs_reordering = true;
-				break;
-			}
-		}
-
-		if (needs_reordering) {
-			const nodes = Array.from(state.analysis.reactive_statements.keys());
-			for (const node of nodes) {
-				const { start, end } = get_node_range(source, node);
-				str.appendLeft(end, '\n');
-				str.move(start, end, /** @type {number} */ (parsed.instance?.content.end));
-				str.update(start - (source[start - 2] === '\r' ? 2 : 1), start, '');
-			}
-		}
-
-		insertion_point = parsed.instance
-			? /** @type {number} */ (parsed.instance.content.end)
-			: insertion_point;
-
-		if (state.derived_components.size > 0) {
-			check_rune_binding('derived');
-			str.appendRight(
-				insertion_point,
-				`\n${indent}${[...state.derived_components.entries()].map(([init, name]) => `const ${name} = $derived(${init});`).join(`\n${indent}`)}\n`
-			);
-		}
-
-		if (state.derived_conflicting_slots.size > 0) {
-			check_rune_binding('derived');
-			str.appendRight(
-				insertion_point,
-				`\n${indent}${[...state.derived_conflicting_slots.entries()].map(([name, init]) => `const ${name} = $derived(${init});`).join(`\n${indent}`)}\n`
-			);
-		}
-
-		if (state.props.length > 0 && state.analysis.accessors) {
-			str.appendRight(
-				insertion_point,
-				`\n${indent}export {${state.props.reduce((acc, prop) => (prop.slot_name || prop.type_only ? acc : `${acc}\n${indent}\t${prop.local},`), '')}\n${indent}}\n`
-			);
-		}
-
-		if (!parsed.instance && need_script) {
-			str.appendRight(insertion_point, '\n</script>\n\n');
-		}
-		migrate_css(state);
-		return {
-			code: str.toString()
-		};
-	} catch (e) {
-		if (!(e instanceof MigrationError)) {
-			// eslint-disable-next-line no-console
-			console.error('Error while migrating Svelte code', e);
-		}
-		has_migration_task = true;
-		return {
-			code: `<!-- @migration-task Error while migrating Svelte code: ${/** @type {any} */ (e).message} -->\n${og_source}`
-		};
-	} finally {
-		if (has_migration_task) {
-			// eslint-disable-next-line no-console
-			console.log(
-				`One or more \`@migration-task\` comments were added to ${filename ? `\`${filename}\`` : "a file (unfortunately we don't know the name)"}, please check them and complete the migration manually.`
-			);
-		}
-	}
-}
-
-/**
- * @typedef {{
- *  scope: Scope;
- *  str: MagicString;
- *  analysis: ComponentAnalysis;
- *  filename?: string;
- *  indent: string;
- *  props: Array<{ local: string; exported: string; init: string; bindable: boolean; slot_name?: string; optional: boolean; type: string; comment?: string; trailing_comment?: string; type_only?: boolean; needs_refine_type?: boolean; }>;
- *  props_insertion_point: number;
- *  has_props_rune: boolean;
- *  has_type_or_fallback: boolean;
- *  end: number;
- * 	names: Record<string, string>;
- * 	legacy_imports: Set<string>;
- * 	script_insertions: Set<string>;
- *  derived_components: Map<string, string>;
- *  derived_conflicting_slots: Map<string, string>;
- * 	derived_labeled_statements: Set<LabeledStatement>;
- *  has_svelte_self: boolean;
- *  uses_ts: boolean;
- * }} State
- */
-
-/** @type {Visitors<AST.SvelteNode, State>} */
-const instance_script = {
-	_(node, { state, next }) {
-		// @ts-expect-error
-		const comments = node.leadingComments;
-		if (comments) {
-			for (const comment of comments) {
-				if (comment.type === 'Line') {
-					const migrated = migrate_svelte_ignore(comment.value);
-					if (migrated !== comment.value) {
-						state.str.overwrite(comment.start + '//'.length, comment.end, migrated);
-					}
-				}
-			}
-		}
-		next();
-	},
-	Identifier(node, { state, path }) {
-		handle_identifier(node, state, path);
-	},
-	ImportDeclaration(node, { state }) {
-		state.props_insertion_point = node.end ?? state.props_insertion_point;
-		if (node.source.value === 'svelte') {
-			let illegal_specifiers = [];
-			let removed_specifiers = 0;
-			for (let specifier of node.specifiers) {
-				if (
-					specifier.type === 'ImportSpecifier' &&
-					specifier.imported.type === 'Identifier' &&
-					['beforeUpdate', 'afterUpdate'].includes(specifier.imported.name)
-				) {
-					const references = state.scope.references.get(specifier.local.name);
-					if (!references) {
-						let end = /** @type {number} */ (
-							state.str.original.indexOf(',', specifier.end) !== -1 &&
-							state.str.original.indexOf(',', specifier.end) <
-								state.str.original.indexOf('}', specifier.end)
-								? state.str.original.indexOf(',', specifier.end) + 1
-								: specifier.end
-						);
-						while (state.str.original[end].trim() === '') end++;
-						state.str.remove(/** @type {number} */ (specifier.start), end);
-						removed_specifiers++;
-						continue;
-					}
-					illegal_specifiers.push(specifier.imported.name);
-				}
-			}
-			if (removed_specifiers === node.specifiers.length) {
-				state.str.remove(/** @type {number} */ (node.start), /** @type {number} */ (node.end));
-			}
-			if (illegal_specifiers.length > 0) {
-				throw new MigrationError(
-					`Can't migrate code with ${illegal_specifiers.join(' and ')}. Please migrate by hand.`
-				);
-			}
-		}
-	},
-	ExportNamedDeclaration(node, { state, next }) {
-		if (node.declaration) {
-			next();
-			return;
-		}
-
-		let count_removed = 0;
-		for (const specifier of node.specifiers) {
-			if (specifier.local.type !== 'Identifier') continue;
-
-			const binding = state.scope.get(specifier.local.name);
-			if (binding?.kind === 'bindable_prop') {
-				state.str.remove(
-					/** @type {number} */ (specifier.start),
-					/** @type {number} */ (specifier.end)
-				);
-				count_removed++;
-			}
-		}
-		if (count_removed === node.specifiers.length) {
-			state.str.remove(/** @type {number} */ (node.start), /** @type {number} */ (node.end));
-		}
-	},
-	VariableDeclaration(node, { state, path, visit, next }) {
-		if (state.scope !== state.analysis.instance.scope) {
-			return;
-		}
-
-		let nr_of_props = 0;
-
-		for (let i = 0; i < node.declarations.length; i++) {
-			const declarator = node.declarations[i];
-			if (state.analysis.runes) {
-				if (get_rune(declarator.init, state.scope) === '$props') {
-					state.props_insertion_point = /** @type {number} */ (declarator.id.start) + 1;
-					state.has_props_rune = true;
-				}
-				continue;
-			}
-
-			let bindings;
-			try {
-				bindings = state.scope.get_bindings(declarator);
-			} catch (e) {
-				// no bindings, so we can skip this
-				next();
-				continue;
-			}
-			const has_state = bindings.some((binding) => binding.kind === 'state');
-			const has_props = bindings.some((binding) => binding.kind === 'bindable_prop');
-
-			if (!has_state && !has_props) {
-				next();
-				continue;
-			}
-
-			if (has_props) {
-				nr_of_props++;
-
-				if (declarator.id.type !== 'Identifier') {
-					// TODO invest time in this?
-					throw new MigrationError(
-						'Encountered an export declaration pattern that is not supported for automigration.'
-					);
-					// Turn export let into props. It's really really weird because export let { x: foo, z: [bar]} = ..
-					// means that foo and bar are the props (i.e. the leaves are the prop names), not x and z.
-					// const tmp = b.id(state.scope.generate('tmp'));
-					// const paths = extract_paths(declarator.id, tmp);
-					// state.props_pre.push(
-					// 	b.declaration('const', tmp, visit(declarator.init!) as Expression)
-					// );
-					// for (const path of paths) {
-					// 	const name = (path.node as Identifier).name;
-					// 	const binding = state.scope.get(name)!;
-					// 	const value = path.expression;
-					// 	if (binding.kind === 'bindable_prop' || binding.kind === 'rest_prop') {
-					// 		state.props.push({
-					// 			local: name,
-					// 			exported: binding.prop_alias ? binding.prop_alias : name,
-					// 			init: value
-					// 		});
-					// 		state.props_insertion_point = /** @type {number} */(declarator.end);
-					// 	} else {
-					// 		declarations.push(b.declarator(path.node, value));
-					// 	}
-					// }
-				}
-
-				const name = declarator.id.name;
-				const binding = /** @type {Binding} */ (state.scope.get(name));
-
-				if (state.analysis.uses_props && (declarator.init || binding.updated)) {
-					throw new MigrationError(
-						'$$props is used together with named props in a way that cannot be automatically migrated.'
-					);
-				}
-
-				const prop = state.props.find((prop) => prop.exported === (binding.prop_alias || name));
-				if (prop) {
-					next();
-					// $$Props type was used
-					prop.init = declarator.init
-						? state.str
-								.snip(
-									/** @type {number} */ (declarator.init.start),
-									/** @type {number} */ (declarator.init.end)
-								)
-								.toString()
-						: '';
-					prop.bindable = binding.updated;
-					prop.exported = binding.prop_alias || name;
-					prop.type_only = false;
-				} else {
-					next();
-					state.props.push({
-						local: name,
-						exported: binding.prop_alias ? binding.prop_alias : name,
-						init: declarator.init
-							? state.str
-									.snip(
-										/** @type {number} */ (declarator.init.start),
-										/** @type {number} */ (declarator.init.end)
-									)
-									.toString()
-							: '',
-						optional: !!declarator.init,
-						bindable: binding.updated,
-						...extract_type_and_comment(declarator, state, path)
-					});
-				}
-
-				let start = /** @type {number} */ (declarator.start);
-				let end = /** @type {number} */ (declarator.end);
-
-				// handle cases like let a,b,c; where only some are exported
-				if (node.declarations.length > 1) {
-					// move the insertion point after the node itself;
-					state.props_insertion_point = /** @type {number} */ (node.end);
-					// if it's not the first declaration remove from the , of the previous declaration
-					if (i !== 0) {
-						start = state.str.original.indexOf(
-							',',
-							/** @type {number} */ (node.declarations[i - 1].end)
-						);
-					}
-					// if it's not the last declaration remove either from up until the
-					// start of the next declaration (if it's the first declaration) or
-					// up until the last index of , from the next declaration
-					if (i !== node.declarations.length - 1) {
-						if (i === 0) {
-							end = /** @type {number} */ (node.declarations[i + 1].start);
-						} else {
-							end = state.str.original.lastIndexOf(
-								',',
-								/** @type {number} */ (node.declarations[i + 1].start)
-							);
-						}
-					}
-				} else {
-					state.props_insertion_point = /** @type {number} */ (declarator.end);
-				}
-
-				state.str.update(start, end, '');
-
-				continue;
-			}
-
-			/**
-			 * @param {"state"|"derived"} rune
-			 */
-			function check_rune_binding(rune) {
-				const has_rune_binding = !!state.scope.get(rune);
-				if (has_rune_binding) {
-					throw new MigrationError(
-						`can't migrate \`${state.str.original.substring(/** @type {number} */ (node.start), node.end)}\` to \`$${rune}\` because there's a variable named ${rune}.\n     Rename the variable and try again or migrate by hand.`
-					);
-				}
-			}
-
-			// state
-			if (declarator.init) {
-				let { start, end } = /** @type {{ start: number, end: number }} */ (declarator.init);
-
-				if (declarator.init.type === 'SequenceExpression') {
-					while (state.str.original[start] !== '(') start -= 1;
-					while (state.str.original[end - 1] !== ')') end += 1;
-				}
-
-				check_rune_binding('state');
-
-				state.str.prependLeft(start, '$state(');
-				state.str.appendRight(end, ')');
-			} else {
-				/**
-				 * @type {AssignmentExpression | undefined}
-				 */
-				let assignment_in_labeled;
-				/**
-				 * @type {LabeledStatement | undefined}
-				 */
-				let labeled_statement;
-
-				// Analyze declaration bindings to see if they're exclusively updated within a single reactive statement
-				const possible_derived = bindings.every((binding) =>
-					binding.references.every((reference) => {
-						const declaration = reference.path.find((el) => el.type === 'VariableDeclaration');
-						const assignment = reference.path.find((el) => el.type === 'AssignmentExpression');
-						const update = reference.path.find((el) => el.type === 'UpdateExpression');
-						const labeled = /** @type {LabeledStatement | undefined} */ (
-							reference.path.find((el) => el.type === 'LabeledStatement' && el.label.name === '$')
-						);
-
-						if (
-							assignment &&
-							labeled &&
-							// ensure that $: foo = bar * 2 is not counted as a reassignment of bar
-							(labeled.body.type !== 'ExpressionStatement' ||
-								labeled.body.expression !== assignment ||
-								(assignment.left.type === 'Identifier' &&
-									assignment.left.name === binding.node.name))
-						) {
-							if (assignment_in_labeled) return false;
-							assignment_in_labeled = /** @type {AssignmentExpression} */ (assignment);
-							labeled_statement = labeled;
-						}
-
-						return (
-							!update &&
-							((declaration && binding.initial) ||
-								(labeled && assignment) ||
-								(!labeled && !assignment))
-						);
-					})
-				);
-
-				const labeled_has_single_assignment =
-					labeled_statement?.body.type === 'BlockStatement' &&
-					labeled_statement.body.body.length === 1 &&
-					labeled_statement.body.body[0].type === 'ExpressionStatement';
-
-				const is_expression_assignment =
-					labeled_statement?.body.type === 'ExpressionStatement' &&
-					labeled_statement.body.expression.type === 'AssignmentExpression';
-
-				let should_be_state = false;
-
-				if (is_expression_assignment) {
-					const body = /**@type {ExpressionStatement}*/ (labeled_statement?.body);
-					const expression = /**@type {AssignmentExpression}*/ (body.expression);
-					const [, ids] = extract_all_identifiers_from_expression(expression.right);
-					if (ids.length === 0) {
-						should_be_state = true;
-						state.derived_labeled_statements.add(
-							/** @type {LabeledStatement} */ (labeled_statement)
-						);
-					}
-				}
-
-				if (
-					!should_be_state &&
-					possible_derived &&
-					assignment_in_labeled &&
-					labeled_statement &&
-					(labeled_has_single_assignment || is_expression_assignment)
-				) {
-					const indent = state.str.original.substring(
-						state.str.original.lastIndexOf('\n', /** @type {number} */ (node.start)) + 1,
-						/** @type {number} */ (node.start)
-					);
-					// transfer all the leading comments
-					if (
-						labeled_statement.body.type === 'BlockStatement' &&
-						labeled_statement.body.body[0].leadingComments
-					) {
-						for (let comment of labeled_statement.body.body[0].leadingComments) {
-							state.str.prependLeft(
-								/** @type {number} */ (node.start),
-								comment.type === 'Block'
-									? `/*${comment.value}*/\n${indent}`
-									: `// ${comment.value}\n${indent}`
-							);
-						}
-					}
-
-					check_rune_binding('derived');
-
-					// Someone wrote a `$: { ... }` statement which we can turn into a `$derived`
-					state.str.appendRight(
-						/** @type {number} */ (declarator.id.typeAnnotation?.end ?? declarator.id.end),
-						' = $derived('
-					);
-					visit(assignment_in_labeled.right);
-					state.str.appendRight(
-						/** @type {number} */ (declarator.id.typeAnnotation?.end ?? declarator.id.end),
-						state.str
-							.snip(
-								/** @type {number} */ (assignment_in_labeled.right.start),
-								/** @type {number} */ (assignment_in_labeled.right.end)
-							)
-							.toString()
-					);
-					state.str.remove(
-						/** @type {number} */ (labeled_statement.start),
-						/** @type {number} */ (labeled_statement.end)
-					);
-					state.str.appendRight(
-						/** @type {number} */ (declarator.id.typeAnnotation?.end ?? declarator.id.end),
-						')'
-					);
-					state.derived_labeled_statements.add(labeled_statement);
-
-					// transfer all the trailing comments
-					if (
-						labeled_statement.body.type === 'BlockStatement' &&
-						labeled_statement.body.body[0].trailingComments
-					) {
-						for (let comment of labeled_statement.body.body[0].trailingComments) {
-							state.str.appendRight(
-								/** @type {number} */ (declarator.id.typeAnnotation?.end ?? declarator.id.end),
-								comment.type === 'Block'
-									? `\n${indent}/*${comment.value}*/`
-									: `\n${indent}// ${comment.value}`
-							);
-						}
-					}
-				} else {
-					check_rune_binding('state');
-
-					state.str.prependLeft(
-						/** @type {number} */ (declarator.id.typeAnnotation?.end ?? declarator.id.end),
-						' = $state('
-					);
-					if (should_be_state) {
-						// someone wrote a `$: foo = ...` statement which we can turn into `let foo = $state(...)`
-						state.str.appendRight(
-							/** @type {number} */ (declarator.id.typeAnnotation?.end ?? declarator.id.end),
-							state.str
-								.snip(
-									/** @type {number} */ (
-										/** @type {AssignmentExpression} */ (assignment_in_labeled).right.start
-									),
-									/** @type {number} */ (
-										/** @type {AssignmentExpression} */ (assignment_in_labeled).right.end
-									)
-								)
-								.toString()
-						);
-						state.str.remove(
-							/** @type {number} */ (/** @type {LabeledStatement} */ (labeled_statement).start),
-							/** @type {number} */ (/** @type {LabeledStatement} */ (labeled_statement).end)
-						);
-					}
-					state.str.appendRight(
-						/** @type {number} */ (declarator.id.typeAnnotation?.end ?? declarator.id.end),
-						')'
-					);
-				}
-			}
-		}
-
-		if (nr_of_props === node.declarations.length) {
-			let start = /** @type {number} */ (node.start);
-			let end = /** @type {number} */ (node.end);
-
-			const parent = path.at(-1);
-			if (parent?.type === 'ExportNamedDeclaration') {
-				start = /** @type {number} */ (parent.start);
-				end = /** @type {number} */ (parent.end);
-			}
-			while (state.str.original[start] !== '\n') start--;
-			while (state.str.original[end] !== '\n') end++;
-			state.str.update(start, end, '');
-		}
-	},
-	BreakStatement(node, { state, path }) {
-		if (path[1].type !== 'LabeledStatement') return;
-		if (node.label?.name !== '$') return;
-		state.str.update(
-			/** @type {number} */ (node.start),
-			/** @type {number} */ (node.end),
-			'return;'
-		);
-	},
-	LabeledStatement(node, { path, state, next }) {
-		if (state.analysis.runes) return;
-		if (path.length > 1) return;
-		if (node.label.name !== '$') return;
-		if (state.derived_labeled_statements.has(node)) return;
-
-		next();
-
-		/**
-		 * @param {"state"|"derived"} rune
-		 */
-		function check_rune_binding(rune) {
-			const has_rune_binding = state.scope.get(rune);
-			if (has_rune_binding) {
-				throw new MigrationError(
-					`can't migrate \`$: ${state.str.original.substring(/** @type {number} */ (node.body.start), node.body.end)}\` to \`$${rune}\` because there's a variable named ${rune}.\n     Rename the variable and try again or migrate by hand.`
-				);
-			}
-		}
-
-		if (
-			node.body.type === 'ExpressionStatement' &&
-			node.body.expression.type === 'AssignmentExpression'
-		) {
-			const { left, right } = node.body.expression;
-
-			const ids = extract_identifiers(left);
-			const [, expression_ids] = extract_all_identifiers_from_expression(right);
-			const bindings = ids.map((id) => /** @type {Binding} */ (state.scope.get(id.name)));
-
-			if (bindings.every((b) => b.kind === 'legacy_reactive')) {
-				if (
-					right.type !== 'Literal' &&
-					bindings.every((b) => b.kind !== 'store_sub') &&
-					left.type !== 'MemberExpression'
-				) {
-					let { start, end } = /** @type {{ start: number, end: number }} */ (right);
-
-					check_rune_binding('derived');
-
-					// $derived
-					state.str.update(
-						/** @type {number} */ (node.start),
-						/** @type {number} */ (node.body.expression.start),
-						'let '
-					);
-
-					if (right.type === 'SequenceExpression') {
-						while (state.str.original[start] !== '(') start -= 1;
-						while (state.str.original[end - 1] !== ')') end += 1;
-					}
-
-					state.str.prependRight(start, `$derived(`);
-
-					// in a case like `$: ({ a } = b())`, there's already a trailing parenthesis.
-					// otherwise, we need to add one
-					if (state.str.original[/** @type {number} */ (node.body.start)] !== '(') {
-						state.str.appendLeft(end, `)`);
-					}
-
-					return;
-				}
-
-				for (const binding of bindings) {
-					if (binding.reassigned && (ids.includes(binding.node) || expression_ids.length === 0)) {
-						check_rune_binding('state');
-						const init =
-							binding.kind === 'state'
-								? ' = $state()'
-								: expression_ids.length === 0
-									? ` = $state(${state.str.original.substring(/** @type {number} */ (right.start), right.end)})`
-									: '';
-						// implicitly-declared variable which we need to make explicit
-						state.str.prependLeft(
-							/** @type {number} */ (node.start),
-							`let ${binding.node.name}${init};\n${state.indent}`
-						);
-					}
-				}
-
-				if (expression_ids.length === 0 && bindings.every((b) => b.kind !== 'store_sub')) {
-					state.str.remove(/** @type {number} */ (node.start), /** @type {number} */ (node.end));
-					return;
-				}
-			}
-		}
-
-		state.legacy_imports.add('run');
-		const is_block_stmt = node.body.type === 'BlockStatement';
-		const start_end = /** @type {number} */ (node.body.start);
-		// TODO try to find out if we can use $derived.by instead?
-		if (is_block_stmt) {
-			state.str.update(
-				/** @type {number} */ (node.start),
-				start_end + 1,
-				`${state.names.run}(() => {`
-			);
-			const end = /** @type {number} */ (node.body.end);
-			state.str.update(end - 1, end, '});');
-		} else {
-			state.str.update(
-				/** @type {number} */ (node.start),
-				start_end,
-				`${state.names.run}(() => {\n${state.indent}`
-			);
-			state.str.indent(state.indent, {
-				exclude: [
-					[0, /** @type {number} */ (node.body.start)],
-					[/** @type {number} */ (node.body.end), state.end]
-				]
-			});
-			state.str.appendLeft(/** @type {number} */ (node.end), `\n${state.indent}});`);
-		}
-	}
-};
-
-/**
- *
- * @param {State} state
- * @param {number} start
- * @param {number} end
- */
-function trim_block(state, start, end) {
-	const original = state.str.snip(start, end).toString();
-	const without_parens = original.substring(1, original.length - 1);
-	if (without_parens.trim().length !== without_parens.length) {
-		state.str.update(start + 1, end - 1, without_parens.trim());
-	}
-}
-
-/** @type {Visitors<AST.SvelteNode, State>} */
-const template = {
-	Identifier(node, { state, path }) {
-		handle_identifier(node, state, path);
-	},
-	RegularElement(node, { state, path, next }) {
-		// Strip off any namespace from the beginning of the node name.
-		const node_name = node.name.replace(/[a-zA-Z-]*:/g, '');
-
-		if (state.analysis.source[node.end - 2] === '/' && !is_void(node_name) && !is_svg(node_name)) {
-			let trimmed_position = node.end - 2;
-			while (state.str.original.charAt(trimmed_position - 1) === ' ') trimmed_position--;
-			state.str.remove(trimmed_position, node.end - 1);
-			state.str.appendLeft(node.end, `</${node.name}>`);
-		}
-
-		migrate_slot_usage(node, path, state);
-		handle_events(node, state);
-
-		next();
-	},
-	SvelteSelf(node, { state, next }) {
-		const source = state.str.original.substring(node.start, node.end);
-		if (!state.filename) {
-			const indent = guess_indent(source);
-			has_migration_task = true;
-			state.str.prependRight(
-				node.start,
-				`<!-- @migration-task: svelte:self is deprecated, import this Svelte file into itself instead -->\n${indent}`
-			);
-			next();
-			return;
-		}
-		// overwrite the open tag
-		state.str.overwrite(
-			node.start + 1,
-			node.start + 1 + 'svelte:self'.length,
-			`${state.analysis.name}`
-		);
-		// if it has a fragment we need to overwrite the closing tag too
-		if (node.fragment.nodes.length > 0) {
-			state.str.overwrite(
-				state.str.original.lastIndexOf('<', node.end) + 2,
-				node.end - 1,
-				`${state.analysis.name}`
-			);
-		} else if (!source.endsWith('/>')) {
-			// special case for case `<svelte:self></svelte:self>` it has no fragment but
-			// we still need to overwrite the end tag
-			state.str.overwrite(
-				node.start + source.lastIndexOf('</', node.end) + 2,
-				node.end - 1,
-				`${state.analysis.name}`
-			);
-		}
-		state.has_svelte_self = true;
-		next();
-	},
-	SvelteElement(node, { state, path, next }) {
-		migrate_slot_usage(node, path, state);
-		if (node.tag.type === 'Literal') {
-			let is_static = true;
-
-			let a = /** @type {number} */ (node.tag.start);
-			let b = /** @type {number} */ (node.tag.end);
-			let quote_mark = state.str.original[a - 1];
-
-			while (state.str.original[--a] !== '=') {
-				if (state.str.original[a] === '{') {
-					is_static = false;
-					break;
-				}
-			}
-
-			if (is_static && state.str.original[b] === quote_mark) {
-				state.str.prependLeft(a + 1, '{');
-				state.str.appendRight(/** @type {number} */ (node.tag.end) + 1, '}');
-			}
-		}
-
-		handle_events(node, state);
-		next();
-	},
-	Component(node, { state, path, next }) {
-		next();
-		migrate_slot_usage(node, path, state);
-	},
-	SvelteComponent(node, { state, next, path }) {
-		next();
-
-		migrate_slot_usage(node, path, state);
-
-		let expression = state.str
-			.snip(
-				/** @type {number} */ (node.expression.start),
-				/** @type {number} */ (node.expression.end)
-			)
-			.toString();
-
-		if (
-			(node.expression.type !== 'Identifier' && node.expression.type !== 'MemberExpression') ||
-			!regex_valid_component_name.test(expression)
-		) {
-			let current_expression = expression;
-			expression = state.scope.generate('SvelteComponent');
-			let needs_derived = true;
-			for (let i = path.length - 1; i >= 0; i--) {
-				const part = path[i];
-				if (
-					part.type === 'EachBlock' ||
-					part.type === 'AwaitBlock' ||
-					part.type === 'IfBlock' ||
-					part.type === 'SnippetBlock' ||
-					part.type === 'Component' ||
-					part.type === 'SvelteComponent'
-				) {
-					let position = node.start;
-					if (i !== path.length - 1) {
-						for (let modifier = 1; modifier < path.length - i; modifier++) {
-							const path_part = path[i + modifier];
-							if ('start' in path_part) {
-								position = /** @type {number} */ (path_part.start);
-								break;
-							}
-						}
-					}
-					const indent = state.str.original.substring(
-						state.str.original.lastIndexOf('\n', position) + 1,
-						position
-					);
-					state.str.appendRight(
-						position,
-						`{@const ${expression} = ${current_expression}}\n${indent}`
-					);
-					needs_derived = false;
-					break;
-				}
-			}
-			if (needs_derived) {
-				if (state.derived_components.has(current_expression)) {
-					expression = /** @type {string} */ (state.derived_components.get(current_expression));
-				} else {
-					state.derived_components.set(current_expression, expression);
-				}
-			}
-		}
-
-		state.str.overwrite(node.start + 1, node.start + node.name.length + 1, expression);
-
-		if (state.str.original.substring(node.end - node.name.length - 1, node.end - 1) === node.name) {
-			state.str.overwrite(node.end - node.name.length - 1, node.end - 1, expression);
-		}
-		let this_pos = state.str.original.lastIndexOf('this', node.expression.start);
-		while (!state.str.original.charAt(this_pos - 1).trim()) this_pos--;
-		const end_pos = state.str.original.indexOf('}', node.expression.end) + 1;
-		state.str.remove(this_pos, end_pos);
-	},
-	SvelteFragment(node, { state, path, next }) {
-		migrate_slot_usage(node, path, state);
-		next();
-	},
-	SvelteWindow(node, { state, next }) {
-		handle_events(node, state);
-		next();
-	},
-	SvelteBody(node, { state, next }) {
-		handle_events(node, state);
-		next();
-	},
-	SvelteDocument(node, { state, next }) {
-		handle_events(node, state);
-		next();
-	},
-	SlotElement(node, { state, path, next, visit }) {
-		migrate_slot_usage(node, path, state);
-
-		if (state.analysis.custom_element) return;
-		let name = 'children';
-		let slot_name = 'default';
-		let slot_props = '{ ';
-		let aliased_slot_name;
-
-		for (const attr of node.attributes) {
-			if (attr.type === 'SpreadAttribute') {
-				slot_props += `...${state.str.original.substring(/** @type {number} */ (attr.expression.start), attr.expression.end)}, `;
-			} else if (attr.type === 'Attribute') {
-				if (attr.name === 'slot') {
-					continue;
-				}
-
-				if (attr.name === 'name') {
-					slot_name = /** @type {any} */ (attr.value)[0].data;
-					// if some of the parents or this node itself har a slot
-					// attribute with the sane name of this slot
-					// we want to create a derived or the migrated snippet
-					// will shadow the slot prop
-					if (
-						path.some(
-							(parent) =>
-								(parent.type === 'RegularElement' ||
-									parent.type === 'SvelteElement' ||
-									parent.type === 'Component' ||
-									parent.type === 'SvelteComponent' ||
-									parent.type === 'SvelteFragment') &&
-								parent.attributes.some(
-									(attribute) =>
-										attribute.type === 'Attribute' &&
-										attribute.name === 'slot' &&
-										is_text_attribute(attribute) &&
-										attribute.value[0].data === slot_name
-								)
-						) ||
-						node.attributes.some(
-							(attribute) =>
-								attribute.type === 'Attribute' &&
-								attribute.name === 'slot' &&
-								is_text_attribute(attribute) &&
-								attribute.value[0].data === slot_name
-						)
-					) {
-						aliased_slot_name = `${slot_name}_render`;
-						state.derived_conflicting_slots.set(aliased_slot_name, slot_name);
-					}
-				} else {
-					const attr_value =
-						attr.value === true || Array.isArray(attr.value) ? attr.value : [attr.value];
-					let value = 'true';
-					if (attr_value !== true) {
-						const first = attr_value[0];
-						const last = attr_value[attr_value.length - 1];
-						for (const attr of attr_value) {
-							visit(attr);
-						}
-						value = state.str
-							.snip(
-								first.type === 'Text'
-									? first.start - 1
-									: /** @type {number} */ (first.expression.start),
-								last.type === 'Text' ? last.end + 1 : /** @type {number} */ (last.expression.end)
-							)
-							.toString();
-					}
-					slot_props += value === attr.name ? `${value}, ` : `${attr.name}: ${value}, `;
-				}
-			}
-		}
-
-		slot_props += '}';
-		if (slot_props === '{ }') {
-			slot_props = '';
-		}
-
-		const existing_prop = state.props.find((prop) => prop.slot_name === slot_name);
-		if (existing_prop) {
-			name = existing_prop.local;
-		} else if (slot_name !== 'default') {
-			name = state.scope.generate(slot_name);
-			if (name !== slot_name) {
-				throw new MigrationError(
-					`This migration would change the name of a slot (${slot_name} to ${name}) making the component unusable`
-				);
-			}
-		}
-
-		if (!existing_prop) {
-			state.props.push({
-				local: name,
-				exported: name,
-				init: '',
-				bindable: false,
-				optional: true,
-				slot_name,
-				type: `import('svelte').${slot_props ? 'Snippet<[any]>' : 'Snippet'}`
-			});
-		} else if (existing_prop.needs_refine_type) {
-			existing_prop.type = `import('svelte').${slot_props ? 'Snippet<[any]>' : 'Snippet'}`;
-			existing_prop.needs_refine_type = false;
-		}
-
-		if (
-			slot_name === 'default' &&
-			path.some(
-				(parent) =>
-					(parent.type === 'SvelteComponent' ||
-						parent.type === 'Component' ||
-						parent.type === 'RegularElement' ||
-						parent.type === 'SvelteElement' ||
-						parent.type === 'SvelteFragment') &&
-					parent.attributes.some((attr) => attr.type === 'LetDirective')
-			)
-		) {
-			aliased_slot_name = `${name}_render`;
-			state.derived_conflicting_slots.set(aliased_slot_name, name);
-		}
-		name = aliased_slot_name ?? name;
-
-		if (node.fragment.nodes.length > 0) {
-			next();
-			state.str.update(
-				node.start,
-				node.fragment.nodes[0].start,
-				`{#if ${name}}{@render ${state.analysis.uses_props ? `${state.names.props}.` : ''}${name}(${slot_props})}{:else}`
-			);
-			state.str.update(node.fragment.nodes[node.fragment.nodes.length - 1].end, node.end, '{/if}');
-		} else {
-			state.str.update(
-				node.start,
-				node.end,
-				`{@render ${state.analysis.uses_props ? `${state.names.props}.` : ''}${name}?.(${slot_props})}`
-			);
-		}
-	},
-	Comment(node, { state }) {
-		const migrated = migrate_svelte_ignore(node.data);
-		if (migrated !== node.data) {
-			state.str.overwrite(node.start + '<!--'.length, node.end - '-->'.length, migrated);
-		}
-	},
-	HtmlTag(node, { state, next }) {
-		trim_block(state, node.start, node.end);
-		next();
-	},
-	ConstTag(node, { state, next }) {
-		trim_block(state, node.start, node.end);
-		next();
-	},
-	IfBlock(node, { state, next }) {
-		const start = node.start;
-		const end = state.str.original.indexOf('}', node.test.end) + 1;
-		trim_block(state, start, end);
-		next();
-	},
-	AwaitBlock(node, { state, next }) {
-		const start = node.start;
-		const end =
-			state.str.original.indexOf(
-				'}',
-				node.pending !== null ? node.expression.end : node.value?.end
-			) + 1;
-		trim_block(state, start, end);
-		if (node.pending !== null) {
-			const start = state.str.original.lastIndexOf('{', node.value?.start);
-			const end = state.str.original.indexOf('}', node.value?.end) + 1;
-			trim_block(state, start, end);
-		}
-		if (node.catch !== null) {
-			const start = state.str.original.lastIndexOf('{', node.error?.start);
-			const end = state.str.original.indexOf('}', node.error?.end) + 1;
-			trim_block(state, start, end);
-		}
-		next();
-	},
-	KeyBlock(node, { state, next }) {
-		const start = node.start;
-		const end = state.str.original.indexOf('}', node.expression.end) + 1;
-		trim_block(state, start, end);
-		next();
-	}
-};
-
-/**
- * @param {AST.RegularElement | AST.SvelteElement | AST.SvelteComponent | AST.Component | AST.SlotElement | AST.SvelteFragment} node
- * @param {AST.SvelteNode[]} path
- * @param {State} state
- */
-function migrate_slot_usage(node, path, state) {
-	const parent = path.at(-2);
-	// Bail on custom element slot usage
-	if (
-		parent?.type !== 'Component' &&
-		parent?.type !== 'SvelteComponent' &&
-		node.type !== 'Component' &&
-		node.type !== 'SvelteComponent'
-	) {
-		return;
-	}
-
-	let snippet_name = 'children';
-	let snippet_props = [];
-
-	// if we stop the transform because the name is not correct we don't want to
-	// remove the let directive and they could come before the name
-	let removal_queue = [];
-
-	for (let attribute of node.attributes) {
-		if (
-			attribute.type === 'Attribute' &&
-			attribute.name === 'slot' &&
-			is_text_attribute(attribute)
-		) {
-			snippet_name = attribute.value[0].data;
-			// the default slot in svelte 4 if what the children slot is for svelte 5
-			if (snippet_name === 'default') {
-				snippet_name = 'children';
-			}
-			if (!regex_is_valid_identifier.test(snippet_name) || is_reserved(snippet_name)) {
-				has_migration_task = true;
-				state.str.appendLeft(
-					node.start,
-					`<!-- @migration-task: migrate this slot by hand, \`${snippet_name}\` is an invalid identifier -->\n${state.indent}`
-				);
-				return;
-			}
-			if (parent?.type === 'Component' || parent?.type === 'SvelteComponent') {
-				for (let attribute of parent.attributes) {
-					if (attribute.type === 'Attribute' || attribute.type === 'BindDirective') {
-						if (attribute.name === snippet_name) {
-							state.str.appendLeft(
-								node.start,
-								`<!-- @migration-task: migrate this slot by hand, \`${snippet_name}\` would shadow a prop on the parent component -->\n${state.indent}`
-							);
-							return;
-						}
-					}
-				}
-			}
-			// flush the queue after we found the name
-			for (let remove_let of removal_queue) {
-				remove_let();
-			}
-			state.str.remove(attribute.start, attribute.end);
-		}
-		if (attribute.type === 'LetDirective') {
-			snippet_props.push(
-				attribute.name +
-					(attribute.expression
-						? `: ${state.str.original.substring(/** @type {number} */ (attribute.expression.start), /** @type {number} */ (attribute.expression.end))}`
-						: '')
-			);
-			// we just add to the queue to remove them after we found if we need to migrate or we bail
-			removal_queue.push(() => state.str.remove(attribute.start, attribute.end));
-		}
-	}
-
-	if (removal_queue.length > 0) {
-		for (let remove_let of removal_queue) {
-			remove_let();
-		}
-	}
-
-	if (node.type === 'SvelteFragment' && node.fragment.nodes.length > 0) {
-		// remove node itself, keep content
-		state.str.remove(node.start, node.fragment.nodes[0].start);
-		state.str.remove(node.fragment.nodes[node.fragment.nodes.length - 1].end, node.end);
-	}
-
-	const props = snippet_props.length > 0 ? `{ ${snippet_props.join(', ')} }` : '';
-
-	if (snippet_name === 'children' && node.type !== 'SvelteFragment') {
-		if (snippet_props.length === 0) return; // nothing to do
-
-		let inner_start = 0;
-		let inner_end = 0;
-		for (let i = 0; i < node.fragment.nodes.length; i++) {
-			const inner = node.fragment.nodes[i];
-			const is_empty_text = inner.type === 'Text' && !inner.data.trim();
-
-			if (
-				(inner.type === 'RegularElement' ||
-					inner.type === 'SvelteElement' ||
-					inner.type === 'Component' ||
-					inner.type === 'SvelteComponent' ||
-					inner.type === 'SlotElement' ||
-					inner.type === 'SvelteFragment') &&
-				inner.attributes.some((attr) => attr.type === 'Attribute' && attr.name === 'slot')
-			) {
-				if (inner_start && !inner_end) {
-					// End of default slot content
-					inner_end = inner.start;
-				}
-			} else if (!inner_start && !is_empty_text) {
-				// Start of default slot content
-				inner_start = inner.start;
-			} else if (inner_end && !is_empty_text) {
-				// There was default slot content before, then some named slot content, now some default slot content again.
-				// We're moving the last character back by one to avoid the closing {/snippet} tag inserted afterwards
-				// to come before the opening {#snippet} tag of the named slot.
-				state.str.update(inner_end - 1, inner_end, '');
-				state.str.prependLeft(inner_end - 1, state.str.original[inner_end - 1]);
-				state.str.move(inner.start, inner.end, inner_end - 1);
-			}
-		}
-
-		if (!inner_end) {
-			inner_end = node.fragment.nodes[node.fragment.nodes.length - 1].end;
-		}
-
-		state.str.appendLeft(
-			inner_start,
-			`{#snippet ${snippet_name}(${props})}\n${state.indent.repeat(path.length)}`
-		);
-		state.str.indent(state.indent, {
-			exclude: [
-				[0, inner_start],
-				[inner_end, state.str.original.length]
-			]
-		});
-		if (inner_end < node.fragment.nodes[node.fragment.nodes.length - 1].end) {
-			// Named slots coming afterwards
-			state.str.prependLeft(inner_end, `{/snippet}\n${state.indent.repeat(path.length)}`);
-		} else {
-			// No named slots coming afterwards
-			state.str.prependLeft(
-				inner_end,
-				`${state.indent.repeat(path.length)}{/snippet}\n${state.indent.repeat(path.length - 1)}`
-			);
-		}
-	} else {
-		// Named slot or `svelte:fragment`: wrap element itself in a snippet
-		state.str.prependLeft(
-			node.start,
-			`{#snippet ${snippet_name}(${props})}\n${state.indent.repeat(path.length - 2)}`
-		);
-		state.str.indent(state.indent, {
-			exclude: [
-				[0, node.start],
-				[node.end, state.str.original.length]
-			]
-		});
-		const str = `\n${state.indent.repeat(path.length - 2)}{/snippet}`;
-
-		if (node.type === 'SlotElement') {
-			state.str.appendRight(node.end, str);
-		} else {
-			state.str.appendLeft(node.end, str);
-		}
-	}
-}
-
-/**
- * @param {VariableDeclarator} declarator
- * @param {State} state
- * @param {AST.SvelteNode[]} path
- */
-function extract_type_and_comment(declarator, state, path) {
-	const str = state.str;
-	const parent = path.at(-1);
-
-	// Try to find jsdoc above the declaration
-	let comment_node = /** @type {Node} */ (parent)?.leadingComments?.at(-1);
-
-	const comment_start = /** @type {any} */ (comment_node)?.start;
-	const comment_end = /** @type {any} */ (comment_node)?.end;
-	let comment = comment_node && str.original.substring(comment_start, comment_end);
-	if (comment_node) {
-		str.update(comment_start, comment_end, '');
-	}
-
-	// Find trailing comments
-	const trailing_comment_node = /** @type {Node} */ (parent)?.trailingComments?.at(0);
-	const trailing_comment_start = /** @type {any} */ (trailing_comment_node)?.start;
-	const trailing_comment_end = /** @type {any} */ (trailing_comment_node)?.end;
-	let trailing_comment =
-		trailing_comment_node && str.original.substring(trailing_comment_start, trailing_comment_end);
-
-	if (trailing_comment_node) {
-		str.update(trailing_comment_start, trailing_comment_end, '');
-	}
-
-	if (declarator.id.typeAnnotation) {
-		state.has_type_or_fallback = true;
-		let start = declarator.id.typeAnnotation.start + 1; // skip the colon
-		while (str.original[start] === ' ') {
-			start++;
-		}
-		return {
-			type: str.original.substring(start, declarator.id.typeAnnotation.end),
-			comment,
-			trailing_comment
-		};
-	}
-
-	let cleaned_comment_arr = comment
-		?.split('\n')
-		.map((line) =>
-			line
-				.trim()
-				// replace `// ` for one liners
-				.replace(/^\/\/\s*/g, '')
-				// replace `\**` for the initial JSDoc
-				.replace(/^\/\*\*?\s*/g, '')
-				// migrate `*/` for the end of JSDoc
-				.replace(/\s*\*\/$/g, '')
-				// remove any initial `* ` to clean the comment
-				.replace(/^\*\s*/g, '')
-		)
-		.filter(Boolean);
-	const first_at_comment = cleaned_comment_arr?.findIndex((line) => line.startsWith('@'));
-	let cleaned_comment = cleaned_comment_arr
-		?.slice(0, first_at_comment !== -1 ? first_at_comment : cleaned_comment_arr.length)
-		.join('\n');
-
-	let cleaned_comment_arr_trailing = trailing_comment
-		?.split('\n')
-		.map((line) =>
-			line
-				.trim()
-				// replace `// ` for one liners
-				.replace(/^\/\/\s*/g, '')
-				// replace `\**` for the initial JSDoc
-				.replace(/^\/\*\*?\s*/g, '')
-				// migrate `*/` for the end of JSDoc
-				.replace(/\s*\*\/$/g, '')
-				// remove any initial `* ` to clean the comment
-				.replace(/^\*\s*/g, '')
-		)
-		.filter(Boolean);
-	const first_at_comment_trailing = cleaned_comment_arr_trailing?.findIndex((line) =>
-		line.startsWith('@')
-	);
-	let cleaned_comment_trailing = cleaned_comment_arr_trailing
-		?.slice(
-			0,
-			first_at_comment_trailing !== -1
-				? first_at_comment_trailing
-				: cleaned_comment_arr_trailing.length
-		)
-		.join('\n');
-
-	// try to find a comment with a type annotation, hinting at jsdoc
-	if (parent?.type === 'ExportNamedDeclaration' && comment_node) {
-		state.has_type_or_fallback = true;
-		const match = /@type {(.+)}/.exec(comment_node.value);
-		if (match) {
-			// try to find JSDoc comments after a hyphen `-`
-			const jsdoc_comment = /@type {.+} (?:\w+|\[.*?\]) - (.+)/.exec(comment_node.value);
-			if (jsdoc_comment) {
-				cleaned_comment += jsdoc_comment[1]?.trim();
-			}
-			return {
-				type: match[1],
-				comment: cleaned_comment,
-				trailing_comment: cleaned_comment_trailing
-			};
-		}
-	}
-
-	// try to infer it from the init
-	if (declarator.init?.type === 'Literal') {
-		state.has_type_or_fallback = true; // only assume type if it's trivial to infer - else someone would've added a type annotation
-		const type = typeof declarator.init.value;
-		if (type === 'string' || type === 'number' || type === 'boolean') {
-			return {
-				type,
-				comment: state.uses_ts ? comment : cleaned_comment,
-				trailing_comment: state.uses_ts ? trailing_comment : cleaned_comment_trailing
-			};
-		}
-	}
-	return {
-		type: 'any',
-		comment: state.uses_ts ? comment : cleaned_comment,
-		trailing_comment: state.uses_ts ? trailing_comment : cleaned_comment_trailing
-	};
-}
-
-// Ensure modifiers are applied in the same order as Svelte 4
-const modifier_order = /** @type {const} */ ([
-	'preventDefault',
-	'stopPropagation',
-	'stopImmediatePropagation',
-	'self',
-	'trusted',
-	'once'
-]);
-
-/**
- * @param {AST.RegularElement | AST.SvelteElement | AST.SvelteWindow | AST.SvelteDocument | AST.SvelteBody} element
- * @param {State} state
- */
-function handle_events(element, state) {
-	/** @type {Map<string, AST.OnDirective[]>} */
-	const handlers = new Map();
-	for (const attribute of element.attributes) {
-		if (attribute.type !== 'OnDirective') continue;
-
-		let name = `on${attribute.name}`;
-		if (attribute.modifiers.includes('capture')) {
-			name += 'capture';
-		}
-
-		const nodes = handlers.get(name) || [];
-		nodes.push(attribute);
-		handlers.set(name, nodes);
-	}
-
-	for (const [name, nodes] of handlers) {
-		const handlers = [];
-
-		let first = null;
-
-		for (const node of nodes) {
-			/** @type {string} */
-			let body;
-
-			if (node.expression) {
-				body = state.str.original.substring(
-					/** @type {number} */ (node.expression.start),
-					/** @type {number} */ (node.expression.end)
-				);
-			} else {
-				body = `${state.names.bubble}('${node.name}')`;
-				state.legacy_imports.add('createBubbler');
-				state.script_insertions.add(
-					`const ${state.names.bubble} = ${state.names.createBubbler}();`
-				);
-			}
-
-			const has_passive = node.modifiers.includes('passive');
-			const has_nonpassive = node.modifiers.includes('nonpassive');
-
-			const modifiers = modifier_order.filter((modifier) => node.modifiers.includes(modifier));
-
-			for (const modifier of modifiers) {
-				state.legacy_imports.add(modifier);
-				body = `${state.names[modifier]}(${body})`;
-			}
-
-			if (has_passive || has_nonpassive) {
-				const action = has_passive ? 'passive' : 'nonpassive';
-				state.legacy_imports.add(action);
-
-				state.str.overwrite(
-					node.start,
-					node.end,
-					`use:${state.names[action]}={['${node.name}', () => ${body}]}`
-				);
-			} else {
-				if (first) {
-					let start = node.start;
-					let end = node.end;
-
-					while (/[\s\n]/.test(state.str.original[start - 1])) start -= 1;
-					state.str.remove(start, end);
-				} else {
-					first = node;
-				}
-
-				handlers.push(body);
-			}
-		}
-
-		if (first) {
-			/** @type {string} */
-			let replacement;
-
-			if (handlers.length > 1) {
-				state.legacy_imports.add('handlers');
-				replacement = `${name}={${state.names.handlers}(${handlers.join(', ')})}`;
-			} else {
-				const handler = handlers[0];
-				replacement = handler === name ? `{${handler}}` : `${name}={${handler}}`;
-			}
-
-			state.str.overwrite(first.start, first.end, replacement);
-		}
-	}
-}
-
-/**
- * Returns start and end of the node. If the start is preceded with white-space-only before a line break,
- * the start will be the start of the line.
- * @param {string} source
- * @param {LabeledStatement} node
- */
-function get_node_range(source, node) {
-	const first_leading_comment = node.leadingComments?.[0];
-	const last_trailing_comment = node.trailingComments?.[node.trailingComments.length - 1];
-
-	// @ts-expect-error the type of `Comment` seems to be wrong...the node actually contains
-	// start and end but the type seems to only contain a `range` (which doesn't actually exists)
-	let start = /** @type {number} */ (first_leading_comment?.start ?? node.start);
-	// @ts-expect-error the type of `Comment` seems to be wrong...the node actually contains
-	// start and end but the type seems to only contain a `range` (which doesn't actually exists)
-	let end = /** @type {number} */ (last_trailing_comment?.end ?? node.end);
-
-	let idx = start;
-	while (source[idx - 1] !== '\n' && source[idx - 1] !== '\r') {
-		idx--;
-		if (source[idx] !== ' ' && source[idx] !== '\t') {
-			idx = start;
-			break;
-		}
-	}
-
-	start = idx;
-
-	return { start, end };
-}
-
-/**
- * @param {Identifier} node
- * @param {State} state
- * @param {any[]} path
- */
-function handle_identifier(node, state, path) {
-	const parent = path.at(-1);
-	if (parent?.type === 'MemberExpression' && parent.property === node) return;
-
-	if (state.analysis.uses_props && node.name !== '$$slots') {
-		if (node.name === '$$props' || node.name === '$$restProps') {
-			// not 100% correct for $$restProps but it'll do
-			state.str.update(
-				/** @type {number} */ (node.start),
-				/** @type {number} */ (node.end),
-				state.names.props
-			);
-		} else {
-			const binding = state.scope.get(node.name);
-			if (binding?.kind === 'bindable_prop' && binding.node !== node) {
-				state.str.prependLeft(/** @type {number} */ (node.start), `${state.names.props}.`);
-			}
-		}
-	} else if (node.name === '$$restProps' && state.analysis.uses_rest_props) {
-		state.str.update(
-			/** @type {number} */ (node.start),
-			/** @type {number} */ (node.end),
-			state.names.rest
-		);
-	} else if (node.name === '$$slots' && state.analysis.uses_slots) {
-		if (parent?.type === 'MemberExpression') {
-			if (state.analysis.custom_element) return;
-
-			let name = parent.property.type === 'Literal' ? parent.property.value : parent.property.name;
-			let slot_name = name;
-			const existing_prop = state.props.find((prop) => prop.slot_name === name);
-			if (existing_prop) {
-				name = existing_prop.local;
-			} else if (name !== 'default') {
-				let new_name = state.scope.generate(name);
-				if (new_name !== name) {
-					throw new MigrationError(
-						`This migration would change the name of a slot (${name} to ${new_name}) making the component unusable`
-					);
-				}
-			}
-
-			name = name === 'default' ? 'children' : name;
-
-			if (!existing_prop) {
-				state.props.push({
-					local: name,
-					exported: name,
-					init: '',
-					bindable: false,
-					optional: true,
-					slot_name,
-					// if it's the first time we encounter this slot
-					// we start with any and delegate to when the slot
-					// is actually rendered (it might not happen in that case)
-					// any is still a safe bet
-					type: `import('svelte').Snippet<[any]>`,
-					needs_refine_type: true
-				});
-			}
-
-			state.str.update(
-				/** @type {number} */ (node.start),
-				parent.property.start,
-				state.analysis.uses_props ? `${state.names.props}.` : ''
-			);
-			state.str.update(parent.property.start, parent.end, name);
-		}
-		// else passed as identifier, we don't know what to do here, so let it error
-	} else if (
-		parent?.type === 'TSInterfaceDeclaration' ||
-		parent?.type === 'TSTypeAliasDeclaration'
-	) {
-		const members =
-			parent.type === 'TSInterfaceDeclaration' ? parent.body.body : parent.typeAnnotation?.members;
-		if (Array.isArray(members)) {
-			if (node.name === '$$Props') {
-				state.has_type_or_fallback = true;
-
-				for (const member of members) {
-					const prop = state.props.find((prop) => prop.exported === member.key.name);
-
-					const type = state.str.original.substring(
-						member.typeAnnotation.typeAnnotation.start,
-						member.typeAnnotation.typeAnnotation.end
-					);
-
-					let comment;
-					const comment_node = member.leadingComments?.at(-1);
-					if (comment_node?.type === 'Block') {
-						comment = state.str.original.substring(comment_node.start, comment_node.end);
-					}
-
-					const trailing_comment = member.trailingComments?.at(0)?.value;
-
-					if (prop) {
-						prop.type = type;
-						prop.optional = member.optional;
-						prop.comment = comment ?? prop.comment;
-						prop.trailing_comment = trailing_comment ?? prop.trailing_comment;
-					} else {
-						state.props.push({
-							local: member.key.name,
-							exported: member.key.name,
-							init: '',
-							bindable: false,
-							optional: member.optional,
-							type,
-							comment,
-							trailing_comment,
-							type_only: true
-						});
-					}
-				}
-
-				state.str.remove(parent.start, parent.end);
-			}
-		}
-	}
-}
-
-/** @param {string} content */
-function guess_indent(content) {
-	const lines = content.split('\n');
-
-	const tabbed = lines.filter((line) => /^\t+/.test(line));
-	const spaced = lines.filter((line) => /^ {2,}/.test(line));
-
-	if (tabbed.length === 0 && spaced.length === 0) {
-		return '\t';
-	}
-
-	// More lines tabbed than spaced? Assume tabs, and
-	// default to tabs in the case of a tie (or nothing
-	// to go on)
-	if (tabbed.length >= spaced.length) {
-		return '\t';
-	}
-
-	// Otherwise, we need to guess the multiple
-	const min = spaced.reduce((previous, current) => {
-		const count = /^ +/.exec(current)?.[0].length ?? 0;
-		return Math.min(count, previous);
-	}, Infinity);
-
-	return ' '.repeat(min);
-}