svelte 5.48.5 → 5.49.1

package/elements.d.ts

@@ -2062,7 +2062,7 @@ export interface SvelteHTMLElements {
 			| undefined
 			| {
 					tag?: string;
-					shadow?: 'open' | 'none' | undefined;
+					shadow?: 'open' | 'none' | ShadowRootInit | undefined;
 					props?:
 						| Record<
 								string,

package/package.json

@@ -2,7 +2,7 @@
   "name": "svelte",
   "description": "Cybernetically enhanced web apps",
   "license": "MIT",
-  "version": "5.48.5",
+  "version": "5.49.1",
   "type": "module",
   "types": "./types/index.d.ts",
   "engines": {
@@ -139,7 +139,7 @@
   ],
   "devDependencies": {
     "@jridgewell/trace-mapping": "^0.3.25",
-    "@playwright/test": "^1.46.1",
+    "@playwright/test": "^1.58.0",
     "@rollup/plugin-commonjs": "^28.0.1",
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-terser": "^0.4.4",
@@ -165,7 +165,7 @@
     "clsx": "^2.1.1",
     "devalue": "^5.6.2",
     "esm-env": "^1.2.1",
-    "esrap": "^2.2.1",
+    "esrap": "^2.2.2",
     "is-reference": "^3.0.3",
     "locate-character": "^3.0.0",
     "magic-string": "^0.30.11",

package/src/compiler/errors.js

@@ -1550,12 +1550,12 @@ export function svelte_options_invalid_attribute_value(node, list) {
 }
 
 /**
- * "customElement" must be a string literal defining a valid custom element name or an object of the form { tag?: string; shadow?: "open" | "none"; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }
+ * "customElement" must be a string literal defining a valid custom element name or an object of the form { tag?: string; shadow?: "open" | "none" | `ShadowRootInit`; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }
  * @param {null | number | NodeLike} node
  * @returns {never}
  */
 export function svelte_options_invalid_customelement(node) {
-	e(node, 'svelte_options_invalid_customelement', `"customElement" must be a string literal defining a valid custom element name or an object of the form { tag?: string; shadow?: "open" | "none"; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }\nhttps://svelte.dev/e/svelte_options_invalid_customelement`);
+	e(node, 'svelte_options_invalid_customelement', `"customElement" must be a string literal defining a valid custom element name or an object of the form { tag?: string; shadow?: "open" | "none" | \`ShadowRootInit\`; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }\nhttps://svelte.dev/e/svelte_options_invalid_customelement`);
 }
 
 /**
@@ -1568,12 +1568,12 @@ export function svelte_options_invalid_customelement_props(node) {
 }
 
 /**
- * "shadow" must be either "open" or "none"
+ * "shadow" must be either "open", "none" or `ShadowRootInit` object.
  * @param {null | number | NodeLike} node
  * @returns {never}
  */
 export function svelte_options_invalid_customelement_shadow(node) {
-	e(node, 'svelte_options_invalid_customelement_shadow', `"shadow" must be either "open" or "none"\nhttps://svelte.dev/e/svelte_options_invalid_customelement_shadow`);
+	e(node, 'svelte_options_invalid_customelement_shadow', `"shadow" must be either "open", "none" or \`ShadowRootInit\` object.\nhttps://svelte.dev/e/svelte_options_invalid_customelement_shadow`);
 }
 
 /**

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

@@ -133,11 +133,13 @@ export default function read_options(node) {
 
 				const shadow = properties.find(([name]) => name === 'shadow')?.[1];
 				if (shadow) {
-					const shadowdom = shadow?.value;
-					if (shadowdom !== 'open' && shadowdom !== 'none') {
-						e.svelte_options_invalid_customelement_shadow(shadow);
+					if (shadow.type === 'Literal' && (shadow.value === 'open' || shadow.value === 'none')) {
+						ce.shadow = shadow.value;
+					} else if (shadow.type === 'ObjectExpression') {
+						ce.shadow = shadow;
+					} else {
+						e.svelte_options_invalid_customelement_shadow(attribute);
 					}
-					ce.shadow = shadowdom;
 				}
 
 				const extend = properties.find(([name]) => name === 'extend')?.[1];

package/src/compiler/phases/2-analyze/visitors/shared/a11y/index.js

@@ -824,6 +824,10 @@ function has_content(element) {
 		}
 
 		if (node.type === 'RegularElement' || node.type === 'SvelteElement') {
+			if (node.attributes.some((a) => a.type === 'Attribute' && a.name === 'popover')) {
+				continue;
+			}
+
 			if (
 				node.name === 'img' &&
 				node.attributes.some((node) => node.type === 'Attribute' && node.name === 'alt')

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

@@ -638,7 +638,16 @@ export function client_component(analysis, options) {
 		const accessors_str = b.array(
 			analysis.exports.map(({ name, alias }) => b.literal(alias ?? name))
 		);
-		const use_shadow_dom = typeof ce === 'boolean' || ce.shadow !== 'none' ? true : false;
+
+		/** @type {ESTree.ObjectExpression | undefined} */
+		let shadow_root_init;
+		if (typeof ce === 'boolean' || ce.shadow === 'open' || ce.shadow === undefined) {
+			shadow_root_init = b.object([b.init('mode', b.literal('open'))]);
+		} else if (ce.shadow === 'none') {
+			shadow_root_init = undefined;
+		} else {
+			shadow_root_init = ce.shadow;
+		}
 
 		const create_ce = b.call(
 			'$.create_custom_element',
@@ -646,7 +655,7 @@ export function client_component(analysis, options) {
 			b.object(props_str),
 			slots_str,
 			accessors_str,
-			b.literal(use_shadow_dom),
+			shadow_root_init,
 			/** @type {any} */ (typeof ce !== 'boolean' ? ce.extend : undefined)
 		);
 

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

@@ -162,7 +162,10 @@ function build_assignment(operator, left, right, context) {
 	// will be pushed to. we do this by transforming it to something like
 	// `$.assign_nullish(object, 'items', [])`
 	let should_transform =
-		dev && path.at(-1) !== 'ExpressionStatement' && is_non_coercive_operator(operator);
+		dev &&
+		path.at(-1) !== 'ExpressionStatement' &&
+		is_non_coercive_operator(operator) &&
+		!context.state.scope.evaluate(right).is_primitive;
 
 	// special case — ignore `onclick={() => (...)}`
 	if (

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

@@ -70,8 +70,7 @@ export function RegularElement(node, context) {
 		if (optimiser.expressions.length > 0) {
 			context.state.template.push(
 				create_child_block(
-					b.block([optimiser.apply(), ...state.init, ...build_template(state.template)]),
-					true
+					b.block([optimiser.apply(), ...state.init, ...build_template(state.template)])
 				)
 			);
 		} else {
@@ -133,7 +132,7 @@ export function RegularElement(node, context) {
 
 		if (optimiser.expressions.length > 0) {
 			context.state.template.push(
-				create_child_block(b.block([optimiser.apply(), ...state.init, statement]), true)
+				create_child_block(b.block([optimiser.apply(), ...state.init, statement]))
 			);
 		} else {
 			context.state.template.push(...state.init, statement);
@@ -186,7 +185,7 @@ export function RegularElement(node, context) {
 
 		if (optimiser.expressions.length > 0) {
 			context.state.template.push(
-				create_child_block(b.block([optimiser.apply(), ...state.init, statement]), true)
+				create_child_block(b.block([optimiser.apply(), ...state.init, statement]))
 			);
 		} else {
 			context.state.template.push(...state.init, statement);
@@ -236,18 +235,19 @@ export function RegularElement(node, context) {
 	}
 
 	if (optimiser.is_async()) {
-		let statement = create_child_block(
-			b.block([optimiser.apply(), ...state.init, ...build_template(state.template)]),
-			true
-		);
+		let statements = [...state.init, ...build_template(state.template)];
+
+		if (optimiser.has_await) {
+			statements = [create_child_block(b.block([optimiser.apply(), ...statements]))];
+		}
 
 		const blockers = optimiser.blockers();
 
 		if (blockers.elements.length > 0) {
-			statement = create_async_block(b.block([statement]), blockers, false, false);
+			statements = [create_async_block(b.block(statements), blockers, false, false)];
 		}
 
-		context.state.template.push(statement);
+		context.state.template.push(...statements);
 	} else {
 		context.state.init.push(...state.init);
 		context.state.template.push(...state.template);

package/src/compiler/phases/3-transform/server/visitors/SvelteElement.js

@@ -79,7 +79,7 @@ export function SvelteElement(node, context) {
 	);
 
 	if (optimiser.expressions.length > 0) {
-		statement = create_child_block(b.block([optimiser.apply(), statement]), true);
+		statement = create_child_block(b.block([optimiser.apply(), statement]));
 	}
 
 	statements.push(statement);

package/src/compiler/phases/3-transform/server/visitors/shared/utils.js

@@ -264,11 +264,10 @@ export function build_getter(node, state) {
 /**
  * Creates a `$$renderer.child(...)` expression statement
  * @param {BlockStatement | Expression} body
- * @param {boolean} async
  * @returns {Statement}
  */
-export function create_child_block(body, async) {
-	return b.stmt(b.call('$$renderer.child', b.arrow([b.id('$$renderer')], body, async)));
+export function create_child_block(body) {
+	return b.stmt(b.call('$$renderer.child', b.arrow([b.id('$$renderer')], body, true)));
 }
 
 /**

package/src/compiler/phases/scope.js

@@ -228,6 +228,13 @@ class Evaluation {
 	 */
 	is_number = true;
 
+	/**
+	 * True if the value is known to be a primitive
+	 * @readonly
+	 * @type {boolean}
+	 */
+	is_primitive = true;
+
 	/**
 	 * True if the value is known to be a function
 	 * @readonly
@@ -577,6 +584,7 @@ class Evaluation {
 
 			if (value === UNKNOWN) {
 				this.has_unknown = true;
+				this.is_primitive = false;
 			}
 		}
 

package/src/compiler/print/index.js

@@ -115,57 +115,17 @@ function base_element(node, context) {
 	const is_doctype_node = node.name.toLowerCase() === '!doctype';
 	const is_self_closing =
 		is_void(node.name) || (node.type === 'Component' && node.fragment.nodes.length === 0);
-	let multiline_content = false;
 
 	if (is_doctype_node) child_context.write(`>`);
 	else if (is_self_closing) {
 		child_context.write(`${multiline_attributes ? '' : ' '}/>`);
 	} else {
 		child_context.write('>');
-
-		// Process the element's content in a separate context for measurement
-		const content_context = child_context.new();
-		const allow_inline_content = child_context.measure() < LINE_BREAK_THRESHOLD;
-		block(content_context, node.fragment, allow_inline_content);
-
-		// Determine if content should be formatted on multiple lines
-		multiline_content = content_context.measure() > LINE_BREAK_THRESHOLD;
-
-		if (multiline_content) {
-			child_context.newline();
-
-			// Only indent if attributes are inline and content itself isn't already multiline
-			const should_indent = !multiline_attributes && !content_context.multiline;
-			if (should_indent) {
-				child_context.indent();
-			}
-
-			child_context.append(content_context);
-
-			if (should_indent) {
-				child_context.dedent();
-			}
-
-			child_context.newline();
-		} else {
-			child_context.append(content_context);
-		}
-
+		block(child_context, node.fragment, true);
 		child_context.write(`</${node.name}>`);
 	}
 
-	const break_line_after = child_context.measure() > LINE_BREAK_THRESHOLD;
-
-	if ((multiline_content || multiline_attributes) && !context.empty()) {
-		context.newline();
-	}
-
 	context.append(child_context);
-
-	if (is_self_closing) return;
-	if (multiline_content || multiline_attributes || break_line_after) {
-		context.newline();
-	}
 }
 
 /** @type {Visitors<AST.SvelteNode>} */
@@ -412,6 +372,8 @@ const svelte_visitors = {
 				}
 			} else {
 				sequence.push(child_node);
+
+				if (child_node.type === 'RegularElement') flush();
 			}
 		}
 
@@ -420,18 +382,20 @@ const svelte_visitors = {
 		let multiline = false;
 		let width = 0;
 
-		const child_contexts = items.map((sequence) => {
-			const child_context = context.new();
+		const child_contexts = items
+			.filter((x) => x.length > 0)
+			.map((sequence) => {
+				const child_context = context.new();
 
-			for (const node of sequence) {
-				child_context.visit(node);
-				multiline ||= child_context.multiline;
-			}
+				for (const node of sequence) {
+					child_context.visit(node);
+					multiline ||= child_context.multiline;
+				}
 
-			width += child_context.measure();
+				width += child_context.measure();
 
-			return child_context;
-		});
+				return child_context;
+			});
 
 		multiline ||= width > LINE_BREAK_THRESHOLD;
 

package/src/internal/client/dev/assign.js

@@ -1,3 +1,4 @@
+import { STATE_SYMBOL } from '#client/constants';
 import { sanitize_location } from '../../../utils.js';
 import { untrack } from '../runtime.js';
 import * as w from '../warnings.js';
@@ -10,7 +11,7 @@ import * as w from '../warnings.js';
  * @param {string} location
  */
 function compare(a, b, property, location) {
-	if (a !== b) {
+	if (a !== b && typeof b === 'object' && STATE_SYMBOL in b) {
 		w.assignment_value_stale(property, /** @type {string} */ (sanitize_location(location)));
 	}
 

package/src/internal/client/dom/elements/custom-element.js

@@ -35,18 +35,23 @@ if (typeof HTMLElement === 'function') {
 		$$l_u = new Map();
 		/** @type {any} The managed render effect for reflecting attributes */
 		$$me;
+		/** @type {ShadowRoot | null} The ShadowRoot of the custom element */
+		$$shadowRoot = null;
 
 		/**
 		 * @param {*} $$componentCtor
 		 * @param {*} $$slots
-		 * @param {*} use_shadow_dom
+		 * @param {ShadowRootInit | undefined} shadow_root_init
 		 */
-		constructor($$componentCtor, $$slots, use_shadow_dom) {
+		constructor($$componentCtor, $$slots, shadow_root_init) {
 			super();
 			this.$$ctor = $$componentCtor;
 			this.$$s = $$slots;
-			if (use_shadow_dom) {
-				this.attachShadow({ mode: 'open' });
+
+			if (shadow_root_init) {
+				// We need to store the reference to shadow root, because `closed` shadow root cannot be
+				// accessed with `this.shadowRoot`.
+				this.$$shadowRoot = this.attachShadow(shadow_root_init);
 			}
 		}
 
@@ -136,7 +141,7 @@ if (typeof HTMLElement === 'function') {
 				}
 				this.$$c = createClassComponent({
 					component: this.$$ctor,
-					target: this.shadowRoot || this,
+					target: this.$$shadowRoot || this,
 					props: {
 						...this.$$d,
 						$$slots,
@@ -277,7 +282,7 @@ function get_custom_elements_slots(element) {
  * @param {Record<string, CustomElementPropDefinition>} props_definition  The props to observe
  * @param {string[]} slots  The slots to create
  * @param {string[]} exports  Explicitly exported values, other than props
- * @param {boolean} use_shadow_dom  Whether to use shadow DOM
+ * @param {ShadowRootInit | undefined} shadow_root_init  Options passed to shadow DOM constructor
  * @param {(ce: new () => HTMLElement) => new () => HTMLElement} [extend]
  */
 export function create_custom_element(
@@ -285,12 +290,12 @@ export function create_custom_element(
 	props_definition,
 	slots,
 	exports,
-	use_shadow_dom,
+	shadow_root_init,
 	extend
 ) {
 	let Class = class extends SvelteElement {
 		constructor() {
-			super(Component, slots, use_shadow_dom);
+			super(Component, slots, shadow_root_init);
 			this.$$p_d = props_definition;
 		}
 		static get observedAttributes() {

package/src/internal/client/dom/elements/transitions.js

@@ -239,8 +239,6 @@ export function transition(flags, element, get_fn, get_params) {
 				intro?.abort();
 			}
 
-			dispatch_event(element, 'introstart');
-
 			intro = animate(element, get_options(), outro, 1, () => {
 				dispatch_event(element, 'introend');
 
@@ -260,8 +258,6 @@ export function transition(flags, element, get_fn, get_params) {
 
 			element.inert = true;
 
-			dispatch_event(element, 'outrostart');
-
 			outro = animate(element, get_options(), intro, 0, () => {
 				dispatch_event(element, 'outroend');
 				fn?.();
@@ -345,7 +341,8 @@ function animate(element, options, counterpart, t2, on_finish) {
 
 	counterpart?.deactivate();
 
-	if (!options?.duration) {
+	if (!options?.duration && !options?.delay) {
+		dispatch_event(element, is_intro ? 'introstart' : 'outrostart');
 		on_finish();
 
 		return {
@@ -385,6 +382,8 @@ function animate(element, options, counterpart, t2, on_finish) {
 		// remove dummy animation from the stack to prevent conflict with main animation
 		animation.cancel();
 
+		dispatch_event(element, is_intro ? 'introstart' : 'outrostart');
+
 		// for bidirectional transitions, we start from the current position,
 		// rather than doing a full intro/outro
 		var t1 = counterpart?.t() ?? 1 - t2;

package/src/internal/client/dom/operations.js

@@ -122,6 +122,10 @@ export function child(node, is_text) {
 		return text;
 	}
 
+	if (is_text) {
+		merge_text_nodes(/** @type {Text} */ (child));
+	}
+
 	set_hydrate_node(child);
 	return child;
 }
@@ -142,14 +146,18 @@ export function first_child(node, is_text = false) {
 		return first;
 	}
 
-	// if an {expression} is empty during SSR, there might be no
-	// text node to hydrate — we must therefore create one
-	if (is_text && hydrate_node?.nodeType !== TEXT_NODE) {
-		var text = create_text();
+	if (is_text) {
+		// if an {expression} is empty during SSR, there might be no
+		// text node to hydrate — we must therefore create one
+		if (hydrate_node?.nodeType !== TEXT_NODE) {
+			var text = create_text();
 
-		hydrate_node?.before(text);
-		set_hydrate_node(text);
-		return text;
+			hydrate_node?.before(text);
+			set_hydrate_node(text);
+			return text;
+		}
+
+		merge_text_nodes(/** @type {Text} */ (hydrate_node));
 	}
 
 	return hydrate_node;
@@ -175,20 +183,24 @@ export function sibling(node, count = 1, is_text = false) {
 		return next_sibling;
 	}
 
-	// if a sibling {expression} is empty during SSR, there might be no
-	// text node to hydrate — we must therefore create one
-	if (is_text && next_sibling?.nodeType !== TEXT_NODE) {
-		var text = create_text();
-		// If the next sibling is `null` and we're handling text then it's because
-		// the SSR content was empty for the text, so we need to generate a new text
-		// node and insert it after the last sibling
-		if (next_sibling === null) {
-			last_sibling?.after(text);
-		} else {
-			next_sibling.before(text);
+	if (is_text) {
+		// if a sibling {expression} is empty during SSR, there might be no
+		// text node to hydrate — we must therefore create one
+		if (next_sibling?.nodeType !== TEXT_NODE) {
+			var text = create_text();
+			// If the next sibling is `null` and we're handling text then it's because
+			// the SSR content was empty for the text, so we need to generate a new text
+			// node and insert it after the last sibling
+			if (next_sibling === null) {
+				last_sibling?.after(text);
+			} else {
+				next_sibling.before(text);
+			}
+			set_hydrate_node(text);
+			return text;
 		}
-		set_hydrate_node(text);
-		return text;
+
+		merge_text_nodes(/** @type {Text} */ (next_sibling));
 	}
 
 	set_hydrate_node(next_sibling);
@@ -258,3 +270,24 @@ export function set_attribute(element, key, value = '') {
 	}
 	return element.setAttribute(key, value);
 }
+
+/**
+ * Browsers split text nodes larger than 65536 bytes when parsing.
+ * For hydration to succeed, we need to stitch them back together
+ * @param {Text} text
+ */
+export function merge_text_nodes(text) {
+	if (/** @type {string} */ (text.nodeValue).length < 65536) {
+		return;
+	}
+
+	let next = text.nextSibling;
+
+	while (next !== null && next.nodeType === TEXT_NODE) {
+		next.remove();
+
+		/** @type {string} */ (text.nodeValue) += /** @type {string} */ (next.nodeValue);
+
+		next = text.nextSibling;
+	}
+}

package/src/internal/client/dom/template.js

@@ -4,11 +4,13 @@ import { hydrate_next, hydrate_node, hydrating, set_hydrate_node } from './hydra
 import {
 	create_text,
 	get_first_child,
+	get_next_sibling,
 	is_firefox,
 	create_element,
 	create_fragment,
 	create_comment,
-	set_attribute
+	set_attribute,
+	merge_text_nodes
 } from './operations.js';
 import { create_fragment_from_html } from './reconciler.js';
 import { active_effect } from '../runtime.js';
@@ -310,6 +312,8 @@ export function text(value = '') {
 		// if an {expression} is empty during SSR, we need to insert an empty text node
 		node.before((node = create_text()));
 		set_hydrate_node(node);
+	} else {
+		merge_text_nodes(/** @type {Text} */ (node));
 	}
 
 	assign_nodes(node, node);

package/src/internal/client/reactivity/batch.js

@@ -171,6 +171,10 @@ export class Batch {
 		if (this.is_deferred()) {
 			this.#defer_effects(render_effects);
 			this.#defer_effects(effects);
+
+			for (const e of this.skipped_effects) {
+				reset_branch(e);
+			}
 		} else {
 			// append/remove branches
 			for (const fn of this.#commit_callbacks) fn();
@@ -881,6 +885,26 @@ export function eager(fn) {
 	return value;
 }
 
+/**
+ * Mark all the effects inside a skipped branch CLEAN, so that
+ * they can be correctly rescheduled later
+ * @param {Effect} effect
+ */
+function reset_branch(effect) {
+	// clean branch = nothing dirty inside, no need to traverse further
+	if ((effect.f & BRANCH_EFFECT) !== 0 && (effect.f & CLEAN) !== 0) {
+		return;
+	}
+
+	set_signal_status(effect, CLEAN);
+
+	var e = effect.first;
+	while (e !== null) {
+		reset_branch(e);
+		e = e.next;
+	}
+}
+
 /**
  * Creates a 'fork', in which state changes are evaluated but not applied to the DOM.
  * This is useful for speculatively loading data (for example) when you suspect that
@@ -972,6 +996,13 @@ export function fork(fn) {
 			await settled;
 		},
 		discard: () => {
+			// cause any MAYBE_DIRTY deriveds to update
+			// if they depend on things thath changed
+			// inside the discarded fork
+			for (var source of batch.current.keys()) {
+				source.wv = increment_write_version();
+			}
+
 			if (!committed && batches.has(batch)) {
 				batches.delete(batch);
 				batch.discard();

package/src/internal/client/runtime.js

@@ -43,7 +43,13 @@ import {
 	set_dev_current_component_function,
 	set_dev_stack
 } from './context.js';
-import { Batch, batch_values, flushSync, schedule_effect } from './reactivity/batch.js';
+import {
+	Batch,
+	batch_values,
+	current_batch,
+	flushSync,
+	schedule_effect
+} from './reactivity/batch.js';
 import { handle_error } from './error-handling.js';
 import { UNINITIALIZED } from '../../constants.js';
 import { captured_signals } from './legacy.js';
@@ -249,10 +255,16 @@ export function update_reaction(reaction) {
 		var result = fn();
 		var deps = reaction.deps;
 
+		// Don't remove reactions during fork;
+		// they must remain for when fork is discarded
+		var is_fork = current_batch?.is_fork;
+
 		if (new_deps !== null) {
 			var i;
 
-			remove_reactions(reaction, skipped_deps);
+			if (!is_fork) {
+				remove_reactions(reaction, skipped_deps);
+			}
 
 			if (deps !== null && skipped_deps > 0) {
 				deps.length = skipped_deps + new_deps.length;
@@ -268,7 +280,7 @@ export function update_reaction(reaction) {
 					(deps[i].reactions ??= []).push(reaction);
 				}
 			}
-		} else if (deps !== null && skipped_deps < deps.length) {
+		} else if (!is_fork && deps !== null && skipped_deps < deps.length) {
 			remove_reactions(reaction, skipped_deps);
 			deps.length = skipped_deps;
 		}