chore: improve event error handling (#11840)

I noticed that we spend a lot of time dealing with a recursive function when propagating events. Let's avoid that overhead and move back to a much faster while loop. We can also stack the errors and throw them at the end.

packages/svelte/src/internal/client/dom/elements/events.js

@@ -173,38 +173,60 @@ export function handle_event_propagation(handler_element, event) {
 		}
 	});
 
-	/** @param {Element} next_target */
+	try {
-	function next(next_target) {
+		/**
-		current_target = next_target;
+		 * @type {unknown}
-		/** @type {null | Element} */
+		 */
-		var parent_element = next_target.parentNode || /** @type {any} */ (next_target).host || null;
+		var throw_error;
-
+		/**
-		try {
+		 * @type {unknown[]}
-			// @ts-expect-error
+		 */
-			var delegated = next_target['__' + event_name];
+		var other_errors = [];
-
+		yield_event_updates(() => {
-			if (delegated !== undefined && !(/** @type {any} */ (next_target).disabled)) {
+			while (current_target !== null) {
-				if (is_array(delegated)) {
+				/** @type {null | Element} */
-					var [fn, ...data] = delegated;
+				var parent_element =
-					fn.apply(next_target, [event, ...data]);
+					current_target.parentNode || /** @type {any} */ (current_target).host || null;
-				} else {
+
-					delegated.call(next_target, event);
+				try {
+					// @ts-expect-error
+					var delegated = current_target['__' + event_name];
+
+					if (delegated !== undefined && !(/** @type {any} */ (current_target).disabled)) {
+						if (is_array(delegated)) {
+							var [fn, ...data] = delegated;
+							fn.apply(current_target, [event, ...data]);
+						} else {
+							delegated.call(current_target, event);
+						}
+					}
+				} catch (error) {
+					if (throw_error) {
+						other_errors.push(error);
+					} else {
+						throw_error = error;
+					}
+				}
+				if (
+					event.cancelBubble ||
+					parent_element === handler_element ||
+					parent_element === null ||
+					current_target === handler_element
+				) {
+					break;
 				}
+				current_target = parent_element;
 			}
-		} finally {
+		});
-			if (
+		if (throw_error) {
-				!event.cancelBubble &&
+			for (let error of other_errors) {
-				parent_element !== handler_element &&
+				// Throw the rest of the errors, one-by-one on a microtask
-				parent_element !== null &&
+				queueMicrotask(() => {
-				next_target !== handler_element
+					throw error;
-			) {
+				});
-				next(parent_element);
 			}
+			throw throw_error;
 		}
-	}
-
-	try {
-		yield_event_updates(() => next(/** @type {Element} */ (current_target)));
 	} finally {
 		// @ts-expect-error is used above
 		event.__root = handler_element;