svelte 5.46.4 → 5.47.1

package/package.json

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

package/src/compiler/phases/2-analyze/css/css-prune.js

@@ -770,7 +770,39 @@ function get_ancestor_elements(node, adjacent_only, seen = new Set()) {
 		}
 
 		if (parent.type === 'RegularElement' || parent.type === 'SvelteElement') {
+			// Special handling for <option> inside <select>: elements inside <option> should
+			// also be considered descendants of <selectedcontent>, which clones the selected option's content
+			if (parent.type === 'RegularElement' && parent.name === 'option') {
+				const is_direct_child = ancestors.length === 0;
+
+				const select_element = path.findLast(
+					(element, j) => element.type === 'RegularElement' && element.name === 'select' && j < i
+				);
+
+				if (select_element && (!adjacent_only || is_direct_child)) {
+					/** @type {Compiler.AST.RegularElement | null} */
+					let selectedcontent_element = null;
+					walk(select_element, null, {
+						RegularElement(child, context) {
+							if (child.name === 'selectedcontent') {
+								selectedcontent_element = child;
+								context.stop();
+								return;
+							}
+							context.next();
+						}
+					});
+
+					if (adjacent_only && is_direct_child && selectedcontent_element) {
+						return [selectedcontent_element, parent];
+					} else if (selectedcontent_element) {
+						ancestors.push(selectedcontent_element);
+					}
+				}
+			}
+
 			ancestors.push(parent);
+
 			if (adjacent_only) {
 				break;
 			}
@@ -817,6 +849,34 @@ function get_descendant_elements(node, adjacent_only, seen = new Set()) {
 
 	walk_children(node.type === 'RenderTag' ? node : node.fragment);
 
+	// Special handling for <selectedcontent>: it clones the content of the selected <option>,
+	// so descendants of <option> elements in the same <select> should also be considered descendants
+	if (node.type === 'RegularElement' && node.name === 'selectedcontent') {
+		const path = node.metadata.path;
+		const select_element = path.findLast(
+			(/** @type {Compiler.AST.SvelteNode} */ element) =>
+				element.type === 'RegularElement' && element.name === 'select'
+		);
+
+		if (select_element) {
+			walk(
+				select_element,
+				{ inside_option: false },
+				{
+					_(child, context) {
+						if (child.type === 'RegularElement' && child.name === 'option') {
+							context.next({ inside_option: true });
+						} else if (context.state.inside_option) {
+							walk_children(child);
+						} else {
+							context.next();
+						}
+					}
+				}
+			);
+		}
+	}
+
 	return descendants;
 }
 

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

@@ -7,7 +7,11 @@ import {
 } from '../../../../html-tree-validation.js';
 import * as e from '../../../errors.js';
 import * as w from '../../../warnings.js';
-import { create_attribute, is_custom_element_node } from '../../nodes.js';
+import {
+	create_attribute,
+	is_custom_element_node,
+	is_customizable_select_element
+} from '../../nodes.js';
 import { regex_starts_with_newline } from '../../patterns.js';
 import { check_element } from './shared/a11y/index.js';
 import { validate_element } from './shared/element.js';
@@ -74,6 +78,15 @@ export function RegularElement(node, context) {
 		node.metadata.synthetic_value_node = child;
 	}
 
+	// Special case: <select>, <option> or <optgroup> with rich content needs special hydration handling
+	// We mark the subtree as dynamic so parent elements properly include the child init code
+	if (is_customizable_select_element(node) || node.name === 'selectedcontent') {
+		// Mark the element's own fragment as dynamic so it's not treated as static
+		node.fragment.metadata.dynamic = true;
+		// Also mark ancestor fragments so parents properly include the child init code
+		mark_subtree_dynamic(context.path);
+	}
+
 	const binding = context.state.scope.get(node.name);
 	if (
 		binding !== null &&

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

@@ -1,6 +1,7 @@
 /** @import { AST } from '#compiler' */
 /** @import { Context } from '../types' */
 import * as e from '../../../errors.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
 
 const valid = ['onerror', 'failed', 'pending'];
 
@@ -23,5 +24,7 @@ export function SvelteBoundary(node, context) {
 		}
 	}
 
+	mark_subtree_dynamic(context.path);
+
 	context.next();
 }

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

@@ -831,6 +831,10 @@ function has_content(element) {
 				return true;
 			}
 
+			if (node.name === 'selectedcontent') {
+				return true;
+			}
+
 			if (!has_content(node)) {
 				continue;
 			}

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

@@ -11,7 +11,12 @@ import {
 import { is_ignored } from '../../../../state.js';
 import { is_event_attribute, is_text_attribute } from '../../../../utils/ast.js';
 import * as b from '#compiler/builders';
-import { create_attribute, ExpressionMetadata, is_custom_element_node } from '../../../nodes.js';
+import {
+	create_attribute,
+	ExpressionMetadata,
+	is_custom_element_node,
+	is_customizable_select_element
+} from '../../../nodes.js';
 import { clean_nodes, determine_namespace_for_children } from '../../utils.js';
 import { build_getter } from '../utils.js';
 import {
@@ -21,9 +26,12 @@ import {
 	build_set_class,
 	build_set_style
 } from './shared/element.js';
-import { process_children } from './shared/fragment.js';
+import { process_children, is_static_element } from './shared/fragment.js';
 import { build_render_statement, build_template_chunk, Memoizer } from './shared/utils.js';
 import { visit_event_attribute } from './shared/events.js';
+import { Template } from '../transform-template/template.js';
+import { transform_template } from '../transform-template/index.js';
+import { TEMPLATE_FRAGMENT } from '../../../../../constants.js';
 
 /**
  * @param {AST.RegularElement} node
@@ -351,13 +359,65 @@ export function RegularElement(node, context) {
 				b.stmt(b.assignment('=', b.member(context.state.node, 'textContent'), value))
 			);
 		}
+	} else if (is_customizable_select_element(node)) {
+		// For <option>, <optgroup>, or <select> elements with rich content, we need to branch based on browser support.
+		// Modern browsers preserve rich HTML in options, older browsers strip it to text only.
+		// We create a separate template for the rich content and append it to the element.
+
+		const element_node = context.state.node;
+
+		// Add a hydration marker inside the option element so $.child() has an anchor to find
+		context.state.template.push_comment();
+
+		// Create a separate template for the rich content
+		const template_name = context.state.scope.root.unique(`${node.name}_content`);
+		const fragment_id = b.id(context.state.scope.generate('fragment'));
+		const anchor_id = b.id(context.state.scope.generate('anchor'));
+
+		// Create state with a new template for the rich content
+		/** @type {typeof state} */
+		const select_state = {
+			...state,
+			init: [],
+			update: [],
+			after_update: [],
+			template: new Template()
+		};
+
+		process_children(
+			trimmed,
+			(is_text) => b.call('$.first_child', fragment_id, is_text && b.true),
+			false,
+			{
+				...context,
+				state: select_state
+			}
+		);
+
+		// Transform the template to $.from_html(...) and hoist it
+		const template = transform_template(select_state, metadata.namespace, TEMPLATE_FRAGMENT);
+		context.state.hoisted.push(b.var(template_name, template));
+
+		// Build the rich content function body
+		// The anchor is the child of the element (a hydration marker during hydration)
+		const body = b.block([
+			b.var(anchor_id, b.call('$.child', element_node)),
+			b.var(fragment_id, b.call(template_name)),
+			...select_state.init,
+			...(select_state.update.length > 0 ? [build_render_statement(select_state)] : []),
+			...select_state.after_update,
+			b.stmt(b.call('$.append', anchor_id, fragment_id))
+		]);
+
+		child_state.init.push(b.stmt(b.call('$.customizable_select', element_node, b.arrow([], body))));
 	} else {
 		/** @type {Expression} */
 		let arg = context.state.node;
 
 		// If `hydrate_node` is set inside the element, we need to reset it
-		// after the element has been hydrated
-		let needs_reset = trimmed.some((node) => node.type !== 'Text');
+		// after the element has been hydrated. We need to check if any child
+		// would actually advance the hydrate_node cursor - static elements don't.
+		let needs_reset = trimmed.some((node) => node.type !== 'Text' && !is_static_element(node));
 
 		// The same applies if it's a `<template>` element, since we need to
 		// set the value of `hydrate_node` to `node.content`
@@ -397,6 +457,18 @@ export function RegularElement(node, context) {
 		context.state.after_update.push(...element_state.after_update);
 	}
 
+	if (node.name === 'selectedcontent') {
+		context.state.init.push(
+			b.stmt(
+				b.call(
+					'$.selectedcontent',
+					context.state.node,
+					b.arrow([b.id('$$element')], b.assignment('=', context.state.node, b.id('$$element')))
+				)
+			)
+		);
+	}
+
 	if (lookup.has('dir')) {
 		// This fixes an issue with Chromium where updates to text content within an element
 		// does not update the direction when set to auto. If we just re-assign the dir, this fixes it.

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

@@ -98,7 +98,7 @@ export function process_children(nodes, initial, is_element, context) {
 
 			let child_state = context.state;
 
-			if (is_static_element(node, context.state)) {
+			if (is_static_element(node)) {
 				skipped += 1;
 			} else if (
 				node.type === 'EachBlock' &&
@@ -137,9 +137,8 @@ export function process_children(nodes, initial, is_element, context) {
 
 /**
  * @param {AST.SvelteNode} node
- * @param {ComponentContext["state"]} state
  */
-function is_static_element(node, state) {
+export function is_static_element(node) {
 	if (node.type !== 'RegularElement') return false;
 	if (node.fragment.metadata.dynamic) return false;
 	if (is_custom_element_node(node)) return false; // we're setting all attributes on custom elements through properties

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

@@ -15,6 +15,7 @@ import {
 	PromiseOptimiser,
 	create_async_block
 } from './shared/utils.js';
+import { is_customizable_select_element } from '../../../nodes.js';
 
 /**
  * @param {AST.RegularElement} node
@@ -124,6 +125,10 @@ export function RegularElement(node, context) {
 
 		const [attributes, ...rest] = prepare_element_spread_object(node, context, optimiser.transform);
 
+		if (is_customizable_select_element(node)) {
+			rest.push(b.true);
+		}
+
 		const statement = b.stmt(b.call('$$renderer.select', attributes, fn, ...rest));
 
 		if (optimiser.expressions.length > 0) {
@@ -149,14 +154,34 @@ export function RegularElement(node, context) {
 			const inner_state = { ...state, template: [], init: [] };
 			process_children(trimmed, { ...context, state: inner_state });
 
-			body = b.arrow(
-				[b.id('$$renderer')],
-				b.block([...state.init, ...build_template(inner_state.template)])
-			);
+			/** @type {import('estree').Statement[]} */
+			const body_statements = [...state.init, ...build_template(inner_state.template)];
+
+			if (dev) {
+				const location = locator(node.start);
+				body_statements.unshift(
+					b.stmt(
+						b.call(
+							'$.push_element',
+							b.id('$$renderer'),
+							b.literal(node.name),
+							b.literal(location.line),
+							b.literal(location.column)
+						)
+					)
+				);
+				body_statements.push(b.stmt(b.call('$.pop_element')));
+			}
+
+			body = b.arrow([b.id('$$renderer')], b.block(body_statements));
 		}
 
 		const [attributes, ...rest] = prepare_element_spread_object(node, context, optimiser.transform);
 
+		if (is_customizable_select_element(node)) {
+			rest.push(b.true);
+		}
+
 		const statement = b.stmt(b.call('$$renderer.option', attributes, body, ...rest));
 
 		if (optimiser.expressions.length > 0) {
@@ -192,7 +217,14 @@ export function RegularElement(node, context) {
 			)
 		);
 	} else {
+		// For optgroup or select with rich content, add hydration marker at the start
 		process_children(trimmed, { ...context, state });
+		if (
+			(node.name === 'optgroup' || node.name === 'select') &&
+			is_customizable_select_element(node)
+		) {
+			state.template.push(b.literal('<!>'));
+		}
 	}
 
 	if (!node_is_void) {

package/src/compiler/phases/nodes.js

@@ -148,3 +148,98 @@ export function get_name(node) {
 
 	return null;
 }
+
+/**
+ * Checks if an <option>, <optgroup>, or <select> element has rich content that requires special hydration handling.
+ * Rich content is anything beyond simple text, expressions, and comments for <option>,
+ * anything beyond <option> children for <optgroup>,
+ * or anything beyond <option>, <optgroup>, and empty text for <select>.
+ * Control flow blocks are recursively checked - they only count as rich content if they contain rich content.
+ * @param {AST.RegularElement} node
+ * @returns {boolean}
+ */
+export function is_customizable_select_element(node) {
+	if (node.name === 'select' || node.name === 'optgroup' || node.name === 'option') {
+		for (const child of find_descendants(node.fragment)) {
+			if (child.type === 'RegularElement') {
+				if (node.name === 'select' && child.name !== 'option' && child.name !== 'optgroup') {
+					return true;
+				}
+
+				if (node.name === 'optgroup' && child.name !== 'option') {
+					return true;
+				}
+
+				if (node.name === 'option') {
+					return true;
+				}
+			}
+
+			// Text nodes directly in <select> or <optgroup> are rich content
+			else if (child.type === 'Text') {
+				if (node.name === 'select' || node.name === 'optgroup') {
+					return true;
+				}
+			}
+
+			// Any non-RegularElement, non-Text node is rich content
+			else {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+/**
+ * @param {AST.Fragment | null} fragment
+ * @returns {Iterable<AST.SvelteNode>}
+ */
+function* find_descendants(fragment) {
+	if (fragment === null) return;
+
+	for (const node of fragment.nodes) {
+		switch (node.type) {
+			case 'SnippetBlock':
+			case 'DebugTag':
+			case 'ConstTag':
+			case 'Comment':
+			case 'ExpressionTag':
+				break;
+
+			case 'Text':
+				if (node.data.trim() !== '') {
+					yield node;
+				}
+				break;
+
+			case 'IfBlock':
+				yield* find_descendants(node.consequent);
+				yield* find_descendants(node.alternate);
+				break;
+
+			case 'EachBlock':
+				yield* find_descendants(node.body);
+				yield* find_descendants(node.fallback ?? null);
+				break;
+
+			case 'KeyBlock':
+				yield* find_descendants(node.fragment);
+				break;
+
+			case 'AwaitBlock':
+				yield* find_descendants(node.pending);
+				yield* find_descendants(node.then);
+				yield* find_descendants(node.catch);
+				break;
+
+			case 'SvelteBoundary':
+				yield* find_descendants(node.fragment);
+				break;
+
+			default:
+				yield node;
+		}
+	}
+}

package/src/html-tree-validation.js

@@ -80,9 +80,9 @@ export function closing_tag_omitted(current, next) {
  */
 const disallowed_children = {
 	...autoclosing_children,
-	optgroup: { only: ['option', '#text'] },
 	// Strictly speaking, seeing an <option> doesn't mean we're in a <select>, but we assume it here
-	option: { only: ['#text'] },
+	// option or optgroup does not have an `only` restriction because newer browsers support rich HTML content
+	// inside option elements. For older browsers, hydration will handle the mismatch.
 	form: { descendant: ['form'] },
 	a: { descendant: ['a'] },
 	button: { descendant: ['button'] },
@@ -92,8 +92,6 @@ const disallowed_children = {
 	h4: { descendant: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] },
 	h5: { descendant: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] },
 	h6: { descendant: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] },
-	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
-	select: { only: ['option', 'optgroup', '#text', 'hr', 'script', 'template'] },
 
 	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
 	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption

package/src/internal/client/dom/elements/customizable-select.js

@@ -0,0 +1,98 @@
+import { hydrating, reset, set_hydrate_node, set_hydrating } from '../hydration.js';
+import { create_comment } from '../operations.js';
+import { attach } from './attachments.js';
+
+/** @type {boolean | null} */
+let supported = null;
+
+/**
+ * Checks if the browser supports rich HTML content inside `<option>` elements.
+ * Modern browsers preserve HTML elements inside options, while older browsers
+ * strip them during parsing, leaving only text content.
+ * @returns {boolean}
+ */
+function is_supported() {
+	if (supported === null) {
+		var select = document.createElement('select');
+		select.innerHTML = '<option><span>t</span></option>';
+		supported = /** @type {Element} */ (select.firstChild)?.firstChild?.nodeType === 1;
+	}
+
+	return supported;
+}
+
+/**
+ *
+ * @param {HTMLElement} element
+ * @param {(new_element: HTMLElement) => void} update_element
+ */
+export function selectedcontent(element, update_element) {
+	// if it's not supported no need for special logic
+	if (!is_supported()) return;
+
+	// we use the attach function directly just to make sure is executed when is mounted to the dom
+	attach(element, () => () => {
+		const select = element.closest('select');
+		if (!select) return;
+
+		const observer = new MutationObserver((entries) => {
+			var selected = false;
+
+			for (const entry of entries) {
+				if (entry.target === element) {
+					// the `<selectedcontent>` already changed, no need to replace it
+					return;
+				}
+
+				// if the changes doesn't include the selected `<option>` we don't need to do anything
+				selected ||= !!entry.target.parentElement?.closest('option')?.selected;
+			}
+
+			if (selected) {
+				// replace the `<selectedcontent>` with a clone
+				element.replaceWith((element = /** @type {HTMLElement} */ (element.cloneNode(true))));
+				update_element(element);
+			}
+		});
+
+		observer.observe(select, {
+			childList: true,
+			characterData: true,
+			subtree: true
+		});
+
+		return () => {
+			observer.disconnect();
+		};
+	});
+}
+
+/**
+ * Handles rich HTML content inside `<option>`, `<optgroup>`, or `<select>` elements with browser-specific branching.
+ * Modern browsers preserve HTML inside options, while older browsers strip it to text only.
+ *
+ * @param {HTMLOptionElement | HTMLOptGroupElement | HTMLSelectElement} element The element to process
+ * @param {() => void} rich_fn Function to process rich HTML content (modern browsers)
+ */
+export function customizable_select(element, rich_fn) {
+	var was_hydrating = hydrating;
+
+	if (!is_supported()) {
+		set_hydrating(false);
+		element.textContent = '';
+		element.append(create_comment(''));
+	}
+
+	try {
+		rich_fn();
+	} finally {
+		if (was_hydrating) {
+			if (hydrating) {
+				reset(element);
+			} else {
+				set_hydrating(true);
+				set_hydrate_node(element);
+			}
+		}
+	}
+}

package/src/internal/client/index.js

@@ -42,6 +42,7 @@ export {
 export { set_class } from './dom/elements/class.js';
 export { apply, event, delegate, replay_events } from './dom/elements/events.js';
 export { autofocus, remove_textarea_child } from './dom/elements/misc.js';
+export { customizable_select, selectedcontent } from './dom/elements/customizable-select.js';
 export { set_style } from './dom/elements/style.js';
 export { animation, transition } from './dom/elements/transitions.js';
 export { bind_active_element } from './dom/elements/bindings/document.js';

package/src/internal/server/renderer.js

@@ -220,9 +220,10 @@ export class Renderer {
 	 * @param {Record<string, boolean> | undefined} [classes]
 	 * @param {Record<string, string> | undefined} [styles]
 	 * @param {number | undefined} [flags]
+	 * @param {boolean | undefined} [is_rich]
 	 * @returns {void}
 	 */
-	select(attrs, fn, css_hash, classes, styles, flags) {
+	select(attrs, fn, css_hash, classes, styles, flags, is_rich) {
 		const { value, ...select_attrs } = attrs;
 
 		this.push(`<select${attributes(select_attrs, css_hash, classes, styles, flags)}>`);
@@ -230,7 +231,7 @@ export class Renderer {
 			renderer.local.select_value = value;
 			fn(renderer);
 		});
-		this.push('</select>');
+		this.push(`${is_rich ? '<!>' : ''}</select>`);
 	}
 
 	/**
@@ -240,8 +241,9 @@ export class Renderer {
 	 * @param {Record<string, boolean> | undefined} [classes]
 	 * @param {Record<string, string> | undefined} [styles]
 	 * @param {number | undefined} [flags]
+	 * @param {boolean | undefined} [is_rich]
 	 */
-	option(attrs, body, css_hash, classes, styles, flags) {
+	option(attrs, body, css_hash, classes, styles, flags, is_rich) {
 		this.#out.push(`<option${attributes(attrs, css_hash, classes, styles, flags)}`);
 
 		/**
@@ -258,7 +260,7 @@ export class Renderer {
 				renderer.#out.push(' selected');
 			}
 
-			renderer.#out.push(`>${body}</option>`);
+			renderer.#out.push(`>${body}${is_rich ? '<!>' : ''}</option>`);
 
 			// super edge case, but may as well handle it
 			if (head) {

package/src/version.js

@@ -4,5 +4,5 @@
  * The current version, as set in package.json.
  * @type {string}
  */
-export const VERSION = '5.46.4';
+export const VERSION = '5.47.1';
 export const PUBLIC_VERSION = '5';