svelte 5.45.2 → 5.45.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "svelte",
   "description": "Cybernetically enhanced web apps",
   "license": "MIT",
-  "version": "5.45.2",
+  "version": "5.45.3",
   "type": "module",
   "types": "./types/index.d.ts",
   "engines": {

package/src/compiler/phases/1-parse/index.js

@@ -1,4 +1,6 @@
 /** @import { AST } from '#compiler' */
+/** @import { Location } from 'locate-character' */
+/** @import * as ESTree from 'estree' */
 // @ts-expect-error acorn type definitions are borked in the release we use
 import { isIdentifierStart, isIdentifierChar } from 'acorn';
 import fragment from './state/fragment.js';
@@ -218,31 +220,45 @@ export class Parser {
 		return result;
 	}
 
-	/** @param {any} allow_reserved */
-	read_identifier(allow_reserved = false) {
+	/**
+	 * @returns {ESTree.Identifier & { start: number, end: number, loc: { start: Location, end: Location } }}
+	 */
+	read_identifier() {
 		const start = this.index;
+		let end = start;
+		let name = '';
 
-		let i = this.index;
+		const code = /** @type {number} */ (this.template.codePointAt(this.index));
 
-		const code = /** @type {number} */ (this.template.codePointAt(i));
-		if (!isIdentifierStart(code, true)) return null;
+		if (isIdentifierStart(code, true)) {
+			let i = this.index;
+			end += code <= 0xffff ? 1 : 2;
 
-		i += code <= 0xffff ? 1 : 2;
+			while (end < this.template.length) {
+				const code = /** @type {number} */ (this.template.codePointAt(end));
 
-		while (i < this.template.length) {
-			const code = /** @type {number} */ (this.template.codePointAt(i));
-
-			if (!isIdentifierChar(code, true)) break;
-			i += code <= 0xffff ? 1 : 2;
-		}
+				if (!isIdentifierChar(code, true)) break;
+				end += code <= 0xffff ? 1 : 2;
+			}
 
-		const identifier = this.template.slice(this.index, (this.index = i));
+			name = this.template.slice(start, end);
+			this.index = end;
 
-		if (!allow_reserved && is_reserved(identifier)) {
-			e.unexpected_reserved_word(start, identifier);
+			if (is_reserved(name)) {
+				e.unexpected_reserved_word(start, name);
+			}
 		}
 
-		return identifier;
+		return {
+			type: 'Identifier',
+			name,
+			start,
+			end,
+			loc: {
+				start: state.locator(start),
+				end: state.locator(end)
+			}
+		};
 	}
 
 	/** @param {RegExp} pattern */

package/src/compiler/phases/1-parse/read/context.js

@@ -1,11 +1,9 @@
-/** @import { Location } from 'locate-character' */
 /** @import { Pattern } from 'estree' */
 /** @import { Parser } from '../index.js' */
 import { match_bracket } from '../utils/bracket.js';
 import { parse_expression_at } from '../acorn.js';
 import { regex_not_newline_characters } from '../../patterns.js';
 import * as e from '../../../errors.js';
-import { locator } from '../../../state.js';
 
 /**
  * @param {Parser} parser
@@ -15,20 +13,13 @@ export default function read_pattern(parser) {
 	const start = parser.index;
 	let i = parser.index;
 
-	const name = parser.read_identifier();
+	const id = parser.read_identifier();
 
-	if (name !== null) {
+	if (id.name !== '') {
 		const annotation = read_type_annotation(parser);
 
 		return {
-			type: 'Identifier',
-			name,
-			start,
-			loc: {
-				start: /** @type {Location} */ (locator(start)),
-				end: /** @type {Location} */ (locator(parser.index))
-			},
-			end: parser.index,
+			...id,
 			typeAnnotation: annotation
 		};
 	}

package/src/compiler/phases/1-parse/state/element.js

@@ -1,4 +1,5 @@
-/** @import { Expression } from 'estree' */
+/** @import { Expression, Identifier, SourceLocation } from 'estree' */
+/** @import { Location } from 'locate-character' */
 /** @import { AST } from '#compiler' */
 /** @import { Parser } from '../index.js' */
 import { is_void } from '../../../../utils.js';
@@ -13,6 +14,8 @@ import { create_attribute, ExpressionMetadata, is_element_node } from '../../nod
 import { get_attribute_expression, is_expression_attribute } from '../../../utils/ast.js';
 import { closing_tag_omitted } from '../../../../html-tree-validation.js';
 import { list } from '../../../utils/string.js';
+import { locator } from '../../../state.js';
+import * as b from '#compiler/builders';
 
 const regex_invalid_unquoted_attribute_value = /^(\/>|[\s"'=<>`])/;
 const regex_closing_textarea_tag = /^<\/textarea(\s[^>]*)?>/i;
@@ -67,10 +70,9 @@ export default function element(parser) {
 		return;
 	}
 
-	const is_closing_tag = parser.eat('/');
-	const name = parser.read_until(regex_whitespace_or_slash_or_closing_tag);
+	if (parser.eat('/')) {
+		const name = parser.read_until(regex_whitespace_or_slash_or_closing_tag);
 
-	if (is_closing_tag) {
 		parser.allow_whitespace();
 		parser.eat('>', true);
 
@@ -125,39 +127,41 @@ export default function element(parser) {
 		return;
 	}
 
-	if (name.startsWith('svelte:') && !meta_tags.has(name)) {
-		const bounds = { start: start + 1, end: start + 1 + name.length };
+	const tag = read_tag(parser, regex_whitespace_or_slash_or_closing_tag);
+
+	if (tag.name.startsWith('svelte:') && !meta_tags.has(tag.name)) {
+		const bounds = { start: start + 1, end: start + 1 + tag.name.length };
 		e.svelte_meta_invalid_tag(bounds, list(Array.from(meta_tags.keys())));
 	}
 
-	if (!regex_valid_element_name.test(name) && !regex_valid_component_name.test(name)) {
+	if (!regex_valid_element_name.test(tag.name) && !regex_valid_component_name.test(tag.name)) {
 		// <div. -> in the middle of typing -> allow in loose mode
-		if (!parser.loose || !name.endsWith('.')) {
-			const bounds = { start: start + 1, end: start + 1 + name.length };
+		if (!parser.loose || !tag.name.endsWith('.')) {
+			const bounds = { start: start + 1, end: start + 1 + tag.name.length };
 			e.tag_invalid_name(bounds);
 		}
 	}
 
-	if (root_only_meta_tags.has(name)) {
-		if (name in parser.meta_tags) {
-			e.svelte_meta_duplicate(start, name);
+	if (root_only_meta_tags.has(tag.name)) {
+		if (tag.name in parser.meta_tags) {
+			e.svelte_meta_duplicate(start, tag.name);
 		}
 
 		if (parent.type !== 'Root') {
-			e.svelte_meta_invalid_placement(start, name);
+			e.svelte_meta_invalid_placement(start, tag.name);
 		}
 
-		parser.meta_tags[name] = true;
+		parser.meta_tags[tag.name] = true;
 	}
 
-	const type = meta_tags.has(name)
-		? meta_tags.get(name)
-		: regex_valid_component_name.test(name) || (parser.loose && name.endsWith('.'))
+	const type = meta_tags.has(tag.name)
+		? meta_tags.get(tag.name)
+		: regex_valid_component_name.test(tag.name) || (parser.loose && tag.name.endsWith('.'))
 			? 'Component'
-			: name === 'title' && parent_is_head(parser.stack)
+			: tag.name === 'title' && parent_is_head(parser.stack)
 				? 'TitleElement'
 				: // TODO Svelte 6/7: once slots are removed in favor of snippets, always keep slot as a regular element
-					name === 'slot' && !parent_is_shadowroot_template(parser.stack)
+					tag.name === 'slot' && !parent_is_shadowroot_template(parser.stack)
 					? 'SlotElement'
 					: 'RegularElement';
 
@@ -168,7 +172,8 @@ export default function element(parser) {
 					type,
 					start,
 					end: -1,
-					name,
+					name: tag.name,
+					name_loc: tag.loc,
 					attributes: [],
 					fragment: create_fragment(true),
 					metadata: {
@@ -184,7 +189,8 @@ export default function element(parser) {
 					type,
 					start,
 					end: -1,
-					name,
+					name: tag.name,
+					name_loc: tag.loc,
 					attributes: [],
 					fragment: create_fragment(true),
 					metadata: {
@@ -194,14 +200,14 @@ export default function element(parser) {
 
 	parser.allow_whitespace();
 
-	if (parent.type === 'RegularElement' && closing_tag_omitted(parent.name, name)) {
+	if (parent.type === 'RegularElement' && closing_tag_omitted(parent.name, tag.name)) {
 		const end = parent.fragment.nodes[0]?.start ?? start;
-		w.element_implicitly_closed({ start: parent.start, end }, `<${name}>`, `</${parent.name}>`);
+		w.element_implicitly_closed({ start: parent.start, end }, `<${tag.name}>`, `</${parent.name}>`);
 		parent.end = start;
 		parser.pop();
 		parser.last_auto_closed_tag = {
 			tag: parent.name,
-			reason: name,
+			reason: tag.name,
 			depth: parser.stack.length
 		};
 	}
@@ -211,7 +217,7 @@ export default function element(parser) {
 
 	const current = parser.current();
 	const is_top_level_script_or_style =
-		(name === 'script' || name === 'style') && current.type === 'Root';
+		(tag.name === 'script' || tag.name === 'style') && current.type === 'Root';
 
 	const read = is_top_level_script_or_style ? read_static_attribute : read_attribute;
 
@@ -324,7 +330,7 @@ export default function element(parser) {
 			}
 		}
 
-		if (name === 'script') {
+		if (tag.name === 'script') {
 			const content = read_script(parser, start, element.attributes);
 			if (prev_comment) {
 				// We take advantage of the fact that the root will never have leadingComments set,
@@ -352,7 +358,7 @@ export default function element(parser) {
 
 	parser.append(element);
 
-	const self_closing = parser.eat('/') || is_void(name);
+	const self_closing = parser.eat('/') || is_void(tag.name);
 	const closed = parser.eat('>', true, false);
 
 	// Loose parsing mode
@@ -382,7 +388,7 @@ export default function element(parser) {
 	if (self_closing || !closed) {
 		// don't push self-closing elements onto the stack
 		element.end = parser.index;
-	} else if (name === 'textarea') {
+	} else if (tag.name === 'textarea') {
 		// special case
 		element.fragment.nodes = read_sequence(
 			parser,
@@ -391,10 +397,10 @@ export default function element(parser) {
 		);
 		parser.read(regex_closing_textarea_tag);
 		element.end = parser.index;
-	} else if (name === 'script' || name === 'style') {
+	} else if (tag.name === 'script' || tag.name === 'style') {
 		// special case
 		const start = parser.index;
-		const data = parser.read_until(new RegExp(`</${name}>`));
+		const data = parser.read_until(new RegExp(`</${tag.name}>`));
 		const end = parser.index;
 
 		/** @type {AST.Text} */
@@ -407,7 +413,7 @@ export default function element(parser) {
 		};
 
 		element.fragment.nodes.push(node);
-		parser.eat(`</${name}>`, true);
+		parser.eat(`</${tag.name}>`, true);
 		element.end = parser.index;
 	} else {
 		parser.stack.push(element);
@@ -450,8 +456,8 @@ function parent_is_shadowroot_template(stack) {
 function read_static_attribute(parser) {
 	const start = parser.index;
 
-	const name = parser.read_until(regex_token_ending_character);
-	if (!name) return null;
+	const tag = read_tag(parser, regex_token_ending_character);
+	if (!tag.name) return null;
 
 	/** @type {true | Array<AST.Text | AST.ExpressionTag>} */
 	let value = true;
@@ -485,7 +491,7 @@ function read_static_attribute(parser) {
 		e.expected_token(parser.index, '=');
 	}
 
-	return create_attribute(name, start, parser.index, value);
+	return create_attribute(tag.name, tag.loc, start, parser.index, value);
 }
 
 /**
@@ -538,10 +544,9 @@ function read_attribute(parser) {
 
 			return spread;
 		} else {
-			const value_start = parser.index;
-			let name = parser.read_identifier();
+			const id = parser.read_identifier();
 
-			if (name === null) {
+			if (id.name === '') {
 				if (
 					parser.loose &&
 					(parser.match('#') || parser.match('/') || parser.match('@') || parser.match(':'))
@@ -551,7 +556,6 @@ function read_attribute(parser) {
 					return null;
 				} else if (parser.loose && parser.match('}')) {
 					// Likely in the middle of typing, just created the shorthand
-					name = '';
 				} else {
 					e.attribute_empty_shorthand(start);
 				}
@@ -563,32 +567,28 @@ function read_attribute(parser) {
 			/** @type {AST.ExpressionTag} */
 			const expression = {
 				type: 'ExpressionTag',
-				start: value_start,
-				end: value_start + name.length,
-				expression: {
-					start: value_start,
-					end: value_start + name.length,
-					type: 'Identifier',
-					name
-				},
+				start: id.start,
+				end: id.end,
+				expression: id,
 				metadata: {
 					expression: new ExpressionMetadata()
 				}
 			};
 
-			return create_attribute(name, start, parser.index, expression);
+			return create_attribute(id.name, id.loc, start, parser.index, expression);
 		}
 	}
 
-	const name = parser.read_until(regex_token_ending_character);
-	if (!name) return null;
+	const tag = read_tag(parser, regex_token_ending_character);
+
+	if (!tag.name) return null;
 
 	let end = parser.index;
 
 	parser.allow_whitespace();
 
-	const colon_index = name.indexOf(':');
-	const type = colon_index !== -1 && get_directive_type(name.slice(0, colon_index));
+	const colon_index = tag.name.indexOf(':');
+	const type = colon_index !== -1 && get_directive_type(tag.name.slice(0, colon_index));
 
 	/** @type {true | AST.ExpressionTag | Array<AST.Text | AST.ExpressionTag>} */
 	let value = true;
@@ -617,10 +617,10 @@ function read_attribute(parser) {
 	}
 
 	if (type) {
-		const [directive_name, ...modifiers] = name.slice(colon_index + 1).split('|');
+		const [directive_name, ...modifiers] = tag.name.slice(colon_index + 1).split('|');
 
 		if (directive_name === '') {
-			e.directive_missing_name({ start, end: start + colon_index + 1 }, name);
+			e.directive_missing_name({ start, end: start + colon_index + 1 }, tag.name);
 		}
 
 		if (type === 'StyleDirective') {
@@ -629,6 +629,7 @@ function read_attribute(parser) {
 				end,
 				type,
 				name: directive_name,
+				name_loc: tag.loc,
 				modifiers: /** @type {Array<'important'>} */ (modifiers),
 				value,
 				metadata: {
@@ -659,6 +660,7 @@ function read_attribute(parser) {
 			end,
 			type,
 			name: directive_name,
+			name_loc: tag.loc,
 			expression,
 			metadata: {
 				expression: new ExpressionMetadata()
@@ -669,7 +671,7 @@ function read_attribute(parser) {
 		directive.modifiers = modifiers;
 
 		if (directive.type === 'TransitionDirective') {
-			const direction = name.slice(0, colon_index);
+			const direction = tag.name.slice(0, colon_index);
 			directive.intro = direction === 'in' || direction === 'transition';
 			directive.outro = direction === 'out' || direction === 'transition';
 		}
@@ -690,7 +692,7 @@ function read_attribute(parser) {
 		return directive;
 	}
 
-	return create_attribute(name, start, end, value);
+	return create_attribute(tag.name, tag.loc, start, end, value);
 }
 
 /**
@@ -851,3 +853,25 @@ function read_sequence(parser, done, location) {
 		e.unexpected_eof(parser.template.length);
 	}
 }
+
+/**
+ * @param {Parser} parser
+ * @param {RegExp} regex
+ * @returns {Identifier & { start: number, end: number, loc: SourceLocation }}
+ */
+function read_tag(parser, regex) {
+	const start = parser.index;
+	const name = parser.read_until(regex);
+	const end = parser.index;
+
+	return {
+		type: 'Identifier',
+		name,
+		start,
+		end,
+		loc: {
+			start: locator(start),
+			end: locator(end)
+		}
+	};
+}

package/src/compiler/phases/1-parse/state/tag.js

@@ -177,7 +177,7 @@ function open(parser) {
 
 		if (parser.eat(',')) {
 			parser.allow_whitespace();
-			index = parser.read_identifier();
+			index = parser.read_identifier().name;
 			if (!index) {
 				e.expected_identifier(parser.index);
 			}
@@ -347,16 +347,10 @@ function open(parser) {
 	if (parser.eat('snippet')) {
 		parser.require_whitespace();
 
-		const name_start = parser.index;
-		let name = parser.read_identifier();
-		const name_end = parser.index;
+		const id = parser.read_identifier();
 
-		if (name === null) {
-			if (parser.loose) {
-				name = '';
-			} else {
-				e.expected_identifier(parser.index);
-			}
+		if (id.name === '' && !parser.loose) {
+			e.expected_identifier(parser.index);
 		}
 
 		parser.allow_whitespace();
@@ -415,12 +409,7 @@ function open(parser) {
 			type: 'SnippetBlock',
 			start,
 			end: -1,
-			expression: {
-				type: 'Identifier',
-				start: name_start,
-				end: name_end,
-				name
-			},
+			expression: id,
 			typeParams: type_params,
 			parameters: function_expression.params,
 			body: create_fragment(),

package/src/compiler/phases/2-analyze/index.js

@@ -900,7 +900,7 @@ export function analyze_component(root, source, options) {
 		// We need an empty class to generate the set_class() or class="" correctly
 		if (!has_spread && !has_class && (node.metadata.scoped || has_class_directive)) {
 			node.attributes.push(
-				create_attribute('class', -1, -1, [
+				create_attribute('class', null, -1, -1, [
 					{
 						type: 'Text',
 						data: '',
@@ -915,7 +915,7 @@ export function analyze_component(root, source, options) {
 		// We need an empty style to generate the set_style() correctly
 		if (!has_spread && !has_style && has_style_directive) {
 			node.attributes.push(
-				create_attribute('style', -1, -1, [
+				create_attribute('style', null, -1, -1, [
 					{
 						type: 'Text',
 						data: '',

package/src/compiler/phases/2-analyze/visitors/Identifier.js

@@ -114,7 +114,8 @@ export function Identifier(node, context) {
 						binding.initial.arguments[0].type !== 'SpreadElement' &&
 						!should_proxy(binding.initial.arguments[0], context.state.scope)))) ||
 				binding.kind === 'raw_state' ||
-				binding.kind === 'derived') &&
+				binding.kind === 'derived' ||
+				binding.kind === 'prop') &&
 			// We're only concerned with reads here
 			(parent.type !== 'AssignmentExpression' || parent.left !== node) &&
 			parent.type !== 'UpdateExpression'

package/src/compiler/phases/2-analyze/visitors/RegularElement.js

@@ -48,8 +48,9 @@ export function RegularElement(node, context) {
 			node.attributes.push(
 				create_attribute(
 					'value',
-					/** @type {AST.Text} */ (node.fragment.nodes.at(0)).start,
-					/** @type {AST.Text} */ (node.fragment.nodes.at(-1)).end,
+					null,
+					-1,
+					-1,
 					// @ts-ignore
 					node.fragment.nodes
 				)

package/src/compiler/phases/3-transform/client/transform-template/index.js

@@ -1,4 +1,3 @@
-/** @import { Location } from 'locate-character' */
 /** @import { Namespace } from '#compiler' */
 /** @import { ComponentClientTransformState } from '../types.js' */
 /** @import { Node } from './types.js' */
@@ -15,7 +14,7 @@ function build_locations(nodes) {
 	for (const node of nodes) {
 		if (node.type !== 'element') continue;
 
-		const { line, column } = /** @type {Location} */ (locator(node.start));
+		const { line, column } = locator(node.start);
 
 		const expression = b.array([b.literal(line), b.literal(column)]);
 		const children = build_locations(node.children);

package/src/compiler/phases/3-transform/client/visitors/BindDirective.js

@@ -40,22 +40,38 @@ export function BindDirective(node, context) {
 			validate_binding(context.state, node, expression);
 		}
 
-		get = b.thunk(expression);
+		const assignment = /** @type {Expression} */ (
+			context.visit(b.assignment('=', /** @type {Pattern} */ (node.expression), b.id('$$value')))
+		);
 
-		/** @type {Expression | undefined} */
-		set = b.unthunk(
-			b.arrow(
+		if (dev) {
+			// in dev, create named functions, so that `$inspect(...)` delivers
+			// useful stack traces
+			get = b.function(b.id('get', node.name_loc), [], b.block([b.return(expression)]));
+			set = b.function(
+				b.id('set', node.name_loc),
 				[b.id('$$value')],
-				/** @type {Expression} */ (
-					context.visit(
-						b.assignment('=', /** @type {Pattern} */ (node.expression), b.id('$$value'))
+				b.block([b.stmt(assignment)])
+			);
+		} else {
+			// in prod, optimise for brevity
+			get = b.thunk(expression);
+
+			/** @type {Expression | undefined} */
+			set = b.unthunk(
+				b.arrow(
+					[b.id('$$value')],
+					/** @type {Expression} */ (
+						context.visit(
+							b.assignment('=', /** @type {Pattern} */ (node.expression), b.id('$$value'))
+						)
 					)
 				)
-			)
-		);
+			);
 
-		if (get === set) {
-			set = undefined;
+			if (get === set) {
+				set = undefined;
+			}
 		}
 	}
 

package/src/compiler/phases/3-transform/client/visitors/CallExpression.js

@@ -39,7 +39,8 @@ export function CallExpression(node, context) {
 				}
 			}
 
-			return b.call('$.state', value);
+			const callee = b.id('$.state', node.callee.loc);
+			return b.call(callee, value);
 		}
 
 		case '$derived':

package/src/compiler/phases/3-transform/client/visitors/Component.js

@@ -1,6 +1,5 @@
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types' */
-import { regex_is_valid_identifier } from '../../../patterns.js';
 import { build_component } from './shared/component.js';
 
 /**
@@ -8,6 +7,6 @@ import { build_component } from './shared/component.js';
  * @param {ComponentContext} context
  */
 export function Component(node, context) {
-	const component = build_component(node, node.name, context);
+	const component = build_component(node, node.name, node.name_loc, context);
 	context.state.init.push(component);
 }

package/src/compiler/phases/3-transform/client/visitors/Fragment.js

@@ -81,7 +81,7 @@ export function Fragment(node, context) {
 	if (is_single_element) {
 		const element = /** @type {AST.RegularElement} */ (trimmed[0]);
 
-		const id = b.id(context.state.scope.generate(element.name));
+		const id = b.id(context.state.scope.generate(element.name), element.name_loc);
 
 		context.visit(element, {
 			...state,

package/src/compiler/phases/3-transform/client/visitors/RegularElement.js

@@ -407,6 +407,7 @@ export function RegularElement(node, context) {
 			const synthetic_node = node.metadata.synthetic_value_node;
 			const synthetic_attribute = create_attribute(
 				'value',
+				null,
 				synthetic_node.start,
 				synthetic_node.end,
 				[synthetic_node]

package/src/compiler/phases/3-transform/client/visitors/SvelteComponent.js

@@ -1,12 +1,13 @@
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types' */
 import { build_component } from './shared/component.js';
+import * as b from '#compiler/builders';
 
 /**
  * @param {AST.SvelteComponent} node
  * @param {ComponentContext} context
  */
 export function SvelteComponent(node, context) {
-	const component = build_component(node, '$$component', context);
+	const component = build_component(node, '$$component', null, context);
 	context.state.init.push(component);
 }

package/src/compiler/phases/3-transform/client/visitors/SvelteHead.js

@@ -14,7 +14,7 @@ export function SvelteHead(node, context) {
 	context.state.init.push(
 		b.stmt(
 			b.call(
-				'$.head',
+				b.id('$.head', node.name_loc),
 				b.literal(hash(filename)),
 				b.arrow([b.id('$$anchor')], /** @type {BlockStatement} */ (context.visit(node.fragment)))
 			)