svelte 5.55.10 → 5.56.0

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

@@ -0,0 +1,87 @@
+/** @import { Expression, Identifier, Pattern, Statement, ExpressionStatement, VariableDeclaration } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types' */
+import { extract_identifiers, has_await_expression } from '../../../../utils/ast.js';
+import * as b from '#compiler/builders';
+import { add_state_transformers } from './shared/declarations.js';
+
+/**
+ * @param {AST.DeclarationTag} node
+ * @param {ComponentContext} context
+ */
+export function DeclarationTag(node, context) {
+	const declaration = /** @type {Statement | undefined} */ (context.visit(node.declaration));
+	add_state_transformers(context);
+
+	if (
+		node.metadata.promises_id &&
+		node.declaration.type === 'VariableDeclaration' &&
+		declaration?.type === 'VariableDeclaration'
+	) {
+		const { ids, assignments } = build_async_declaration_parts(declaration);
+		add_async_declaration(context, node.metadata, ids, assignments, declaration.kind);
+	} else {
+		context.state.consts.push(declaration ?? node.declaration);
+	}
+}
+
+/**
+ * @param {VariableDeclaration} declaration
+ */
+export function build_async_declaration_parts(declaration) {
+	const ids = new Map();
+	for (const declarator of declaration.declarations) {
+		for (const id of extract_identifiers(declarator.id)) {
+			ids.set(id.name, id);
+		}
+	}
+
+	const assignments = declaration.declarations
+		.filter((declarator) => declarator.init !== null)
+		.map((declarator) =>
+			b.stmt(
+				b.assignment(
+					'=',
+					/** @type {Pattern} */ (declarator.id),
+					/** @type {Expression} */ (declarator.init)
+				)
+			)
+		);
+
+	return { ids: [...ids.values()], assignments };
+}
+
+/**
+ * @param {ComponentContext} context
+ * @param {AST.ConstTag['metadata'] | AST.DeclarationTag['metadata']} metadata
+ * @param {Identifier[]} ids
+ * @param {ExpressionStatement[]} assignments
+ * @param {VariableDeclaration['kind']} [kind]
+ */
+export function add_async_declaration(context, metadata, ids, assignments, kind = 'let') {
+	const run = (context.state.async_consts ??= {
+		id: /** @type {Identifier} */ (metadata.promises_id),
+		thunks: []
+	});
+
+	for (const id of ids) {
+		context.state.consts.push(kind === 'var' ? b.var(id.name) : b.let(id.name));
+	}
+
+	const blockers = [...metadata.expression.dependencies]
+		.map((dep) => dep.blocker)
+		.filter((b) => b !== null && b.object !== context.state.async_consts?.id);
+
+	if (blockers.length === 1) {
+		run.thunks.push(b.thunk(b.member(/** @type {Expression} */ (blockers[0]), 'promise')));
+	} else if (blockers.length > 0) {
+		run.thunks.push(b.thunk(b.call('$.wait', b.array(blockers))));
+	}
+
+	// keep the number of thunks pushed in sync with analysis phase
+	const has_await =
+		metadata.expression.has_await ||
+		assignments.some((assignment) => has_await_expression(assignment));
+	const body = assignments.length === 1 ? assignments[0].expression : b.block(assignments);
+	run.thunks.push(b.thunk(body, has_await));
+}

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

@@ -52,7 +52,6 @@ export function Fragment(node, context) {
 			(trimmed[0].type === 'IfBlock' &&
 				trimmed[0].elseif &&
 				/** @type {AST.IfBlock} */ (parent).metadata.flattened?.includes(trimmed[0])));
-	const template_name = context.state.scope.root.unique('root'); // TODO infer name from parent
 
 	/** @type {Statement[]} */
 	const body = [];
@@ -96,8 +95,7 @@ export function Fragment(node, context) {
 
 		let flags = state.template.needs_import_node ? TEMPLATE_USE_IMPORT_NODE : undefined;
 
-		const template = transform_template(state, namespace, flags);
-		state.hoisted.push(b.var(template_name, template));
+		const template_name = transform_template(state, 'root', flags);
 
 		state.init.unshift(b.var(id, b.call(template_name)));
 		close = b.stmt(b.call('$.append', b.id('$$anchor'), id));
@@ -147,8 +145,7 @@ export function Fragment(node, context) {
 				// special case — we can use `$.comment` instead of creating a unique template
 				state.init.unshift(b.var(id, b.call('$.comment')));
 			} else {
-				const template = transform_template(state, namespace, flags);
-				state.hoisted.push(b.var(template_name, template));
+				const template_name = transform_template(state, 'root', flags);
 
 				state.init.unshift(b.var(id, b.call(template_name)));
 			}

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

@@ -18,7 +18,7 @@ import {
 	is_customizable_select_element
 } from '../../../nodes.js';
 import { clean_nodes, determine_namespace_for_children } from '../../utils.js';
-import { build_getter } from '../utils.js';
+import { build_getter, get_transform } from '../utils.js';
 import {
 	get_attribute_name,
 	build_attribute_value,
@@ -300,11 +300,14 @@ export function RegularElement(node, context) {
 		}
 	}
 
+	const scope = /** @type {Scope} */ (context.state.scopes.get(node.fragment));
+
 	/** @type {ComponentClientTransformState} */
 	const state = {
 		...context.state,
 		metadata,
-		scope: /** @type {Scope} */ (context.state.scopes.get(node.fragment)),
+		scope,
+		transform: get_transform(scope, context.state),
 		preserve_whitespace: context.state.preserve_whitespace || name === 'pre' || name === 'textarea'
 	};
 
@@ -318,8 +321,19 @@ export function RegularElement(node, context) {
 		state.options.preserveComments
 	);
 
+	const has_declarations = !node.fragment.metadata.transparent;
+
 	/** @type {typeof state} */
-	const child_state = { ...state, init: [], update: [], after_update: [], snippets: [] };
+	const child_state = {
+		...state,
+		init: [],
+		update: [],
+		after_update: [],
+		snippets: [],
+		consts: has_declarations ? [] : state.consts,
+		async_consts: has_declarations ? undefined : state.async_consts,
+		memoizer: has_declarations ? new Memoizer() : state.memoizer
+	};
 
 	for (const node of hoisted) {
 		context.visit(node, child_state);
@@ -360,7 +374,6 @@ export function RegularElement(node, context) {
 		context.state.template.push_comment();
 
 		// Create a separate template for the rich content
-		const template_name = context.state.scope.root.unique(`${name}_content`);
 		const fragment_id = b.id(context.state.scope.generate('fragment'));
 		const anchor_id = b.id(context.state.scope.generate('anchor'));
 
@@ -384,9 +397,8 @@ export function RegularElement(node, context) {
 			}
 		);
 
-		// 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));
+		// Transform the template to $.from_html(...) and hoist it (deduplicating identical templates)
+		const template_name = transform_template(select_state, `${name}_content`, TEMPLATE_FRAGMENT);
 
 		// Build the rich content function body
 		// The anchor is the child of the element (a hydration marker during hydration)
@@ -427,11 +439,21 @@ export function RegularElement(node, context) {
 		}
 	}
 
-	if (node.fragment.nodes.some((node) => node.type === 'SnippetBlock')) {
+	if (node.fragment.nodes.some((node) => node.type === 'SnippetBlock') || has_declarations) {
+		if (child_state.async_consts && child_state.async_consts.thunks.length > 0) {
+			child_state.consts.push(
+				b.var(
+					child_state.async_consts.id,
+					b.call('$.run', b.array(child_state.async_consts.thunks))
+				)
+			);
+		}
+
 		// Wrap children in `{...}` to avoid declaration conflicts
 		context.state.init.push(
 			b.block([
 				...child_state.snippets,
+				...child_state.consts,
 				...child_state.init,
 				...element_state.init,
 				child_state.update.length > 0 ? build_render_statement(child_state) : b.empty,

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

@@ -40,6 +40,7 @@ export function SvelteBoundary(node, context) {
 	const hoisted = [];
 
 	let has_const = false;
+	let has_declaration = false;
 
 	// const tags need to live inside the boundary, but might also be referenced in hoisted snippets.
 	// to resolve this we cheat: we duplicate const tags inside snippets
@@ -55,6 +56,10 @@ export function SvelteBoundary(node, context) {
 				});
 			}
 		}
+
+		if (child.type === 'DeclarationTag') {
+			has_declaration = true;
+		}
 	}
 
 	for (const child of node.fragment.nodes) {
@@ -68,10 +73,10 @@ export function SvelteBoundary(node, context) {
 		if (child.type === 'SnippetBlock') {
 			if (
 				context.state.options.experimental.async &&
-				has_const &&
+				(has_const || has_declaration) &&
 				!['failed', 'pending'].includes(child.expression.name)
 			) {
-				// we can't hoist snippets as they may reference const tags, so we just keep them in the fragment
+				// we can't hoist snippets as they may reference const/declaration tags, so we just keep them in the fragment
 				nodes.push(child);
 			} else {
 				/** @type {Statement[]} */

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

@@ -49,8 +49,13 @@ export function VariableDeclaration(node, context) {
 				}
 
 				if (declarator.id.type === 'Identifier') {
+					const exclude_id = context.state.scope.root.unique('rest_excludes');
+					context.state.hoisted.push(
+						b.var(exclude_id, b.new('Set', b.array(seen.map((name) => b.literal(name)))))
+					);
+
 					/** @type {Expression[]} */
-					const args = [b.id('$$props'), b.array(seen.map((name) => b.literal(name)))];
+					const args = [b.id('$$props'), exclude_id];
 
 					if (dev) {
 						// include rest name, so we can provide informative error messages
@@ -95,8 +100,13 @@ export function VariableDeclaration(node, context) {
 							}
 						} else {
 							// RestElement
+							const exclude_id = context.state.scope.root.unique('rest_excludes');
+							context.state.hoisted.push(
+								b.var(exclude_id, b.new('Set', b.array(seen.map((name) => b.literal(name)))))
+							);
+
 							/** @type {Expression[]} */
-							const args = [b.id('$$props'), b.array(seen.map((name) => b.literal(name)))];
+							const args = [b.id('$$props'), exclude_id];
 
 							if (dev) {
 								// include rest name, so we can provide informative error messages

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

@@ -15,6 +15,7 @@ import { CallExpression } from './visitors/CallExpression.js';
 import { ClassBody } from './visitors/ClassBody.js';
 import { Component } from './visitors/Component.js';
 import { ConstTag } from './visitors/ConstTag.js';
+import { DeclarationTag } from './visitors/DeclarationTag.js';
 import { DebugTag } from './visitors/DebugTag.js';
 import { EachBlock } from './visitors/EachBlock.js';
 import { ExpressionStatement } from './visitors/ExpressionStatement.js';
@@ -64,6 +65,7 @@ const template_visitors = {
 	AwaitBlock,
 	Component,
 	ConstTag,
+	DeclarationTag,
 	DebugTag,
 	EachBlock,
 	Fragment,

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

@@ -1,8 +1,9 @@
-/** @import { Expression, Pattern, Statement } from 'estree' */
+/** @import { Expression, Pattern } from 'estree' */
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types.js' */
 import * as b from '#compiler/builders';
 import { extract_identifiers } from '../../../../utils/ast.js';
+import { add_async_declaration } from './DeclarationTag.js';
 
 /**
  * @param {AST.ConstTag} node
@@ -12,31 +13,15 @@ export function ConstTag(node, context) {
 	const declaration = node.declaration.declarations[0];
 	const id = /** @type {Pattern} */ (context.visit(declaration.id));
 	const init = /** @type {Expression} */ (context.visit(declaration.init));
-	const blockers = [...node.metadata.expression.dependencies]
-		.map((dep) => dep.blocker)
-		.filter((b) => b !== null && b.object !== context.state.async_consts?.id);
 
 	if (node.metadata.promises_id) {
-		const run = (context.state.async_consts ??= {
-			id: node.metadata.promises_id,
-			thunks: []
-		});
-
-		const identifiers = extract_identifiers(declaration.id);
-
-		for (const identifier of identifiers) {
-			context.state.init.push(b.let(identifier.name));
-		}
-
-		if (blockers.length === 1) {
-			run.thunks.push(b.thunk(/** @type {Expression} */ (blockers[0])));
-		} else if (blockers.length > 0) {
-			run.thunks.push(b.thunk(b.call('Promise.all', b.array(blockers))));
-		}
-
-		// keep the number of thunks pushed in sync with ConstTag in analysis phase
-		const assignment = b.assignment('=', id, init);
-		run.thunks.push(b.thunk(assignment, node.metadata.expression.has_await));
+		add_async_declaration(
+			context,
+			node.metadata,
+			extract_identifiers(id),
+			[b.stmt(b.assignment('=', id, init))],
+			'let'
+		);
 	} else {
 		context.state.init.push(b.const(id, init));
 	}

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

@@ -0,0 +1,85 @@
+/** @import { Expression, Identifier, Pattern, Statement, ExpressionStatement, VariableDeclaration } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import { extract_identifiers, has_await_expression } from '../../../../utils/ast.js';
+import * as b from '#compiler/builders';
+
+/**
+ * @param {AST.DeclarationTag} node
+ * @param {ComponentContext} context
+ */
+export function DeclarationTag(node, context) {
+	const declaration = /** @type {Statement} */ (context.visit(node.declaration));
+
+	if (
+		node.metadata.promises_id &&
+		node.declaration.type === 'VariableDeclaration' &&
+		declaration.type === 'VariableDeclaration'
+	) {
+		const { ids, assignments } = build_async_declaration_parts(declaration);
+		add_async_declaration(context, node.metadata, ids, assignments, declaration.kind);
+	} else {
+		context.state.init.push(declaration);
+	}
+}
+
+/**
+ * @param {VariableDeclaration} declaration
+ */
+export function build_async_declaration_parts(declaration) {
+	const ids = new Map();
+	for (const declarator of declaration.declarations) {
+		for (const id of extract_identifiers(declarator.id)) {
+			ids.set(id.name, id);
+		}
+	}
+
+	const assignments = declaration.declarations
+		.filter((declarator) => declarator.init !== null)
+		.map((declarator) =>
+			b.stmt(
+				b.assignment(
+					'=',
+					/** @type {Pattern} */ (declarator.id),
+					/** @type {Expression} */ (declarator.init)
+				)
+			)
+		);
+
+	return { ids: [...ids.values()], assignments };
+}
+
+/**
+ * @param {ComponentContext} context
+ * @param {AST.ConstTag['metadata'] | AST.DeclarationTag['metadata']} metadata
+ * @param {Identifier[]} ids
+ * @param {ExpressionStatement[]} assignments
+ * @param {VariableDeclaration['kind']} [kind]
+ */
+export function add_async_declaration(context, metadata, ids, assignments, kind = 'let') {
+	const run = (context.state.async_consts ??= {
+		id: /** @type {Identifier} */ (metadata.promises_id),
+		thunks: []
+	});
+
+	for (const id of ids) {
+		context.state.init.push(kind === 'var' ? b.var(id.name) : b.let(id.name));
+	}
+
+	const blockers = [...metadata.expression.dependencies]
+		.map((dep) => dep.blocker)
+		.filter((b) => b !== null && b.object !== context.state.async_consts?.id);
+
+	if (blockers.length === 1) {
+		run.thunks.push(b.thunk(/** @type {Expression} */ (blockers[0])));
+	} else if (blockers.length > 0) {
+		run.thunks.push(b.thunk(b.call('Promise.all', b.array(blockers))));
+	}
+
+	// keep the number of thunks pushed in sync with analysis phase
+	const has_await =
+		metadata.expression.has_await ||
+		assignments.some((assignment) => has_await_expression(assignment));
+	const body = assignments.length === 1 ? assignments[0].expression : b.block(assignments);
+	run.thunks.push(b.thunk(body, has_await));
+}

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

@@ -17,17 +17,23 @@ import { is_customizable_select_element } from '../../../nodes.js';
 export function RegularElement(node, context) {
 	const name = context.state.namespace === 'html' ? node.name.toLowerCase() : node.name;
 	const namespace = determine_namespace_for_children(node, context.state.namespace);
+	const has_child_declarations = !node.fragment.metadata.transparent;
 
 	/** @type {ComponentServerTransformState} */
 	const state = {
 		...context.state,
 		namespace,
+		scope: /** @type {Scope} */ (context.state.scopes.get(node.fragment)),
 		preserve_whitespace:
 			context.state.preserve_whitespace || node.name === 'pre' || node.name === 'textarea',
 		init: [],
-		template: []
+		template: [],
+		async_consts: undefined
 	};
 
+	/** @type {ComponentServerTransformState} */
+	const attribute_state = { ...state, scope: context.state.scope };
+
 	const node_is_void = is_void(name);
 
 	const optimiser = new PromiseOptimiser();
@@ -50,7 +56,11 @@ export function RegularElement(node, context) {
 	if (!is_special) {
 		// only open the tag in the non-special path
 		state.template.push(b.literal(`<${name}`));
-		body = build_element_attributes(node, { ...context, state }, optimiser.transform);
+		body = build_element_attributes(
+			node,
+			{ ...context, state: attribute_state },
+			optimiser.transform
+		);
 		state.template.push(b.literal(node_is_void ? '/>' : '>')); // add `/>` for XHTML compliance
 	}
 
@@ -72,10 +82,7 @@ export function RegularElement(node, context) {
 		node.fragment.nodes,
 		context.path,
 		namespace,
-		{
-			...state,
-			scope: /** @type {Scope} */ (state.scopes.get(node.fragment))
-		},
+		state,
 		state.preserve_whitespace,
 		state.options.preserveComments
 	);
@@ -205,7 +212,17 @@ export function RegularElement(node, context) {
 		state.template.push(b.stmt(b.call('$.pop_element')));
 	}
 
-	if (optimiser.is_async()) {
+	if (has_child_declarations && state.async_consts && state.async_consts.thunks.length > 0) {
+		state.init.push(
+			b.var(state.async_consts.id, b.call('$$renderer.run', b.array(state.async_consts.thunks)))
+		);
+	}
+
+	if (has_child_declarations) {
+		context.state.template.push(
+			...optimiser.render([b.block([...state.init, ...build_template(state.template)])])
+		);
+	} else if (optimiser.is_async()) {
 		context.state.template.push(
 			...optimiser.render([...state.init, ...build_template(state.template)])
 		);

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

@@ -152,6 +152,7 @@ export function clean_nodes(
 
 		if (
 			node.type === 'ConstTag' ||
+			node.type === 'DeclarationTag' ||
 			node.type === 'DebugTag' ||
 			node.type === 'SvelteBody' ||
 			node.type === 'SvelteWindow' ||

package/src/compiler/phases/nodes.js

@@ -217,6 +217,7 @@ function* find_descendants(fragment) {
 			case 'SnippetBlock':
 			case 'DebugTag':
 			case 'ConstTag':
+			case 'DeclarationTag':
 			case 'Comment':
 			case 'ExpressionTag':
 				break;

package/src/compiler/print/index.js

@@ -603,6 +603,48 @@ const svelte_visitors = (comments) => ({
 		context.write('}');
 	},
 
+	DeclarationTag(node, context) {
+		context.write('{');
+
+		// This is duplicated from esrap's handling of VariableDeclaration,
+		// which we need to do in order to omit the trailing semicolon that esrap would add.
+		const open = context.new();
+		const join = context.new();
+		const child_context = context.new();
+
+		context.append(child_context);
+
+		child_context.write(`${node.declaration.kind} `);
+		child_context.append(open);
+
+		const declarations = node.declaration.declarations;
+		let first = true;
+
+		for (const d of declarations) {
+			if (!first) child_context.append(join);
+			first = false;
+
+			child_context.visit(d);
+		}
+
+		const length = child_context.measure() + 2 * (declarations.length - 1);
+
+		const multiline = child_context.multiline || (declarations.length > 1 && length > 50);
+
+		if (multiline) {
+			context.multiline = true;
+
+			if (declarations.length > 1) open.indent();
+			join.write(',');
+			join.newline();
+			if (declarations.length > 1) context.dedent();
+		} else {
+			join.write(', ');
+		}
+
+		context.write('}');
+	},
+
 	DebugTag(node, context) {
 		context.write('{@debug ');
 		let started = false;

package/src/compiler/utils/builders.js

@@ -686,7 +686,8 @@ export {
 	if_builder as if,
 	this_instance as this,
 	null_instance as null,
-	debugger_builder as debugger
+	debugger_builder as debugger,
+	new_builder as new
 };
 
 /**

package/src/internal/client/dom/blocks/boundary.js

@@ -396,7 +396,7 @@ export class Boundary {
 			if (this.#pending_effect) current_batch.skip_effect(this.#pending_effect);
 			if (this.#failed_effect) current_batch.skip_effect(this.#failed_effect);
 
-			current_batch.on_fork_commit(() => {
+			current_batch.oncommit(() => {
 				this.#handle_error(error);
 			});
 		} else {

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

@@ -233,6 +233,12 @@ export function should_defer_append() {
 }
 
 /**
+ * Branching here is intentional and load-bearing for perf. `createElement(tag)`
+ * hits a fast path in Blink that `createElementNS(NAMESPACE_HTML, tag)` doesn't,
+ * and passing an explicit `undefined` as the trailing options arg measurably
+ * slows both APIs. Funnelling every case through a single `createElementNS(ns,
+ * tag, options)` call would be smaller but slower on the HTML path.
+ *
  * @template {keyof HTMLElementTagNameMap | string} T
  * @param {T} tag
  * @param {string} [namespace]
@@ -240,9 +246,13 @@ export function should_defer_append() {
  * @returns {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element}
  */
 export function create_element(tag, namespace, is) {
-	let options = is ? { is } : undefined;
+	if (namespace == null || namespace === NAMESPACE_HTML) {
+		return /** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */ (
+			is ? document.createElement(tag, { is }) : document.createElement(tag)
+		);
+	}
 	return /** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */ (
-		document.createElementNS(namespace ?? NAMESPACE_HTML, tag, options)
+		is ? document.createElementNS(namespace, tag, { is }) : document.createElementNS(namespace, tag)
 	);
 }
 

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

@@ -140,12 +140,6 @@ export class Batch {
 	 */
 	#discard_callbacks = new Set();
 
-	/**
-	 * Callbacks that should run only when a fork is committed.
-	 * @type {Set<(batch: Batch) => void>}
-	 */
-	#fork_commit_callbacks = new Set();
-
 	/**
 	 * The number of async effects that are currently in flight
 	 */
@@ -634,7 +628,6 @@ export class Batch {
 	discard() {
 		for (const fn of this.#discard_callbacks) fn(this);
 		this.#discard_callbacks.clear();
-		this.#fork_commit_callbacks.clear();
 
 		this.#unlink();
 		this.#deferred?.resolve();
@@ -840,16 +833,6 @@ export class Batch {
 		this.#discard_callbacks.add(fn);
 	}
 
-	/** @param {(batch: Batch) => void} fn */
-	on_fork_commit(fn) {
-		this.#fork_commit_callbacks.add(fn);
-	}
-
-	run_fork_commit_callbacks() {
-		for (const fn of this.#fork_commit_callbacks) fn(this);
-		this.#fork_commit_callbacks.clear();
-	}
-
 	settled() {
 		return (this.#deferred ??= deferred()).promise;
 	}
@@ -1410,10 +1393,6 @@ export function fork(fn) {
 				source.wv = increment_write_version();
 			}
 
-			batch.activate();
-			batch.run_fork_commit_callbacks();
-			batch.deactivate();
-
 			// trigger any `$state.eager(...)` expressions with the new state.
 			// eager effects don't get scheduled like other effects, so we
 			// can't just encounter them during traversal, we need to