From 894f15ab79508beec89e68ed79737f4eed1d4984 Mon Sep 17 00:00:00 2001
From: Steven Giesel <stgiesel35@gmail.com>
Date: Fri, 19 Sep 2025 23:30:10 +0200
Subject: [PATCH] feat: Use source generator for event dispatch extensions

---
 docs/samples/tests/razor/ClickMeTest.razor    |   2 +-
 docs/samples/tests/xunit/ClickMeTest.cs       |   2 +-
 .../interaction/trigger-event-handlers.md     |  27 +-
 docs/site/docs/migrations/1to2.md             |  18 +-
 .../EventDispatcherExtensionGenerator.cs      | 220 +++++
 .../ClipboardEventDispatchExtensions.cs       | 129 ---
 .../DetailsElementEventDispatchExtensions.cs  |  26 -
 .../DialogEventDispatchExtensions.cs          |  29 -
 .../DragEventDispatchExtensions.cs            | 352 --------
 .../FocusEventDispatchExtensions.cs           | 109 ---
 .../GeneralEventDispatchExtensions.cs         | 204 -----
 .../InputEventDispatchExtensions.cs           | 162 +---
 .../KeyboardEventDispatchExtensions.cs        | 169 ++--
 .../MediaEventDispatchExtensions.cs           | 264 ------
 .../MouseEventDispatchExtensions.cs           | 515 -----------
 .../PointerEventDispatchExtensions.cs         | 829 ------------------
 .../ProgressEventDispatchExtensions.cs        | 212 -----
 .../TouchEventDispatchExtensions.cs           | 261 ------
 .../ClipboardEventDispatchExtensionsTest.cs   |   2 +-
 .../DragEventDispatchExtensionsTest.cs        |   2 +-
 .../EventDispatchExtensionsTest.cs            |  14 +-
 .../FocusEventDispatchExtensionsTest.cs       |   2 +-
 .../GeneralEventDispatchExtensionsTest.cs     |   5 +-
 .../InputEventDispatchExtensionsTest.cs       |   7 +-
 .../KeyboardEventDispatchExtensionsTest.cs    |   1 -
 .../MediaEventDispatchExtensionsTest.cs       |  17 -
 .../MouseEventDispatchExtensionsTest.cs       |   1 -
 .../PointerEventDispatchExtensionsTest.cs     |   2 +-
 .../ProgressEventDispatchExtensionsTest.cs    |   2 +-
 .../TouchEventDispatchExtensionsTest.cs       |   2 +-
 .../WheelEventDispatchExtensionsTest.cs       |   2 +-
 31 files changed, 356 insertions(+), 3233 deletions(-)
 create mode 100644 src/bunit.generators.internal/Blazor/EventDispatcherExtensionGenerator.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/ClipboardEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/DetailsElementEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/DialogEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/DragEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/FocusEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/GeneralEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/MediaEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/MouseEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/PointerEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/ProgressEventDispatchExtensions.cs
 delete mode 100644 src/bunit/EventDispatchExtensions/TouchEventDispatchExtensions.cs
 delete mode 100644 tests/bunit.tests/EventDispatchExtensions/MediaEventDispatchExtensionsTest.cs

diff --git a/docs/samples/tests/razor/ClickMeTest.razor b/docs/samples/tests/razor/ClickMeTest.razor
index 0534006e6..bd851f10e 100644
--- a/docs/samples/tests/razor/ClickMeTest.razor
+++ b/docs/samples/tests/razor/ClickMeTest.razor
@@ -11,7 +11,7 @@
 
     // Act
     buttonElement.Click();
-    buttonElement.Click(detail: 3, ctrlKey: true);
+    buttonElement.Click(new MouseEventArgs { Detail = 3, CtrlKey = true });
     buttonElement.Click(new MouseEventArgs());
 
     // Assert
diff --git a/docs/samples/tests/xunit/ClickMeTest.cs b/docs/samples/tests/xunit/ClickMeTest.cs
index 23b7284f2..756d80eba 100644
--- a/docs/samples/tests/xunit/ClickMeTest.cs
+++ b/docs/samples/tests/xunit/ClickMeTest.cs
@@ -15,7 +15,7 @@ public void Test()
 
     // Act
     buttonElement.Click();
-    buttonElement.Click(detail: 3, ctrlKey: true);
+    buttonElement.Click(new MouseEventArgs { Detail = 3, CtrlKey = true });
     buttonElement.Click(new MouseEventArgs());
 
     // Assert
diff --git a/docs/site/docs/interaction/trigger-event-handlers.md b/docs/site/docs/interaction/trigger-event-handlers.md
index dec219d43..d8eb3ff8c 100644
--- a/docs/site/docs/interaction/trigger-event-handlers.md
+++ b/docs/site/docs/interaction/trigger-event-handlers.md
@@ -9,19 +9,7 @@ Blazor makes it possible to bind many event handlers to elements in a Blazor com
 
 bUnit comes with event dispatch helper methods that makes it possible to invoke event handlers for all event types supported by Blazor.
 
-**The built-in dispatch event helpers are:**
-
-- [Clipboard events](xref:Bunit.ClipboardEventDispatchExtensions)
-- [Drag events](xref:Bunit.DragEventDispatchExtensions)
-- [Focus events](xref:Bunit.FocusEventDispatchExtensions)
-- [General events](xref:Bunit.GeneralEventDispatchExtensions)
-- [Input events](xref:Bunit.InputEventDispatchExtensions)
-- [Keyboard events](xref:Bunit.KeyboardEventDispatchExtensions)
-- [Media events](xref:Bunit.MediaEventDispatchExtensions)
-- [Mouse events](xref:Bunit.MouseEventDispatchExtensions)
-- [Pointer events](xref:Bunit.PointerEventDispatchExtensions)
-- [Progress events](xref:Bunit.ProgressEventDispatchExtensions)
-- [Touch event](xref:Bunit.TouchEventDispatchExtensions)
+**The built-in dispatch event helpers are:** [here](xref:Bunit.EventHandlerDispatchExtensions).
 
 To use these, first find the element in the component under test where the event handler is bound. This is usually done with the [`Find(string cssSelector)`](xref:Bunit.RenderedComponentExtensions.Find``1(Bunit.IRenderedComponent{``0},System.String)) method. Next, invoke the event dispatch helper method of choice. 
 
@@ -50,9 +38,7 @@ To trigger the `@onclick` `ClickHandler` event handler method in the `<ClickMe>`
 This is what happens in the test:
 
 1. In the arrange step of the test, the `<ClickMe>` component is rendered and the `<button>` element is found using the [`Find(string cssSelector)`](xref:Bunit.RenderedComponentExtensions.Find``1(Bunit.IRenderedComponent{``0},System.String)) method.
-2. The act step of the test is the `<button>`'s click event handler. In this case, the `ClickHandler` event handler method is invoked in three different ways:
-   - The first and second invocations use the same [`Click`](xref:Bunit.MouseEventDispatchExtensions.Click(AngleSharp.Dom.IElement,System.Int64,System.Double,System.Double,System.Double,System.Double,System.Double,System.Double,System.Double,System.Double,System.Int64,System.Int64,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.String)) method. It has a number of optional arguments, some of which are passed in the second invocation. If any arguments are provided, they are added to an instance of the `MouseEventArgs` type, which is passed to the event handler if it has it as an argument. 
-   - The last invocation uses the [`Click`](xref:Bunit.MouseEventDispatchExtensions.Click(AngleSharp.Dom.IElement,Microsoft.AspNetCore.Components.Web.MouseEventArgs)) method. This takes an instance of the `MouseEventArgs` type, which is passed to the event handler if it has it as an argument.
+2. The act step of the test is the `<button>`'s click event handler. In this case, the `ClickHandler` event handler method is invoked by calling the [`Click`](xref:Bunit.EventHandlerDispatchExtensions.Click(AngleSharp.Dom.IElement,Microsoft.AspNetCore.Components.Web.MouseEventArgs)) extension method on the found `<button>` element. The method takes an optional `MouseEventArgs` argument, which, if not supplied, will be initialized with default values.
 
 All the event dispatch helper methods have the same two overloads: one that takes a number of optional arguments, and one that takes one of the `EventArgs` types provided by Blazor.
 
@@ -110,4 +96,13 @@ cut.Find("input").TriggerEvent("oncustompaste", new CustomPasteEventArgs
 
 // Assert that the custom event data was passed correctly
 cut.Find("p:last-child").MarkupMatches("<p>You pasted: FOO</p>");
+```
+
+## Using the `Async` version
+All event dispatch helper methods have an `Async` version that returns a `Task`. Important to note is that the `Async` version will await the event handler callback **but not** the rendercycle that may be triggered by the event handler.
+
+Example:
+
+```csharp
+await cut.Find("button").ClickAsync();
 ```
\ No newline at end of file
diff --git a/docs/site/docs/migrations/1to2.md b/docs/site/docs/migrations/1to2.md
index 0f1b19a97..16bb88e9d 100644
--- a/docs/site/docs/migrations/1to2.md
+++ b/docs/site/docs/migrations/1to2.md
@@ -29,7 +29,7 @@ The `Fake` prefix used for various fake implementations has been renamed to `Bun
  * `FakeAuthrozitationContext` to `BunitAuthorizationContext`
  * `FakeuthorizationPolicyProvider` to `BunitAuthorizationPolicyProvider`
   
-## Unified the `Render` methods
+## Unified the `Render` methods
 In v1 there were multiple `RenderXXX`methods (like `RenderComponent`, `Render` and `SetParametersAndRender`) that were used to render components and markup. In v2, these methods have been unified into a single `Render` method that can handle both components and markup) via the simple `Render` method:
 
 ```diff
@@ -64,4 +64,18 @@ public static class Extensions
         return loggerFactory.CreateLogger<T>();
     }
 }
-```
\ No newline at end of file
+```
+
+## Event dispatcher does not offer overload with all parameters
+
+In version 1.x, bUnit offered for example the following methods to invoke `onclick` on a component:
+
+```csharp
+cut.Find("button").Click();
+cut.Find("button").ClickAsync(new MouseEventArgs());
+cut.Find("button").Click(detail: 2, ctrlKey: true);
+```
+
+The last one was a method with all parameters of `MouseEventArgs` as optional parameters. This method has been removed in favor of using the `MouseEventArgs` directly.
+
+Also `ClickAsync` - to align with its synchronous counterpart - doesn't take `MouseEventArgs` as mandatory parameter anymore. If not set, a default instance will be created.
\ No newline at end of file
diff --git a/src/bunit.generators.internal/Blazor/EventDispatcherExtensionGenerator.cs b/src/bunit.generators.internal/Blazor/EventDispatcherExtensionGenerator.cs
new file mode 100644
index 000000000..bd3a36eff
--- /dev/null
+++ b/src/bunit.generators.internal/Blazor/EventDispatcherExtensionGenerator.cs
@@ -0,0 +1,220 @@
+using System;
+using System.Collections.Frozen;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Bunit.Blazor;
+
+[Generator]
+public class EventDispatcherExtensionGenerator : IIncrementalGenerator
+{
+	private static readonly Dictionary<string, string> EventNameOverrides = new()
+	{
+		["ondblclick"] = "DoubleClick",
+		["onmousewheel"] = "MouseWheel"
+	};
+
+	private static readonly FrozenSet<string> WordBoundaries =
+	[
+		"key", "mouse", "pointer", "touch", "drag", "drop", "focus", "blur",
+		"click", "dbl", "context", "menu", "copy", "cut", "paste",
+		"down", "up", "over", "out", "move", "enter", "leave", "start", "end",
+		"cancel", "change", "input", "wheel", "got", "lost", "capture",
+		"in", "before", "after", "load", "time", "abort", "progress", "error",
+		"activate", "deactivate", "ended", "full", "screen", "data", "metadata",
+		"lock", "ready", "state", "scroll", "toggle", "close", "seeking", "seeked",
+		"loaded", "duration", "emptied", "stalled", "suspend", "volume", "waiting",
+		"play", "playing", "pause", "press", "rate", "stop", "cue", "can", "through", "update"
+	];
+
+	public void Initialize(IncrementalGeneratorInitializationContext context)
+	{
+		var compilationProvider = context.CompilationProvider;
+
+		context.RegisterSourceOutput(compilationProvider, GenerateEventDispatchExtensions);
+	}
+
+	private static void GenerateEventDispatchExtensions(SourceProductionContext context, Compilation compilation)
+	{
+		var eventHandlerAttributeSymbol = compilation.GetTypeByMetadataName("Microsoft.AspNetCore.Components.EventHandlerAttribute");
+		if (eventHandlerAttributeSymbol is null)
+		{
+			return;
+		}
+
+		var eventHandlersSymbol = compilation.GetTypeByMetadataName("Microsoft.AspNetCore.Components.Web.EventHandlers");
+		if (eventHandlersSymbol is null)
+		{
+			return;
+		}
+
+		var eventMappings = new Dictionary<string, List<(string EventName, string MethodName)>>();
+
+		foreach (var attribute in eventHandlersSymbol.GetAttributes())
+		{
+			if (!SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, eventHandlerAttributeSymbol))
+				continue;
+
+			if (attribute.ConstructorArguments.Length < 2)
+				continue;
+
+			var eventName = attribute.ConstructorArguments[0].Value?.ToString();
+			var eventArgsType = attribute.ConstructorArguments[1].Value as INamedTypeSymbol;
+
+			if (string.IsNullOrEmpty(eventName) || eventArgsType == null)
+				continue;
+
+			var eventArgsTypeName = eventArgsType.Name;
+
+			var methodName = GenerateMethodNameFromEventName(eventName);
+
+			if (!eventMappings.ContainsKey(eventArgsTypeName))
+			{
+				eventMappings[eventArgsTypeName] = [];
+			}
+
+			eventMappings[eventArgsTypeName].Add((eventName, methodName));
+		}
+
+		if (eventMappings.Count == 0)
+		{
+			return;
+		}
+
+		var sourceBuilder = new StringBuilder(8000);
+		sourceBuilder.AppendLine("#nullable enable");
+		sourceBuilder.AppendLine("using AngleSharp.Dom;");
+		sourceBuilder.AppendLine("using Microsoft.AspNetCore.Components.Web;");
+		sourceBuilder.AppendLine("using System.Threading.Tasks;");
+		sourceBuilder.AppendLine();
+		sourceBuilder.AppendLine("namespace Bunit;");
+		sourceBuilder.AppendLine();
+
+		sourceBuilder.AppendLine("/// <summary>");
+		sourceBuilder.AppendLine("/// Event dispatch helper extension methods.");
+		sourceBuilder.AppendLine("/// </summary>");
+		sourceBuilder.AppendLine("public static partial class EventHandlerDispatchExtensions");
+		sourceBuilder.AppendLine("{");
+
+		foreach (var kvp in eventMappings.OrderBy(x => x.Key))
+		{
+			GenerateExtensionsForEventArgsType(sourceBuilder, kvp.Key, kvp.Value);
+		}
+
+		sourceBuilder.AppendLine("}");
+
+		context.AddSource("EventHandlerDispatchExtensions.g.cs", sourceBuilder.ToString());
+	}
+
+	private static string GenerateMethodNameFromEventName(string eventName)
+	{
+		if (EventNameOverrides.TryGetValue(eventName, out var overrideName))
+		{
+			return overrideName;
+		}
+
+		if (eventName.StartsWith("on"))
+		{
+			eventName = eventName[2..];
+		}
+
+		if (eventName.Length == 0)
+		{
+			return eventName;
+		}
+
+		var result = new StringBuilder();
+
+		var i = 0;
+		while (i < eventName.Length)
+		{
+			var foundWord = false;
+
+			foreach (var word in WordBoundaries.OrderByDescending(w => w.Length))
+			{
+				var isWithinStringBounds = i + word.Length <= eventName.Length;
+				var isWordMatch = isWithinStringBounds && eventName.AsSpan(i, word.Length).Equals(word.AsSpan(), StringComparison.OrdinalIgnoreCase);
+
+				if (isWordMatch)
+				{
+					result.Append(char.ToUpper(word[0]));
+					result.Append(word[1..].ToLower());
+					i += word.Length;
+					foundWord = true;
+					break;
+				}
+			}
+
+			if (!foundWord)
+			{
+				result.Append(i == 0 ? char.ToUpper(eventName[i]) : eventName[i]);
+				i++;
+			}
+		}
+
+		return result.ToString();
+	}
+
+	private static void GenerateExtensionsForEventArgsType(StringBuilder sourceBuilder, string eventArgsType, List<(string EventName, string MethodName)> events)
+	{
+		sourceBuilder.AppendLine($"\t// {eventArgsType} events");
+
+		foreach (var (eventName, methodName) in events)
+		{
+			var qualifiedEventArgsType = eventArgsType == "ErrorEventArgs"
+				? "Microsoft.AspNetCore.Components.Web.ErrorEventArgs"
+				: eventArgsType;
+
+			if (methodName == "Click")
+			{
+				GenerateAsyncEventMethodWithDefaultArgs(sourceBuilder, methodName, eventName, qualifiedEventArgsType, "new MouseEventArgs() { Detail = 1 }");
+			}
+			else if (methodName == "DoubleClick")
+			{
+				GenerateAsyncEventMethodWithDefaultArgs(sourceBuilder, methodName, eventName, qualifiedEventArgsType, "new MouseEventArgs() { Detail = 2 }");
+			}
+			else
+			{
+				GenerateAsyncEventMethodWithDefaultArgs(sourceBuilder, methodName, eventName, qualifiedEventArgsType, $"new {qualifiedEventArgsType}()");
+			}
+		}
+	}
+
+	private static void GenerateAsyncEventMethodWithDefaultArgs(StringBuilder sourceBuilder, string methodName, string eventName, string eventArgsType, string defaultArgs)
+	{
+		sourceBuilder.AppendLine("\t/// <summary>");
+		sourceBuilder.AppendLine($"\t/// Raises the <c>@{eventName}</c> event on <paramref name=\"element\"/>, passing the provided <paramref name=\"eventArgs\"/>");
+		sourceBuilder.AppendLine($"\t/// to the event handler. If <paramref name=\"eventArgs\"/> is null, a new instance of {eventArgsType} will be created.");
+		sourceBuilder.AppendLine("\t/// </summary>");
+		sourceBuilder.AppendLine("\t/// <param name=\"element\">The element to raise the event on.</param>");
+		sourceBuilder.AppendLine("\t/// <param name=\"eventArgs\">The event arguments to pass to the event handler.</param>");
+		sourceBuilder.AppendLine($"\tpublic static void {methodName}(this IElement element, {eventArgsType}? eventArgs = null) => _ = {methodName}Async(element, eventArgs);");
+		sourceBuilder.AppendLine();
+
+		sourceBuilder.AppendLine("\t/// <summary>");
+		sourceBuilder.AppendLine($"\t/// Raises the <c>@{eventName}</c> event on <paramref name=\"element\"/>, passing the provided <paramref name=\"eventArgs\"/>");
+		sourceBuilder.AppendLine($"\t/// to the event handler. If <paramref name=\"eventArgs\"/> is null, a new instance of {eventArgsType} will be created.");
+		sourceBuilder.AppendLine("\t/// </summary>");
+		sourceBuilder.AppendLine("\t/// <param name=\"element\">The element to raise the event on.</param>");
+		sourceBuilder.AppendLine("\t/// <param name=\"eventArgs\">The event arguments to pass to the event handler.</param>");
+		sourceBuilder.AppendLine("\t/// <returns>A task that completes when the event handler is done.</returns>");
+		sourceBuilder.AppendLine($"\tpublic static Task {methodName}Async(this IElement element, {eventArgsType}? eventArgs = null) => element.TriggerEventAsync(\"{eventName}\", eventArgs ?? {defaultArgs});");
+		sourceBuilder.AppendLine();
+
+		sourceBuilder.AppendLine("\t/// <summary>");
+		sourceBuilder.AppendLine($"\t/// Raises the <c>@{eventName}</c> event on the element returned by <paramref name=\"elementTask\"/>, passing the provided <paramref name=\"eventArgs\"/>");
+		sourceBuilder.AppendLine($"\t/// to the event handler. If <paramref name=\"eventArgs\"/> is null, a new instance of {eventArgsType} will be created.");
+		sourceBuilder.AppendLine("\t/// </summary>");
+		sourceBuilder.AppendLine("\t/// <param name=\"elementTask\">A task that returns the element to raise the element on.</param>");
+		sourceBuilder.AppendLine("\t/// <param name=\"eventArgs\">The event arguments to pass to the event handler.</param>");
+		sourceBuilder.AppendLine("\t/// <returns>A task that completes when the event handler is done.</returns>");
+		sourceBuilder.AppendLine($"\tpublic static async Task {methodName}Async(this Task<IElement> elementTask, {eventArgsType}? eventArgs = null)");
+		sourceBuilder.AppendLine("\t{");
+		sourceBuilder.AppendLine("\t\tvar element = await elementTask;");
+		sourceBuilder.AppendLine($"\t\tawait {methodName}Async(element, eventArgs);");
+		sourceBuilder.AppendLine("\t}");
+		sourceBuilder.AppendLine();
+	}
+}
diff --git a/src/bunit/EventDispatchExtensions/ClipboardEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/ClipboardEventDispatchExtensions.cs
deleted file mode 100644
index d88fa2d94..000000000
--- a/src/bunit/EventDispatchExtensions/ClipboardEventDispatchExtensions.cs
+++ /dev/null
@@ -1,129 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// Clipboard event dispatch helper extension methods.
-/// </summary>
-public static class ClipboardEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@onbeforecopy</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void BeforeCopy(this IElement element) => BeforeCopyAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onbeforecopy</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task BeforeCopyAsync(this IElement element) => element.TriggerEventAsync("onbeforecopy", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onbeforecut</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void BeforeCut(this IElement element) => BeforeCutAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onbeforecut</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task BeforeCutAsync(this IElement element) => element.TriggerEventAsync("onbeforecut", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onbeforepaste</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void BeforePaste(this IElement element) => BeforePasteAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onbeforepaste</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task BeforePasteAsync(this IElement element) => element.TriggerEventAsync("onbeforepaste", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@oncopy</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ClipboardEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="type">The type of the event.</param>
-	public static void Copy(this IElement element, string? type = default) => _ = CopyAsync(element, new ClipboardEventArgs { Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@oncopy</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Copy(this IElement element, ClipboardEventArgs eventArgs) => _ = CopyAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@oncopy</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task CopyAsync(this IElement element, ClipboardEventArgs eventArgs) => element.TriggerEventAsync("oncopy", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@oncut</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ClipboardEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="type">The type of the event.</param>
-	public static void Cut(this IElement element, string type = default!) => _ = CutAsync(element, new ClipboardEventArgs { Type = type });
-
-	/// <summary>
-	/// Raises the <c>@oncut</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Cut(this IElement element, ClipboardEventArgs eventArgs) => _ = CutAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@oncut</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task CutAsync(this IElement element, ClipboardEventArgs eventArgs) => element.TriggerEventAsync("oncut", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpaste</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ClipboardEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="type">The type of the event.</param>
-	public static void Paste(this IElement element, string type = default!) => _ = PasteAsync(element, new ClipboardEventArgs { Type = type });
-
-	/// <summary>
-	/// Raises the <c>@onpaste</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Paste(this IElement element, ClipboardEventArgs eventArgs) => _ = PasteAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpaste</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PasteAsync(this IElement element, ClipboardEventArgs eventArgs) => element.TriggerEventAsync("onpaste", eventArgs);
-}
diff --git a/src/bunit/EventDispatchExtensions/DetailsElementEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/DetailsElementEventDispatchExtensions.cs
deleted file mode 100644
index 37ffa5acf..000000000
--- a/src/bunit/EventDispatchExtensions/DetailsElementEventDispatchExtensions.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// General event dispatch helper extension methods.
-/// </summary>
-public static class DetailsElementEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@ontoggle</c> event on <paramref name="element"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Toggle(this IElement element)
-		=> _ = ToggleAsync(element, EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@ontoggle</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ToggleAsync(this IElement element, EventArgs eventArgs) => element.TriggerEventAsync("ontoggle", eventArgs);
-}
diff --git a/src/bunit/EventDispatchExtensions/DialogEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/DialogEventDispatchExtensions.cs
deleted file mode 100644
index 8fa2b9706..000000000
--- a/src/bunit/EventDispatchExtensions/DialogEventDispatchExtensions.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// Dialog helper events.
-/// </summary>
-public static class DialogEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@oncancel</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>).
-	/// </summary>
-	public static void Cancel(this IElement element) => _ = CancelAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@oncancel</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>).
-	/// </summary>
-	public static Task CancelAsync(this IElement element) => element.TriggerEventAsync("oncancel", EventArgs.Empty);
-
-	/// <summary>
-	///	Raises the <c>@onclose</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>.
-	///	</summary>
-	public static void Close(this IElement element) => _ = CloseAsync(element);
-
-	/// <summary>
-	///	Raises the <c>@onclose</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>.
-	///	</summary>
-	public static Task CloseAsync(this IElement element) => element.TriggerEventAsync("onclose", EventArgs.Empty);
-}
diff --git a/src/bunit/EventDispatchExtensions/DragEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/DragEventDispatchExtensions.cs
deleted file mode 100644
index 11d524cee..000000000
--- a/src/bunit/EventDispatchExtensions/DragEventDispatchExtensions.cs
+++ /dev/null
@@ -1,352 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// Drag event dispatch helper extension methods.
-/// </summary>
-public static class DragEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@ondrag</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="DragEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="dataTransfer">The data that underlies a drag-and-drop operation, known as the drag data store. See <see cref="DataTransfer"/>.</param>
-	public static void Drag(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string type = default!, DataTransfer dataTransfer = default!)
-		=> _ = DragAsync(element, new DragEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type, DataTransfer = dataTransfer });
-
-	/// <summary>
-	/// Raises the <c>@ondrag</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Drag(this IElement element, DragEventArgs eventArgs) => _ = DragAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondrag</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DragAsync(this IElement element, DragEventArgs eventArgs) => element.TriggerEventAsync("ondrag", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragend</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="DragEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="dataTransfer">The data that underlies a drag-and-drop operation, known as the drag data store. See <see cref="DataTransfer"/>.</param>
-	public static void DragEnd(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, DataTransfer? dataTransfer = default)
-		=> _ = DragEndAsync(element, new DragEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type!, DataTransfer = dataTransfer! });
-
-	/// <summary>
-	/// Raises the <c>@ondragend</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void DragEnd(this IElement element, DragEventArgs eventArgs) => _ = DragEndAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragend</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DragEndAsync(this IElement element, DragEventArgs eventArgs) => element.TriggerEventAsync("ondragend", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragenter</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="DragEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="dataTransfer">The data that underlies a drag-and-drop operation, known as the drag data store. See <see cref="DataTransfer"/>.</param>
-	public static void DragEnter(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, DataTransfer? dataTransfer = default)
-		=> _ = DragEnterAsync(element, new DragEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type!, DataTransfer = dataTransfer! });
-
-	/// <summary>
-	/// Raises the <c>@ondragenter</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void DragEnter(this IElement element, DragEventArgs eventArgs) => _ = DragEnterAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragenter</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DragEnterAsync(this IElement element, DragEventArgs eventArgs) => element.TriggerEventAsync("ondragenter", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragleave</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="DragEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="dataTransfer">The data that underlies a drag-and-drop operation, known as the drag data store. See <see cref="DataTransfer"/>.</param>
-	public static void DragLeave(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, DataTransfer? dataTransfer = default)
-		=> _ = DragLeaveAsync(element, new DragEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type!, DataTransfer = dataTransfer! });
-
-	/// <summary>
-	/// Raises the <c>@ondragleave</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void DragLeave(this IElement element, DragEventArgs eventArgs) => _ = DragLeaveAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragleave</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DragLeaveAsync(this IElement element, DragEventArgs eventArgs) => element.TriggerEventAsync("ondragleave", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragover</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="DragEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="dataTransfer">The data that underlies a drag-and-drop operation, known as the drag data store. See <see cref="DataTransfer"/>.</param>
-	public static void DragOver(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, DataTransfer? dataTransfer = default)
-		=> _ = DragOverAsync(element, new DragEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type!, DataTransfer = dataTransfer! });
-
-	/// <summary>
-	/// Raises the <c>@ondragover</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void DragOver(this IElement element, DragEventArgs eventArgs) => _ = DragOverAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragover</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DragOverAsync(this IElement element, DragEventArgs eventArgs) => element.TriggerEventAsync("ondragover", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragstart</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="DragEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="dataTransfer">The data that underlies a drag-and-drop operation, known as the drag data store. See <see cref="DataTransfer"/>.</param>
-	public static void DragStart(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, DataTransfer? dataTransfer = default)
-		=> _ = DragStartAsync(element, new DragEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type!, DataTransfer = dataTransfer! });
-
-	/// <summary>
-	/// Raises the <c>@ondragstart</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void DragStart(this IElement element, DragEventArgs eventArgs) => _ = DragStartAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondragstart</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DragStartAsync(this IElement element, DragEventArgs eventArgs) => element.TriggerEventAsync("ondragstart", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondrop</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="DragEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="dataTransfer">The data that underlies a drag-and-drop operation, known as the drag data store. See <see cref="DataTransfer"/>.</param>
-	public static void Drop(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, DataTransfer? dataTransfer = default)
-		=> _ = DropAsync(element, new DragEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type!, DataTransfer = dataTransfer! });
-
-	/// <summary>
-	/// Raises the <c>@ondrop</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Drop(this IElement element, DragEventArgs eventArgs) => _ = DropAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondrop</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DropAsync(this IElement element, DragEventArgs eventArgs) => element.TriggerEventAsync("ondrop", eventArgs);
-}
diff --git a/src/bunit/EventDispatchExtensions/FocusEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/FocusEventDispatchExtensions.cs
deleted file mode 100644
index 090a45419..000000000
--- a/src/bunit/EventDispatchExtensions/FocusEventDispatchExtensions.cs
+++ /dev/null
@@ -1,109 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// Focus event dispatch helper extension methods.
-/// </summary>
-public static class FocusEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@onfocus</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="FocusEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="type">The type of the event.</param>
-	public static void Focus(this IElement element, string? type = default) => _ = FocusAsync(element, new FocusEventArgs { Type = type });
-
-	/// <summary>
-	/// Raises the <c>@onfocus</c> event on <paramref name="element"/>, passing the provided
-	/// event arguments to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass the event handler.</param>
-	public static void Focus(this IElement element, FocusEventArgs eventArgs) => _ = FocusAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onfocus</c> event on <paramref name="element"/>, passing the provided
-	/// event arguments to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task FocusAsync(this IElement element, FocusEventArgs eventArgs) => element.TriggerEventAsync("onfocus", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onblur</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="FocusEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="type">The type of the event.</param>
-	public static void Blur(this IElement element, string? type = default) => _ = BlurAsync(element, new FocusEventArgs { Type = type });
-
-	/// <summary>
-	/// Raises the <c>@onblur</c> event on <paramref name="element"/>, passing the provided
-	/// event arguments to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass the event handler.</param>
-	public static void Blur(this IElement element, FocusEventArgs eventArgs) => _ = BlurAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onblur</c> event on <paramref name="element"/>, passing the provided
-	/// event arguments to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task BlurAsync(this IElement element, FocusEventArgs eventArgs) => element.TriggerEventAsync("onblur", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onfocusin</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="FocusEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="type">The type of the event.</param>
-	public static void FocusIn(this IElement element, string? type = default) => _ = FocusInAsync(element, new FocusEventArgs { Type = type });
-
-	/// <summary>
-	/// Raises the <c>@onfocusin</c> event on <paramref name="element"/>, passing the provided
-	/// event arguments to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass the event handler.</param>
-	public static void FocusIn(this IElement element, FocusEventArgs eventArgs) => _ = FocusInAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onfocusin</c> event on <paramref name="element"/>, passing the provided
-	/// event arguments to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task FocusInAsync(this IElement element, FocusEventArgs eventArgs) => element.TriggerEventAsync("onfocusin", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onfocusout</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="FocusEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="type">The type of the event.</param>
-	public static void FocusOut(this IElement element, string? type = default) => _ = FocusOutAsync(element, new FocusEventArgs { Type = type });
-
-	/// <summary>
-	/// Raises the <c>@onfocusout</c> event on <paramref name="element"/>, passing the provided
-	/// event arguments to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass the event handler.</param>
-	public static void FocusOut(this IElement element, FocusEventArgs eventArgs) => _ = FocusOutAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onfocusout</c> event on <paramref name="element"/>, passing the provided
-	/// event arguments to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task FocusOutAsync(this IElement element, FocusEventArgs eventArgs) => element.TriggerEventAsync("onfocusout", eventArgs);
-}
diff --git a/src/bunit/EventDispatchExtensions/GeneralEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/GeneralEventDispatchExtensions.cs
deleted file mode 100644
index f2b0c7c45..000000000
--- a/src/bunit/EventDispatchExtensions/GeneralEventDispatchExtensions.cs
+++ /dev/null
@@ -1,204 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// General event dispatch helper extension methods.
-/// </summary>
-public static class GeneralEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@onactivate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Activate(this IElement element) => ActivateAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onactivate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ActivateAsync(this IElement element) => element.TriggerEventAsync("onactivate", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onbeforeactivate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void BeforeActivate(this IElement element) => BeforeActivateAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onbeforeactivate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task BeforeActivateAsync(this IElement element) => element.TriggerEventAsync("onbeforeactivate", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onbeforedeactivate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void BeforeDeactivate(this IElement element) => BeforeDeactivateAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onbeforedeactivate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task BeforeDeactivateAsync(this IElement element) => element.TriggerEventAsync("onbeforedeactivate", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@ondeactivate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Deactivate(this IElement element) => DeactivateAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@ondeactivate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DeactivateAsync(this IElement element) => element.TriggerEventAsync("ondeactivate", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onended</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Ended(this IElement element) => EndedAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onended</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task EndedAsync(this IElement element) => element.TriggerEventAsync("onended", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onfullscreenchange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void FullscreenChange(this IElement element) => FullscreenChangeAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onfullscreenchange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task FullscreenChangeAsync(this IElement element) => element.TriggerEventAsync("onfullscreenchange", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onfullscreenerror</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void FullscreenError(this IElement element) => FullscreenErrorAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onfullscreenerror</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task FullscreenErrorAsync(this IElement element) => element.TriggerEventAsync("onfullscreenerror", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onloadeddata</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void LoadedData(this IElement element) => LoadedDataAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onloadeddata</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task LoadedDataAsync(this IElement element) => element.TriggerEventAsync("onloadeddata", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onloadedmetadata</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void LoadedMetadata(this IElement element) => LoadedMetadataAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onloadedmetadata</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task LoadedMetadataAsync(this IElement element) => element.TriggerEventAsync("onloadedmetadata", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onpointerlockchange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void PointerlockChange(this IElement element) => PointerlockChangeAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onpointerlockchange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerlockChangeAsync(this IElement element) => element.TriggerEventAsync("onpointerlockchange", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onpointerlockerror</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void PointerlockError(this IElement element) => PointerlockErrorAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onpointerlockerror</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerlockErrorAsync(this IElement element) => element.TriggerEventAsync("onpointerlockerror", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onreadystatechange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void ReadystateChange(this IElement element) => ReadystateChangeAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onreadystatechange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ReadystateChangeAsync(this IElement element) => element.TriggerEventAsync("onreadystatechange", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onscroll</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Scroll(this IElement element) => ScrollAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onscroll</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ScrollAsync(this IElement element) => element.TriggerEventAsync("onscroll", EventArgs.Empty);
-}
diff --git a/src/bunit/EventDispatchExtensions/InputEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/InputEventDispatchExtensions.cs
index be6f0871f..fe5d517df 100644
--- a/src/bunit/EventDispatchExtensions/InputEventDispatchExtensions.cs
+++ b/src/bunit/EventDispatchExtensions/InputEventDispatchExtensions.cs
@@ -6,7 +6,7 @@ namespace Bunit;
 /// <summary>
 /// Input event dispatch helper extension methods.
 /// </summary>
-public static class InputEventDispatchExtensions
+public static partial class EventHandlerDispatchExtensions
 {
 	/// <summary>
 	/// Raises the <c>@onchange</c> event on <paramref name="element"/>,  passing the provided
@@ -18,22 +18,16 @@ public static void Change<T>(this IElement element, T value)
 		=> _ = ChangeAsync(element, CreateFrom(value));
 
 	/// <summary>
-	/// Raises the <c>@onchange</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Change(this IElement element, ChangeEventArgs eventArgs)
-		=> _ = ChangeAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onchange</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
+	/// Raises the <c>@onchange</c> event on the element returned by <paramref name="elementTask"/>,  passing the provided
+	/// properties to the event handler via a <see cref="ChangeEventArgs"/> object.
 	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ChangeAsync(this IElement element, ChangeEventArgs eventArgs) => element.TriggerEventAsync("onchange", eventArgs);
+	/// <param name="elementTask">A task that returns the element to raise the event on.</param>
+	/// <param name="value">The new value.</param>
+	public static async Task ChangeAsync<T>(this Task<IElement> elementTask, T value)
+	{
+		var element = await elementTask;
+		await ChangeAsync(element, CreateFrom(value));
+	}
 
 	/// <summary>
 	/// Raises the <c>@oninput</c> event on <paramref name="element"/>,  passing the provided
@@ -45,141 +39,25 @@ public static void Input<T>(this IElement element, T value)
 		=> _ = InputAsync(element, CreateFrom(value));
 
 	/// <summary>
-	/// Raises the <c>@oninput</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Input(this IElement element, ChangeEventArgs eventArgs)
-		=> _ = InputAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@oninput</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Input(this IElement element) => _ = InputAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@oninput</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task InputAsync(this IElement element) => element.TriggerEventAsync("oninput", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@oninput</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task InputAsync(this IElement element, ChangeEventArgs eventArgs) => element.TriggerEventAsync("oninput", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@oninvalid</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Invalid(this IElement element) => _ = InvalidAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@oninvalid</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task InvalidAsync(this IElement element) => element.TriggerEventAsync("oninvalid", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onreset</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Reset(this IElement element) => _ = ResetAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onreset</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ResetAsync(this IElement element) => element.TriggerEventAsync("onreset", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onselect</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Select(this IElement element) => _ = SelectAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onselect</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task SelectAsync(this IElement element) => element.TriggerEventAsync("onselect", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onselectstart</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void SelectStart(this IElement element) => _ = SelectStartAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onselectstart</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task SelectStartAsync(this IElement element) => element.TriggerEventAsync("onselectstart", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onselectionchange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void SelectionChange(this IElement element) => _ = SelectionChangeAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onselectionchange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task SelectionChangeAsync(this IElement element) => element.TriggerEventAsync("onselectionchange", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onsubmit</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Submit(this IElement element) => _ = SubmitAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onsubmit</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
+	/// Raises the <c>@oninput</c> event on the element returned by <paramref name="elementTask"/>,  passing the provided
+	/// properties to the event handler via a <see cref="ChangeEventArgs"/> object.
 	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task SubmitAsync(this IElement element) => element.TriggerEventAsync("onsubmit", EventArgs.Empty);
-
-	private static ChangeEventArgs CreateFrom<T>(T value)
+	/// <param name="elementTask">A task that returns the element to raise the event on.</param>
+	/// <param name="value">The new value.</param>
+	public static async Task InputAsync<T>(this Task<IElement> elementTask, T value)
 	{
-		var result = new ChangeEventArgs();
-		result.Value = FormatValue(value);
-		return result;
+		var element = await elementTask;
+		await InputAsync(element, CreateFrom(value));
 	}
 
+	private static ChangeEventArgs CreateFrom<T>(T value) => new() { Value = FormatValue(value) };
+
 	private static object? FormatValue<T>(T value)
 		=> value switch
 		{
 			null => null,
 			bool _ => value,
-			String _ => value,
+			string _ => value,
 			ICollection values => FormatValues(values),
 			IEnumerable values => FormatValues(values),
 			_ => BindConverter.FormatValue(value)
diff --git a/src/bunit/EventDispatchExtensions/KeyboardEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/KeyboardEventDispatchExtensions.cs
index d3879b0af..d505ddf3d 100644
--- a/src/bunit/EventDispatchExtensions/KeyboardEventDispatchExtensions.cs
+++ b/src/bunit/EventDispatchExtensions/KeyboardEventDispatchExtensions.cs
@@ -5,42 +5,8 @@ namespace Bunit;
 /// <summary>
 /// Keyboard event dispatch helper extension methods.
 /// </summary>
-public static class KeyboardEventDispatchExtensions
+public static partial class EventHandlerDispatchExtensions
 {
-	/// <summary>
-	/// Raises the <c>@onkeydown</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="KeyboardEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="key">
-	///     The key value of the key represented by the event. If the value has a printed
-	///     representation, this attribute's value is the same as the char attribute. Otherwise,
-	///     it's one of the key value strings specified in 'Key values'. If the key can't
-	///     be identified, this is the string "Unidentified".
-	/// </param>
-	/// <param name="code">
-	///     Holds a string that identifies the physical key being pressed. The value is not
-	///     affected by the current keyboard layout or modifier state, so a particular key
-	///     will always return the same value.
-	/// </param>
-	/// <param name="location">The location of the key on the device.</param>
-	/// <param name="repeat">true if a key has been depressed long enough to trigger key repetition, otherwise false.</param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">The type of the event.</param>
-	public static void KeyDown(this IElement element, string key, string? code = default, float location = default, bool repeat = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = KeyDownAsync(element, new KeyboardEventArgs { Key = key, Code = code!, Location = location, Repeat = repeat, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onkeydown</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void KeyDown(this IElement element, KeyboardEventArgs eventArgs) => _ = KeyDownAsync(element, eventArgs);
-
 	/// <summary>
 	/// Raises the <c>@onkeydown</c> event on <paramref name="element"/>, passing the provided <paramref name="key"/>
 	/// to the event handler.
@@ -58,47 +24,34 @@ public static void KeyDown(this IElement element, Key key, bool repeat = default
 	}
 
 	/// <summary>
-	/// Raises the <c>@onkeydown</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
+	/// Raises the <c>@onkeydown</c> event on <paramref name="element"/>, passing the provided <paramref name="key"/>
 	/// to the event handler.
 	/// </summary>
 	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task KeyDownAsync(this IElement element, KeyboardEventArgs eventArgs) => element.TriggerEventAsync("onkeydown", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onkeyup</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="KeyboardEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="key">
-	///     The key value of the key represented by the event. If the value has a printed
-	///     representation, this attribute's value is the same as the char attribute. Otherwise,
-	///     it's one of the key value strings specified in 'Key values'. If the key can't
-	///     be identified, this is the string "Unidentified".
-	/// </param>
-	/// <param name="code">
-	///     Holds a string that identifies the physical key being pressed. The value is not
-	///     affected by the current keyboard layout or modifier state, so a particular key
-	///     will always return the same value.
-	/// </param>
-	/// <param name="location">The location of the key on the device.</param>
-	/// <param name="repeat">true if a key has been depressed long enough to trigger key repetition, otherwise false.</param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
+	/// <param name="key">The keyboard key to pass to the event handler.</param>
+	/// <param name="repeat"><c>true</c> if a key has been depressed long enough to trigger key repetition, otherwise <c>false</c>.</param>
 	/// <param name="type">The type of the event.</param>
-	public static void KeyUp(this IElement element, string key, string? code = default, float location = default, bool repeat = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = KeyUpAsync(element, new KeyboardEventArgs { Key = key, Code = code!, Location = location, Repeat = repeat, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
+	public static Task KeyDownAsync(this IElement element, Key key, bool repeat = default, string? type = default)
+	{
+		KeyboardEventArgs eventArgs = key;
+		eventArgs.Repeat = repeat;
+		eventArgs.Type = type!; // Type property missing annotation
+		return KeyDownAsync(element, eventArgs);
+	}
 
 	/// <summary>
-	/// Raises the <c>@onkeyup</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
+	/// Raises the <c>@onkeydown</c> event on <paramref name="elementTask"/>, passing the provided <paramref name="key"/>
 	/// to the event handler.
 	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void KeyUp(this IElement element, KeyboardEventArgs eventArgs) => _ = KeyUpAsync(element, eventArgs);
+	/// <param name="elementTask">The element to raise the event on.</param>
+	/// <param name="key">The keyboard key to pass to the event handler.</param>
+	/// <param name="repeat"><c>true</c> if a key has been depressed long enough to trigger key repetition, otherwise <c>false</c>.</param>
+	/// <param name="type">The type of the event.</param>
+	public static async Task KeyDownAsync(this Task<IElement> elementTask, Key key, bool repeat = default, string? type = default)
+	{
+		var element = await elementTask;
+		await KeyDownAsync(element, key, repeat, type);
+	}
 
 	/// <summary>
 	/// Raises the <c>@onkeyup</c> event on <paramref name="element"/>, passing the provided <paramref name="key"/>
@@ -117,47 +70,50 @@ public static void KeyUp(this IElement element, Key key, bool repeat = default,
 	}
 
 	/// <summary>
-	/// Raises the <c>@onkeyup</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
+	/// Raises the <c>@onkeyup</c> event on <paramref name="element"/>, passing the provided <paramref name="key"/>
 	/// to the event handler.
 	/// </summary>
 	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task KeyUpAsync(this IElement element, KeyboardEventArgs eventArgs) => element.TriggerEventAsync("onkeyup", eventArgs);
+	/// <param name="key">The keyboard key to pass to the event handler.</param>
+	/// <param name="repeat"><c>true</c> if a key has been depressed long enough to trigger key repetition, otherwise <c>false</c>.</param>
+	/// <param name="type">The type of the event.</param>
+	public static Task KeyUpAsync(this IElement element, Key key, bool repeat = default, string? type = default)
+	{
+		KeyboardEventArgs eventArgs = key;
+		eventArgs.Repeat = repeat;
+		eventArgs.Type = type!; // Type property missing annotation
+		return KeyUpAsync(element, eventArgs);
+	}
 
 	/// <summary>
-	/// Raises the <c>@onkeypress</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="KeyboardEventArgs"/> object.
+	/// Raises the <c>@onkeyup</c> event on <paramref name="elementTask"/>, passing the provided <paramref name="key"/>
+	/// to the event handler.
 	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="key">
-	///     The key value of the key represented by the event. If the value has a printed
-	///     representation, this attribute's value is the same as the char attribute. Otherwise,
-	///     it's one of the key value strings specified in 'Key values'. If the key can't
-	///     be identified, this is the string "Unidentified".
-	/// </param>
-	/// <param name="code">
-	///     Holds a string that identifies the physical key being pressed. The value is not
-	///     affected by the current keyboard layout or modifier state, so a particular key
-	///     will always return the same value.
-	/// </param>
-	/// <param name="location">The location of the key on the device.</param>
-	/// <param name="repeat">true if a key has been depressed long enough to trigger key repetition, otherwise false.</param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
+	/// <param name="elementTask">The element to raise the event on.</param>
+	/// <param name="key">The keyboard key to pass to the event handler.</param>
+	/// <param name="repeat"><c>true</c> if a key has been depressed long enough to trigger key repetition, otherwise <c>false</c>.</param>
 	/// <param name="type">The type of the event.</param>
-	public static void KeyPress(this IElement element, string key, string? code = default, float location = default, bool repeat = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = KeyPressAsync(element, new KeyboardEventArgs { Key = key, Code = code!, Location = location, Repeat = repeat, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
+	public static async Task KeyUpAsync(this Task<IElement> elementTask, Key key, bool repeat = default, string? type = default)
+	{
+		var element = await elementTask;
+		await KeyUpAsync(element, key, repeat, type);
+	}
 
 	/// <summary>
-	/// Raises the <c>@onkeypress</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
+	/// Raises the <c>@onkeypress</c> event on <paramref name="element"/>, passing the provided <paramref name="key"/>
 	/// to the event handler.
 	/// </summary>
 	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void KeyPress(this IElement element, KeyboardEventArgs eventArgs) => _ = KeyPressAsync(element, eventArgs);
+	/// <param name="key">The keyboard key to pass to the event handler.</param>
+	/// <param name="repeat"><c>true</c> if a key has been depressed long enough to trigger key repetition, otherwise <c>false</c>.</param>
+	/// <param name="type">The type of the event.</param>
+	public static void KeyPress(this IElement element, Key key, bool repeat = default, string? type = default)
+	{
+		KeyboardEventArgs eventArgs = key;
+		eventArgs.Repeat = repeat;
+		eventArgs.Type = type!; // Type property missing annotation
+		_ = KeyPressAsync(element, eventArgs);
+	}
 
 	/// <summary>
 	/// Raises the <c>@onkeypress</c> event on <paramref name="element"/>, passing the provided <paramref name="key"/>
@@ -167,20 +123,25 @@ public static void KeyPress(this IElement element, string key, string? code = de
 	/// <param name="key">The keyboard key to pass to the event handler.</param>
 	/// <param name="repeat"><c>true</c> if a key has been depressed long enough to trigger key repetition, otherwise <c>false</c>.</param>
 	/// <param name="type">The type of the event.</param>
-	public static void KeyPress(this IElement element, Key key, bool repeat = default, string? type = default)
+	public static Task KeyPressAsync(this IElement element, Key key, bool repeat = default, string? type = default)
 	{
 		KeyboardEventArgs eventArgs = key;
 		eventArgs.Repeat = repeat;
 		eventArgs.Type = type!; // Type property missing annotation
-		_ = KeyPressAsync(element, eventArgs);
+		return KeyPressAsync(element, eventArgs);
 	}
 
 	/// <summary>
-	/// Raises the <c>@onkeypress</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
+	/// Raises the <c>@onkeypress</c> event on <paramref name="elementTask"/>, passing the provided <paramref name="key"/>
 	/// to the event handler.
 	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task KeyPressAsync(this IElement element, KeyboardEventArgs eventArgs) => element.TriggerEventAsync("onkeypress", eventArgs);
+	/// <param name="elementTask">The element to raise the event on.</param>
+	/// <param name="key">The keyboard key to pass to the event handler.</param>
+	/// <param name="repeat"><c>true</c> if a key has been depressed long enough to trigger key repetition, otherwise <c>false</c>.</param>
+	/// <param name="type">The type of the event.</param>
+	public static async Task KeyPressAsync(this Task<IElement> elementTask, Key key, bool repeat = default, string? type = default)
+	{
+		var element = await elementTask;
+		await KeyPressAsync(element, key, repeat, type);
+	}
 }
diff --git a/src/bunit/EventDispatchExtensions/MediaEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/MediaEventDispatchExtensions.cs
deleted file mode 100644
index 12ca36b29..000000000
--- a/src/bunit/EventDispatchExtensions/MediaEventDispatchExtensions.cs
+++ /dev/null
@@ -1,264 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// Media event dispatch helper extension methods.
-/// </summary>
-public static class MediaEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@oncanplay</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void CanPlay(this IElement element) => CanPlayAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@oncanplay</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task CanPlayAsync(this IElement element) => element.TriggerEventAsync("oncanplay", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@oncanplaythrough</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void CanPlayThrough(this IElement element) => _ = CanPlayThroughAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@oncanplaythrough</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task CanPlayThroughAsync(this IElement element) => element.TriggerEventAsync("oncanplaythrough", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@oncuechange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void CueChange(this IElement element) => CueChangeAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@oncuechange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task CueChangeAsync(this IElement element) => element.TriggerEventAsync("oncuechange", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@ondurationchange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void DurationChange(this IElement element) => DurationChangeAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@ondurationchange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DurationChangeAsync(this IElement element) => element.TriggerEventAsync("ondurationchange", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onemptied</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Emptied(this IElement element) => EmptiedAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onemptied</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task EmptiedAsync(this IElement element) => element.TriggerEventAsync("onemptied", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onpause</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Pause(this IElement element) => PauseAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onpause</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PauseAsync(this IElement element) => element.TriggerEventAsync("onpause", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onplay</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Play(this IElement element) => PlayAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onplay</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PlayAsync(this IElement element) => element.TriggerEventAsync("onplay", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onplaying</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Playing(this IElement element) => PlayingAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onplaying</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PlayingAsync(this IElement element) => element.TriggerEventAsync("onplaying", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onratechange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void RateChange(this IElement element) => RateChangeAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onratechange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task RateChangeAsync(this IElement element) => element.TriggerEventAsync("onratechange", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onseeked</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Seeked(this IElement element) => SeekedAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onseeked</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task SeekedAsync(this IElement element) => element.TriggerEventAsync("onseeked", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onseeking</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Seeking(this IElement element) => SeekingAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onseeking</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task SeekingAsync(this IElement element) => element.TriggerEventAsync("onseeking", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onstalled</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Stalled(this IElement element) => StalledAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onstalled</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task StalledAsync(this IElement element) => element.TriggerEventAsync("onstalled", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onstop</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Stop(this IElement element) => StopAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onstop</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task StopAsync(this IElement element) => element.TriggerEventAsync("onstop", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onsuspend</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Suspend(this IElement element) => SuspendAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onsuspend</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task SuspendAsync(this IElement element) => element.TriggerEventAsync("onsuspend", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@ontimeupdate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void TimeUpdate(this IElement element) => TimeUpdateAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@ontimeupdate</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task TimeUpdateAsync(this IElement element) => element.TriggerEventAsync("ontimeupdate", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onvolumechange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void VolumeChange(this IElement element) => VolumeChangeAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onvolumechange</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task VolumeChangeAsync(this IElement element) => element.TriggerEventAsync("onvolumechange", EventArgs.Empty);
-
-	/// <summary>
-	/// Raises the <c>@onwaiting</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	public static void Waiting(this IElement element) => WaitingAsync(element);
-
-	/// <summary>
-	/// Raises the <c>@onwaiting</c> event on <paramref name="element"/>, passing an empty (<see cref="EventArgs.Empty"/>)
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task WaitingAsync(this IElement element) => element.TriggerEventAsync("onwaiting", EventArgs.Empty);
-}
diff --git a/src/bunit/EventDispatchExtensions/MouseEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/MouseEventDispatchExtensions.cs
deleted file mode 100644
index d67a0b866..000000000
--- a/src/bunit/EventDispatchExtensions/MouseEventDispatchExtensions.cs
+++ /dev/null
@@ -1,515 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// Mouse event dispatch helper extension methods.
-/// </summary>
-public static class MouseEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@onmouseover</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void MouseOver(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = MouseOverAsync(element, new MouseEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onmouseover</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void MouseOver(this IElement element, MouseEventArgs eventArgs)
-		=> _ = MouseOverAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmouseover</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task MouseOverAsync(this IElement element, MouseEventArgs eventArgs) => element.TriggerEventAsync("onmouseover", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmouseout</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void MouseOut(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = MouseOutAsync(element, new MouseEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onmouseout</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void MouseOut(this IElement element, MouseEventArgs eventArgs)
-		=> _ = MouseOutAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmouseout</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task MouseOutAsync(this IElement element, MouseEventArgs eventArgs) => element.TriggerEventAsync("onmouseout", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmousemove</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void MouseMove(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = MouseMoveAsync(element, new MouseEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onmousemove</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void MouseMove(this IElement element, MouseEventArgs eventArgs)
-		=> _ = MouseMoveAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmousemove</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task MouseMoveAsync(this IElement element, MouseEventArgs eventArgs) => element.TriggerEventAsync("onmousemove", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmousedown</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void MouseDown(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = MouseDownAsync(element, new MouseEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onmousedown</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void MouseDown(this IElement element, MouseEventArgs eventArgs)
-		=> _ = MouseDownAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmousedown</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task MouseDownAsync(this IElement element, MouseEventArgs eventArgs) => element.TriggerEventAsync("onmousedown", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmouseup</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void MouseUp(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = MouseUpAsync(element, new MouseEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onmouseup</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void MouseUp(this IElement element, MouseEventArgs eventArgs)
-		=> _ = MouseUpAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmouseup</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task MouseUpAsync(this IElement element, MouseEventArgs eventArgs) => element.TriggerEventAsync("onmouseup", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onclick</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="pageX">The X coordinate of the mouse pointer relative to the whole document.</param>
-	/// <param name="pageY">The Y coordinate of the mouse pointer relative to the whole document.</param>
-	/// <param name="offsetX">The X coordinate of the mouse pointer in relative (Target Element) coordinates.</param>
-	/// <param name="offsetY">The Y coordinate of the mouse pointer in relative (Target Element) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void Click(this IElement element, long detail = 1, double screenX = default, double screenY = default, double clientX = default, double clientY = default, double pageX = 0, double pageY = 0, double offsetX = 0, double offsetY = 0, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = ClickAsync(element, new MouseEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, PageX = pageX, PageY = pageY, OffsetX = offsetX, OffsetY = offsetY, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onclick</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Click(this IElement element, MouseEventArgs eventArgs)
-		=> _ = ClickAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onclick</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ClickAsync(this IElement element, MouseEventArgs eventArgs) => element.TriggerEventAsync("onclick", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondblclick</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="pageX">The X coordinate of the mouse pointer relative to the whole document.</param>
-	/// <param name="pageY">The Y coordinate of the mouse pointer relative to the whole document.</param>
-	/// <param name="offsetX">The X coordinate of the mouse pointer in relative (Target Element) coordinates.</param>
-	/// <param name="offsetY">The Y coordinate of the mouse pointer in relative (Target Element) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void DoubleClick(this IElement element, long detail = 2, double screenX = default, double screenY = default, double clientX = default, double clientY = default, double pageX = 0, double pageY = 0, double offsetX = 0, double offsetY = 0, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = DoubleClickAsync(element, new MouseEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, PageX = pageX, PageY = pageY, OffsetX = offsetX, OffsetY = offsetY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@ondblclick</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void DoubleClick(this IElement element, MouseEventArgs eventArgs)
-		=> _ = DoubleClickAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ondblclick</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task DoubleClickAsync(this IElement element, MouseEventArgs eventArgs) => element.TriggerEventAsync("ondblclick", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onwheel</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="deltaX">The horizontal scroll amount.</param>
-	/// <param name="deltaY">The vertical scroll amount.</param>
-	/// <param name="deltaZ">The scroll amount for the z-axis.</param>
-	/// <param name="deltaMode">The unit of the delta values scroll amount.</param>
-	public static void Wheel(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, double deltaX = default, double deltaY = default, double deltaZ = default, long deltaMode = default)
-		=> _ = WheelAsync(element, new WheelEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type!, DeltaX = deltaX, DeltaY = deltaY, DeltaZ = deltaZ, DeltaMode = deltaMode });
-
-	/// <summary>
-	/// Raises the <c>@onwheel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Wheel(this IElement element, WheelEventArgs eventArgs)
-		=> _ = WheelAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onwheel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task WheelAsync(this IElement element, WheelEventArgs eventArgs) => element.TriggerEventAsync("onwheel", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmousewheel</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="deltaX">The horizontal scroll amount.</param>
-	/// <param name="deltaY">The vertical scroll amount.</param>
-	/// <param name="deltaZ">The scroll amount for the z-axis.</param>
-	/// <param name="deltaMode">The unit of the delta values scroll amount.</param>
-	public static void MouseWheel(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, double deltaX = default, double deltaY = default, double deltaZ = default, long deltaMode = default)
-		=> MouseWheelAsync(element, new WheelEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type!, DeltaX = deltaX, DeltaY = deltaY, DeltaZ = deltaZ, DeltaMode = deltaMode });
-
-	/// <summary>
-	/// Raises the <c>@onmousewheel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void MouseWheel(this IElement element, WheelEventArgs eventArgs)
-		=> _ = MouseWheelAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onmousewheel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task MouseWheelAsync(this IElement element, WheelEventArgs eventArgs) => element.TriggerEventAsync("onmousewheel", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@oncontextmenu</c> event on <paramref name="element"/>,  passing the provided
-	/// properties to the event handler via a <see cref="MouseEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void ContextMenu(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = ContextMenuAsync(element, new MouseEventArgs { Detail = detail, ScreenX = screenX, ScreenY = screenY, ClientX = clientX, ClientY = clientY, Button = button, Buttons = buttons, CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@oncontextmenu</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void ContextMenu(this IElement element, MouseEventArgs eventArgs)
-		=> _ = ContextMenuAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@oncontextmenu</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ContextMenuAsync(this IElement element, MouseEventArgs eventArgs) => element.TriggerEventAsync("oncontextmenu", eventArgs);
-}
diff --git a/src/bunit/EventDispatchExtensions/PointerEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/PointerEventDispatchExtensions.cs
deleted file mode 100644
index 36ff05c25..000000000
--- a/src/bunit/EventDispatchExtensions/PointerEventDispatchExtensions.cs
+++ /dev/null
@@ -1,829 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// Pointer event dispatch helper extension methods.
-/// </summary>
-public static class PointerEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@ongotpointercapture</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void GotPointerCapture(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = GotPointerCaptureAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@ongotpointercapture</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void GotPointerCapture(this IElement element, PointerEventArgs eventArgs) => _ = GotPointerCaptureAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ongotpointercapture</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task GotPointerCaptureAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("ongotpointercapture", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onlostpointercapture</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void LostPointerCapture(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = LostPointerCaptureAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@onlostpointercapture</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void LostPointerCapture(this IElement element, PointerEventArgs eventArgs) => _ = LostPointerCaptureAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onlostpointercapture</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task LostPointerCaptureAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("onlostpointercapture", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerdown</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void PointerDown(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = PointerDownAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@onpointerdown</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void PointerDown(this IElement element, PointerEventArgs eventArgs) => _ = PointerDownAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerdown</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerDownAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("onpointerdown", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointercancel</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void PointerCancel(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = PointerCancelAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@onpointercancel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void PointerCancel(this IElement element, PointerEventArgs eventArgs) => _ = PointerCancelAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointercancel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerCancelAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("onpointercancel", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerenter</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void PointerEnter(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = PointerEnterAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@onpointerenter</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void PointerEnter(this IElement element, PointerEventArgs eventArgs) => _ = PointerEnterAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerenter</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerEnterAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("onpointerenter", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerleave</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void PointerLeave(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = PointerLeaveAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@onpointerleave</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void PointerLeave(this IElement element, PointerEventArgs eventArgs) => _ = PointerLeaveAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerleave</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerLeaveAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("onpointerleave", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointermove</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void PointerMove(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = PointerMoveAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@onpointermove</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void PointerMove(this IElement element, PointerEventArgs eventArgs) => _ = PointerMoveAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointermove</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerMoveAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("onpointermove", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerout</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void PointerOut(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = PointerOutAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@onpointerout</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void PointerOut(this IElement element, PointerEventArgs eventArgs) => _ = PointerOutAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerout</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerOutAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("onpointerout", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerover</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void PointerOver(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = PointerOverAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@onpointerover</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void PointerOver(this IElement element, PointerEventArgs eventArgs) => _ = PointerOverAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerover</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerOverAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("onpointerover", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerup</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="PointerEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="screenX">The X coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="screenY">The Y coordinate of the mouse pointer in global (screen) coordinates.</param>
-	/// <param name="clientX">The X coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="clientY">The Y coordinate of the mouse pointer in local (DOM content) coordinates.</param>
-	/// <param name="button">
-	///     The button number that was pressed when the mouse event was fired: Left button=0,
-	///     middle button=1 (if present), right button=2. For mice configured for left handed
-	///     use in which the button actions are reversed the values are instead read from
-	///     right to left.
-	/// </param>
-	/// <param name="buttons">
-	///     The buttons being pressed when the mouse event was fired: Left button=1, Right
-	///     button=2, Middle (wheel) button=4, 4th button (typically, "Browser Back" button)=8,
-	///     5th button (typically, "Browser Forward" button)=16. If two or more buttons are
-	///     pressed, returns the logical sum of the values. E.g., if Left button and Right
-	///     button are pressed, returns 3 (=1 | 2).
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	/// <param name="pointerId">A unique identifier for the pointer causing the event.</param>
-	/// <param name="width">The width (magnitude on the X axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="height">The height (magnitude on the Y axis), in CSS pixels, of the contact geometry of the pointer.</param>
-	/// <param name="pressure">The normalized pressure of the pointer input in the range of 0 to 1, where 0
-	/// and 1 represent the minimum and maximum pressure the hardware is capable of detecting, respectively.</param>
-	/// <param name="tiltX">The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis.</param>
-	/// <param name="tiltY">The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
-	/// and the plane containing both the transducer (e.g. pen stylus) axis and the X axis.</param>
-	/// <param name="pointerType">Indicates the device type that caused the event. Must be one of the strings mouse,
-	/// pen or touch, or an empty string.</param>
-	/// <param name="isPrimary">Indicates if the pointer represents the primary pointer of this pointer type.</param>
-	public static void PointerUp(this IElement element, long detail = default, double screenX = default, double screenY = default, double clientX = default, double clientY = default, long button = default, long buttons = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default, long pointerId = default, float width = default, float height = default, float pressure = default, float tiltX = default, float tiltY = default, string? pointerType = default, bool isPrimary = default)
-		=> _ = PointerUpAsync(element, new PointerEventArgs
-		{
-			Detail = detail,
-			ScreenX = screenX,
-			ScreenY = screenY,
-			ClientX = clientX,
-			ClientY = clientY,
-			Button = button,
-			Buttons = buttons,
-			CtrlKey = ctrlKey,
-			ShiftKey = shiftKey,
-			AltKey = altKey,
-			MetaKey = metaKey,
-			Type = type!,
-			PointerId = pointerId,
-			Width = width,
-			Height = height,
-			Pressure = pressure,
-			TiltX = tiltX,
-			TiltY = tiltY,
-			PointerType = pointerType!,
-			IsPrimary = isPrimary,
-		});
-
-	/// <summary>
-	/// Raises the <c>@onpointerup</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void PointerUp(this IElement element, PointerEventArgs eventArgs) => _ = PointerUpAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onpointerup</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task PointerUpAsync(this IElement element, PointerEventArgs eventArgs) => element.TriggerEventAsync("onpointerup", eventArgs);
-}
diff --git a/src/bunit/EventDispatchExtensions/ProgressEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/ProgressEventDispatchExtensions.cs
deleted file mode 100644
index 7cfe8fced..000000000
--- a/src/bunit/EventDispatchExtensions/ProgressEventDispatchExtensions.cs
+++ /dev/null
@@ -1,212 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// Pointer event dispatch helper extension methods.
-/// </summary>
-public static class ProgressEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@onloadstart</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ProgressEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="lengthComputable">Whether or not the total size of the transfer is known.</param>
-	/// <param name="loaded">The number of bytes transferred since the beginning of the operation. This doesn't include headers and other overhead, but only the content itself.</param>
-	/// <param name="total">The total number of bytes of content that will be transferred during the operation. If the total size is unknown, this value is zero.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void LoadStart(this IElement element, bool lengthComputable = default, long loaded = default, long total = default, string? type = default)
-		=> _ = LoadStartAsync(element, new ProgressEventArgs { LengthComputable = lengthComputable, Loaded = loaded, Total = total, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onloadstart</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void LoadStart(this IElement element, ProgressEventArgs eventArgs) => _ = LoadStartAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onloadstart</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task LoadStartAsync(this IElement element, ProgressEventArgs eventArgs) => element.TriggerEventAsync("onloadstart", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontimeout</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ProgressEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="lengthComputable">Whether or not the total size of the transfer is known.</param>
-	/// <param name="loaded">The number of bytes transferred since the beginning of the operation. This doesn't include headers and other overhead, but only the content itself.</param>
-	/// <param name="total">The total number of bytes of content that will be transferred during the operation. If the total size is unknown, this value is zero.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void Timeout(this IElement element, bool lengthComputable = default, long loaded = default, long total = default, string? type = default)
-		=> _ = TimeoutAsync(element, new ProgressEventArgs { LengthComputable = lengthComputable, Loaded = loaded, Total = total, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@ontimeout</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Timeout(this IElement element, ProgressEventArgs eventArgs) => _ = TimeoutAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontimeout</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task TimeoutAsync(this IElement element, ProgressEventArgs eventArgs) => element.TriggerEventAsync("ontimeout", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onabort</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ProgressEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="lengthComputable">Whether or not the total size of the transfer is known.</param>
-	/// <param name="loaded">The number of bytes transferred since the beginning of the operation. This doesn't include headers and other overhead, but only the content itself.</param>
-	/// <param name="total">The total number of bytes of content that will be transferred during the operation. If the total size is unknown, this value is zero.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void Abort(this IElement element, bool lengthComputable = default, long loaded = default, long total = default, string? type = default)
-		=> _ = AbortAsync(element, new ProgressEventArgs { LengthComputable = lengthComputable, Loaded = loaded, Total = total, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onabort</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Abort(this IElement element, ProgressEventArgs eventArgs) => _ = AbortAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onabort</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task AbortAsync(this IElement element, ProgressEventArgs eventArgs) => element.TriggerEventAsync("onabort", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onload</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ProgressEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="lengthComputable">Whether or not the total size of the transfer is known.</param>
-	/// <param name="loaded">The number of bytes transferred since the beginning of the operation. This doesn't include headers and other overhead, but only the content itself.</param>
-	/// <param name="total">The total number of bytes of content that will be transferred during the operation. If the total size is unknown, this value is zero.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void Load(this IElement element, bool lengthComputable = default, long loaded = default, long total = default, string? type = default)
-		=> _ = LoadAsync(element, new ProgressEventArgs { LengthComputable = lengthComputable, Loaded = loaded, Total = total, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onload</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Load(this IElement element, ProgressEventArgs eventArgs) => _ = LoadAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onload</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task LoadAsync(this IElement element, ProgressEventArgs eventArgs) => element.TriggerEventAsync("onload", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onloadend</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ProgressEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="lengthComputable">Whether or not the total size of the transfer is known.</param>
-	/// <param name="loaded">The number of bytes transferred since the beginning of the operation. This doesn't include headers and other overhead, but only the content itself.</param>
-	/// <param name="total">The total number of bytes of content that will be transferred during the operation. If the total size is unknown, this value is zero.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void LoadEnd(this IElement element, bool lengthComputable = default, long loaded = default, long total = default, string? type = default)
-		=> _ = LoadEndAsync(element, new ProgressEventArgs { LengthComputable = lengthComputable, Loaded = loaded, Total = total, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onloadend</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void LoadEnd(this IElement element, ProgressEventArgs eventArgs) => _ = LoadEndAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onloadend</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task LoadEndAsync(this IElement element, ProgressEventArgs eventArgs) => element.TriggerEventAsync("onloadend", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onprogress</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ProgressEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="lengthComputable">Whether or not the total size of the transfer is known.</param>
-	/// <param name="loaded">The number of bytes transferred since the beginning of the operation. This doesn't include headers and other overhead, but only the content itself.</param>
-	/// <param name="total">The total number of bytes of content that will be transferred during the operation. If the total size is unknown, this value is zero.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void Progress(this IElement element, bool lengthComputable = default, long loaded = default, long total = default, string? type = default)
-		=> _ = ProgressAsync(element, new ProgressEventArgs { LengthComputable = lengthComputable, Loaded = loaded, Total = total, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onprogress</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Progress(this IElement element, ProgressEventArgs eventArgs) => _ = ProgressAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onprogress</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ProgressAsync(this IElement element, ProgressEventArgs eventArgs) => element.TriggerEventAsync("onprogress", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onerror</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="ProgressEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="lengthComputable">Whether or not the total size of the transfer is known.</param>
-	/// <param name="loaded">The number of bytes transferred since the beginning of the operation. This doesn't include headers and other overhead, but only the content itself.</param>
-	/// <param name="total">The total number of bytes of content that will be transferred during the operation. If the total size is unknown, this value is zero.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void Error(this IElement element, bool lengthComputable = default, long loaded = default, long total = default, string? type = default)
-		=> _ = ErrorAsync(element, new ProgressEventArgs { LengthComputable = lengthComputable, Loaded = loaded, Total = total, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@onerror</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void Error(this IElement element, ProgressEventArgs eventArgs) => _ = ErrorAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@onerror</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task ErrorAsync(this IElement element, ProgressEventArgs eventArgs) => element.TriggerEventAsync("onerror", eventArgs);
-}
diff --git a/src/bunit/EventDispatchExtensions/TouchEventDispatchExtensions.cs b/src/bunit/EventDispatchExtensions/TouchEventDispatchExtensions.cs
deleted file mode 100644
index 39b67d2a0..000000000
--- a/src/bunit/EventDispatchExtensions/TouchEventDispatchExtensions.cs
+++ /dev/null
@@ -1,261 +0,0 @@
-using AngleSharp.Dom;
-
-namespace Bunit;
-
-/// <summary>
-/// Pointer event dispatch helper extension methods.
-/// </summary>
-public static class TouchEventDispatchExtensions
-{
-	/// <summary>
-	/// Raises the <c>@ontouchcancel</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="TouchEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="touches">A list of <see cref="TouchPoint"/> for every point of contact currently touching the surface.</param>
-	/// <param name="targetTouches">A list of <see cref="TouchPoint"/> for every point of contact that is touching the surface and started on the element that is the target of the current event.</param>
-	/// <param name="changedTouches">A list of Touches for every point of contact which contributed to the event.
-	/// For the touchstart event this must be a list of the touch points that just became
-	/// active with the current event. For the touchmove event this must be a list of
-	/// the touch points that have moved since the last event. For the touchend and touchcancel
-	/// events this must be a list of the touch points that have just been removed from
-	/// the surface.
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void TouchCancel(this IElement element, long detail = default, TouchPoint[]? touches = default, TouchPoint[]? targetTouches = default, TouchPoint[]? changedTouches = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = TouchCancelAsync(element, new TouchEventArgs { Detail = detail, Touches = touches ?? Array.Empty<TouchPoint>(), TargetTouches = targetTouches ?? Array.Empty<TouchPoint>(), ChangedTouches = changedTouches ?? Array.Empty<TouchPoint>(), CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@ontouchcancel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void TouchCancel(this IElement element, TouchEventArgs eventArgs)
-		=> _ = TouchCancelAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchcancel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task TouchCancelAsync(this IElement element, TouchEventArgs eventArgs)
-		=> element.TriggerEventAsync("ontouchcancel", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchend</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="TouchEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="touches">A list of <see cref="TouchPoint"/> for every point of contact currently touching the surface.</param>
-	/// <param name="targetTouches">A list of <see cref="TouchPoint"/> for every point of contact that is touching the surface and started on the element that is the target of the current event.</param>
-	/// <param name="changedTouches">A list of Touches for every point of contact which contributed to the event.
-	/// For the touchstart event this must be a list of the touch points that just became
-	/// active with the current event. For the touchmove event this must be a list of
-	/// the touch points that have moved since the last event. For the touchend and touchcancel
-	/// events this must be a list of the touch points that have just been removed from
-	/// the surface.
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void TouchEnd(this IElement element, long detail = default, TouchPoint[]? touches = default, TouchPoint[]? targetTouches = default, TouchPoint[]? changedTouches = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = TouchEndAsync(element, new TouchEventArgs { Detail = detail, Touches = touches ?? Array.Empty<TouchPoint>(), TargetTouches = targetTouches ?? Array.Empty<TouchPoint>(), ChangedTouches = changedTouches ?? Array.Empty<TouchPoint>(), CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@ontouchend</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void TouchEnd(this IElement element, TouchEventArgs eventArgs)
-		=> _ = TouchEndAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchend</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task TouchEndAsync(this IElement element, TouchEventArgs eventArgs)
-		=> element.TriggerEventAsync("ontouchend", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchmove</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="TouchEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="touches">A list of <see cref="TouchPoint"/> for every point of contact currently touching the surface.</param>
-	/// <param name="targetTouches">A list of <see cref="TouchPoint"/> for every point of contact that is touching the surface and started on the element that is the target of the current event.</param>
-	/// <param name="changedTouches">A list of Touches for every point of contact which contributed to the event.
-	/// For the touchstart event this must be a list of the touch points that just became
-	/// active with the current event. For the touchmove event this must be a list of
-	/// the touch points that have moved since the last event. For the touchend and touchcancel
-	/// events this must be a list of the touch points that have just been removed from
-	/// the surface.
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void TouchMove(this IElement element, long detail = default, TouchPoint[]? touches = default, TouchPoint[]? targetTouches = default, TouchPoint[]? changedTouches = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = TouchMoveAsync(element, new TouchEventArgs { Detail = detail, Touches = touches ?? Array.Empty<TouchPoint>(), TargetTouches = targetTouches ?? Array.Empty<TouchPoint>(), ChangedTouches = changedTouches ?? Array.Empty<TouchPoint>(), CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@ontouchmove</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void TouchMove(this IElement element, TouchEventArgs eventArgs)
-		=> _ = TouchMoveAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchmove</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task TouchMoveAsync(this IElement element, TouchEventArgs eventArgs)
-		=> element.TriggerEventAsync("ontouchmove", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchstart</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="TouchEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="touches">A list of <see cref="TouchPoint"/> for every point of contact currently touching the surface.</param>
-	/// <param name="targetTouches">A list of <see cref="TouchPoint"/> for every point of contact that is touching the surface and started on the element that is the target of the current event.</param>
-	/// <param name="changedTouches">A list of Touches for every point of contact which contributed to the event.
-	/// For the touchstart event this must be a list of the touch points that just became
-	/// active with the current event. For the touchmove event this must be a list of
-	/// the touch points that have moved since the last event. For the touchend and touchcancel
-	/// events this must be a list of the touch points that have just been removed from
-	/// the surface.
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void TouchStart(this IElement element, long detail = default, TouchPoint[]? touches = default, TouchPoint[]? targetTouches = default, TouchPoint[]? changedTouches = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = TouchStartAsync(element, new TouchEventArgs { Detail = detail, Touches = touches ?? Array.Empty<TouchPoint>(), TargetTouches = targetTouches ?? Array.Empty<TouchPoint>(), ChangedTouches = changedTouches ?? Array.Empty<TouchPoint>(), CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@ontouchstart</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void TouchStart(this IElement element, TouchEventArgs eventArgs)
-		=> _ = TouchStartAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchstart</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task TouchStartAsync(this IElement element, TouchEventArgs eventArgs)
-		=> element.TriggerEventAsync("ontouchstart", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchenter</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="TouchEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="touches">A list of <see cref="TouchPoint"/> for every point of contact currently touching the surface.</param>
-	/// <param name="targetTouches">A list of <see cref="TouchPoint"/> for every point of contact that is touching the surface and started on the element that is the target of the current event.</param>
-	/// <param name="changedTouches">A list of Touches for every point of contact which contributed to the event.
-	/// For the touchstart event this must be a list of the touch points that just became
-	/// active with the current event. For the touchmove event this must be a list of
-	/// the touch points that have moved since the last event. For the touchend and touchcancel
-	/// events this must be a list of the touch points that have just been removed from
-	/// the surface.
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void TouchEnter(this IElement element, long detail = default, TouchPoint[]? touches = default, TouchPoint[]? targetTouches = default, TouchPoint[]? changedTouches = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = TouchEnterAsync(element, new TouchEventArgs { Detail = detail, Touches = touches ?? Array.Empty<TouchPoint>(), TargetTouches = targetTouches ?? Array.Empty<TouchPoint>(), ChangedTouches = changedTouches ?? Array.Empty<TouchPoint>(), CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@ontouchenter</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void TouchEnter(this IElement element, TouchEventArgs eventArgs)
-		=> _ = TouchEnterAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchenter</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task TouchEnterAsync(this IElement element, TouchEventArgs eventArgs)
-		=> element.TriggerEventAsync("ontouchenter", eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchleave</c> event on <paramref name="element"/>, passing the provided
-	/// properties to the event handler via a <see cref="TouchEventArgs"/> object.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="detail">A count of consecutive clicks that happened in a short amount of time, incremented by one.</param>
-	/// <param name="touches">A list of <see cref="TouchPoint"/> for every point of contact currently touching the surface.</param>
-	/// <param name="targetTouches">A list of <see cref="TouchPoint"/> for every point of contact that is touching the surface and started on the element that is the target of the current event.</param>
-	/// <param name="changedTouches">A list of Touches for every point of contact which contributed to the event.
-	/// For the touchstart event this must be a list of the touch points that just became
-	/// active with the current event. For the touchmove event this must be a list of
-	/// the touch points that have moved since the last event. For the touchend and touchcancel
-	/// events this must be a list of the touch points that have just been removed from
-	/// the surface.
-	/// </param>
-	/// <param name="ctrlKey">true if the control key was down when the event was fired. false otherwise.</param>
-	/// <param name="shiftKey">true if the shift key was down when the event was fired. false otherwise.</param>
-	/// <param name="altKey">true if the alt key was down when the event was fired. false otherwise.</param>
-	/// <param name="metaKey">true if the meta key was down when the event was fired. false otherwise.</param>
-	/// <param name="type">Gets or sets the type of the event.</param>
-	public static void TouchLeave(this IElement element, long detail = default, TouchPoint[]? touches = default, TouchPoint[]? targetTouches = default, TouchPoint[]? changedTouches = default, bool ctrlKey = default, bool shiftKey = default, bool altKey = default, bool metaKey = default, string? type = default)
-		=> _ = TouchLeaveAsync(element, new TouchEventArgs { Detail = detail, Touches = touches ?? Array.Empty<TouchPoint>(), TargetTouches = targetTouches ?? Array.Empty<TouchPoint>(), ChangedTouches = changedTouches ?? Array.Empty<TouchPoint>(), CtrlKey = ctrlKey, ShiftKey = shiftKey, AltKey = altKey, MetaKey = metaKey, Type = type! });
-
-	/// <summary>
-	/// Raises the <c>@ontouchleave</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	public static void TouchLeave(this IElement element, TouchEventArgs eventArgs)
-		=> _ = TouchLeaveAsync(element, eventArgs);
-
-	/// <summary>
-	/// Raises the <c>@ontouchleave</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
-	/// to the event handler.
-	/// </summary>
-	/// <param name="element">The element to raise the event on.</param>
-	/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
-	/// <returns>A task that completes when the event handler is done.</returns>
-	public static Task TouchLeaveAsync(this IElement element, TouchEventArgs eventArgs)
-		=> element.TriggerEventAsync("ontouchleave", eventArgs);
-}
diff --git a/tests/bunit.tests/EventDispatchExtensions/ClipboardEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/ClipboardEventDispatchExtensionsTest.cs
index f8110d62f..294855a37 100644
--- a/tests/bunit.tests/EventDispatchExtensions/ClipboardEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/ClipboardEventDispatchExtensionsTest.cs
@@ -9,7 +9,7 @@ public ClipboardEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : ba
 	protected override string ElementName => "textarea";
 
 	[Theory(DisplayName = "Clipboard events are raised correctly through helpers")]
-	[MemberData(nameof(GetEventHelperMethods), typeof(ClipboardEventDispatchExtensions))]
+	[MemberData(nameof(GetEventHelperMethods))]
 	public void CanRaiseEvents(MethodInfo helper)
 	{
 		var expected = new ClipboardEventArgs
diff --git a/tests/bunit.tests/EventDispatchExtensions/DragEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/DragEventDispatchExtensionsTest.cs
index fbb6d7f95..20f7f856c 100644
--- a/tests/bunit.tests/EventDispatchExtensions/DragEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/DragEventDispatchExtensionsTest.cs
@@ -9,7 +9,7 @@ public DragEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : base(ou
 	protected override string ElementName => "textarea";
 
 	[Theory(DisplayName = "Drag events are raised correctly through helpers")]
-	[MemberData(nameof(GetEventHelperMethods), typeof(DragEventDispatchExtensions))]
+	[MemberData(nameof(GetEventHelperMethods))]
 	public void CanRaiseEvents(MethodInfo helper)
 	{
 		var expected = new DragEventArgs
diff --git a/tests/bunit.tests/EventDispatchExtensions/EventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/EventDispatchExtensionsTest.cs
index bf5409f3d..b89a10584 100644
--- a/tests/bunit.tests/EventDispatchExtensions/EventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/EventDispatchExtensionsTest.cs
@@ -85,23 +85,21 @@ private static string GetEventNameFromMethod(MethodInfo helper)
 	}
 
 	[SuppressMessage("Design", "CA1000:Do not declare static members on generic types", Justification = "Can safely be shared")]
-	public static IEnumerable<object[]> GetEventHelperMethods(Type helperClassType)
+	public static IEnumerable<object[]> GetEventHelperMethods()
 	{
-		ArgumentNullException.ThrowIfNull(helperClassType);
-
-		return helperClassType.GetMethods()
+		return typeof(EventHandlerDispatchExtensions).GetMethods()
 			.Where(x => x.GetParameters().FirstOrDefault()?.ParameterType == typeof(IElement))
+			.Where(x => x.GetParameters().Skip(1).FirstOrDefault()?.ParameterType == typeof(TEventArgs))
 			.Select(x => new[] { x })
 			.ToArray();
 	}
 
 	[SuppressMessage("Design", "CA1000:Do not declare static members on generic types", Justification = "Can safely be shared")]
-	public static IEnumerable<object[]> GetEventHelperMethods(Type helperClassType, Func<MethodInfo, bool> customFilter)
+	public static IEnumerable<object[]> GetEventHelperMethods(Func<MethodInfo, bool> customFilter)
 	{
-		ArgumentNullException.ThrowIfNull(helperClassType);
-
-		return helperClassType.GetMethods()
+		return typeof(EventHandlerDispatchExtensions).GetMethods()
 			.Where(x => x.GetParameters().FirstOrDefault()?.ParameterType == typeof(IElement) && customFilter(x))
+			.Where(x => x.GetParameters().Skip(1).FirstOrDefault()?.ParameterType == typeof(TEventArgs))
 			.Select(x => new[] { x })
 			.ToArray();
 	}
diff --git a/tests/bunit.tests/EventDispatchExtensions/FocusEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/FocusEventDispatchExtensionsTest.cs
index 6fc79f930..94574be01 100644
--- a/tests/bunit.tests/EventDispatchExtensions/FocusEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/FocusEventDispatchExtensionsTest.cs
@@ -9,7 +9,7 @@ public FocusEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : base(o
 	protected override string ElementName => "p";
 
 	[Theory(DisplayName = "Focus events are raised correctly through helpers")]
-	[MemberData(nameof(GetEventHelperMethods), typeof(FocusEventDispatchExtensions))]
+	[MemberData(nameof(GetEventHelperMethods))]
 	public void CanRaiseEvents(MethodInfo helper)
 	{
 		var expected = new FocusEventArgs
diff --git a/tests/bunit.tests/EventDispatchExtensions/GeneralEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/GeneralEventDispatchExtensionsTest.cs
index e4668c430..89a047f91 100644
--- a/tests/bunit.tests/EventDispatchExtensions/GeneralEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/GeneralEventDispatchExtensionsTest.cs
@@ -6,6 +6,9 @@ namespace Bunit;
 
 public class GeneralEventDispatchExtensionsTest : EventDispatchExtensionsTest<EventArgs>
 {
+	public static IEnumerable<object[]> Helpers { get; }
+		= GetEventHelperMethods(x => !x.Name.Contains("submit", StringComparison.OrdinalIgnoreCase));
+	
 	protected override string ElementName => "p";
 
 	public GeneralEventDispatchExtensionsTest(ITestOutputHelper outputHelper)
@@ -15,7 +18,7 @@ public GeneralEventDispatchExtensionsTest(ITestOutputHelper outputHelper)
 	}
 
 	[Theory(DisplayName = "General events are raised correctly through helpers")]
-	[MemberData(nameof(GetEventHelperMethods), typeof(GeneralEventDispatchExtensions))]
+	[MemberData(nameof(Helpers))]
 	public void CanRaiseEvents(MethodInfo helper)
 	{
 		ArgumentNullException.ThrowIfNull(helper);
diff --git a/tests/bunit.tests/EventDispatchExtensions/InputEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/InputEventDispatchExtensionsTest.cs
index 304c0b8ba..514e2d2f7 100644
--- a/tests/bunit.tests/EventDispatchExtensions/InputEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/InputEventDispatchExtensionsTest.cs
@@ -2,9 +2,12 @@ namespace Bunit;
 
 public class InputEventDispatchExtensionsTest : EventDispatchExtensionsTest<ChangeEventArgs>
 {
-	private static readonly string[] ExcludedMethodsFromGenericTests = new[] { "Change", "Input", "Submit" };
+	// ChangeEventArgs naturally translates only to "change" and "input" but not submit
+	// See: https://source.dot.net/#Microsoft.AspNetCore.Components.Web/Web/EventHandlers.cs
+	// Therefore, we add those explicitly here.
+	private static readonly string[] UseEventHandlers = ["Change", "Input", "Submit"];
 	public static IEnumerable<object[]> Helpers { get; }
-		= GetEventHelperMethods(typeof(InputEventDispatchExtensions), x => !ExcludedMethodsFromGenericTests
+		= GetEventHelperMethods(x => UseEventHandlers
 		.Contains(x.Name.Replace("Async", string.Empty, StringComparison.Ordinal)));
 
 	private static readonly Fixture Fixture = new();
diff --git a/tests/bunit.tests/EventDispatchExtensions/KeyboardEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/KeyboardEventDispatchExtensionsTest.cs
index e5c7c465d..fc354eb49 100644
--- a/tests/bunit.tests/EventDispatchExtensions/KeyboardEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/KeyboardEventDispatchExtensionsTest.cs
@@ -8,7 +8,6 @@ public KeyboardEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : bas
 
 	public static IEnumerable<object[]> Helpers { get; }
 		= GetEventHelperMethods(
-			typeof(KeyboardEventDispatchExtensions),
 			x => Array.TrueForAll(x.GetParameters(), p => p.ParameterType != typeof(Key)));
 
 	protected override string ElementName => "input";
diff --git a/tests/bunit.tests/EventDispatchExtensions/MediaEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/MediaEventDispatchExtensionsTest.cs
deleted file mode 100644
index 3ee3153a5..000000000
--- a/tests/bunit.tests/EventDispatchExtensions/MediaEventDispatchExtensionsTest.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-namespace Bunit;
-
-public class MediaEventDispatchExtensionsTest : EventDispatchExtensionsTest<EventArgs>
-{
-	public MediaEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : base(outputHelper)
-	{
-	}
-
-	protected override string ElementName => "audio";
-
-	[Theory(DisplayName = "Media events are raised correctly through helpers")]
-	[MemberData(nameof(GetEventHelperMethods), typeof(MediaEventDispatchExtensions))]
-	public void CanRaiseEvents(MethodInfo helper)
-	{
-		VerifyEventRaisesCorrectly(helper, EventArgs.Empty);
-	}
-}
diff --git a/tests/bunit.tests/EventDispatchExtensions/MouseEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/MouseEventDispatchExtensionsTest.cs
index 03d562b06..226a36947 100644
--- a/tests/bunit.tests/EventDispatchExtensions/MouseEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/MouseEventDispatchExtensionsTest.cs
@@ -8,7 +8,6 @@ public MouseEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : base(o
 
 	public static IEnumerable<object[]> Helpers { get; }
 		= GetEventHelperMethods(
-			typeof(MouseEventDispatchExtensions),
 			x => !x.Name.Contains("Wheel", StringComparison.OrdinalIgnoreCase)
 			  && !x.Name.Contains("DoubleClick", StringComparison.OrdinalIgnoreCase));
 
diff --git a/tests/bunit.tests/EventDispatchExtensions/PointerEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/PointerEventDispatchExtensionsTest.cs
index bc239a37d..54668ce86 100644
--- a/tests/bunit.tests/EventDispatchExtensions/PointerEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/PointerEventDispatchExtensionsTest.cs
@@ -9,7 +9,7 @@ public PointerEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : base
 	protected override string ElementName => "div";
 
 	[Theory(DisplayName = "Pointer events are raised correctly through helpers")]
-	[MemberData(nameof(GetEventHelperMethods), typeof(PointerEventDispatchExtensions))]
+	[MemberData(nameof(GetEventHelperMethods))]
 	public void CanRaiseEvents(MethodInfo helper)
 	{
 		var expected = new PointerEventArgs
diff --git a/tests/bunit.tests/EventDispatchExtensions/ProgressEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/ProgressEventDispatchExtensionsTest.cs
index ca63db4ed..6aa852185 100644
--- a/tests/bunit.tests/EventDispatchExtensions/ProgressEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/ProgressEventDispatchExtensionsTest.cs
@@ -9,7 +9,7 @@ public ProgressEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : bas
 	protected override string ElementName => "div";
 
 	[Theory(DisplayName = "Progress events are raised correctly through helpers")]
-	[MemberData(nameof(GetEventHelperMethods), typeof(ProgressEventDispatchExtensions))]
+	[MemberData(nameof(GetEventHelperMethods))]
 	public void CanRaiseEvents(MethodInfo helper)
 	{
 		var expected = new ProgressEventArgs
diff --git a/tests/bunit.tests/EventDispatchExtensions/TouchEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/TouchEventDispatchExtensionsTest.cs
index b1e2ce8e2..603da671f 100644
--- a/tests/bunit.tests/EventDispatchExtensions/TouchEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/TouchEventDispatchExtensionsTest.cs
@@ -9,7 +9,7 @@ public TouchEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : base(o
 	protected override string ElementName => "p";
 
 	[Theory(DisplayName = "Touch events are raised correctly through helpers")]
-	[MemberData(nameof(GetEventHelperMethods), typeof(TouchEventDispatchExtensions))]
+	[MemberData(nameof(GetEventHelperMethods))]
 	public void CanRaiseEvents(MethodInfo helper)
 	{
 		var expected = new TouchEventArgs
diff --git a/tests/bunit.tests/EventDispatchExtensions/WheelEventDispatchExtensionsTest.cs b/tests/bunit.tests/EventDispatchExtensions/WheelEventDispatchExtensionsTest.cs
index dbbb3ea17..b2fd53822 100644
--- a/tests/bunit.tests/EventDispatchExtensions/WheelEventDispatchExtensionsTest.cs
+++ b/tests/bunit.tests/EventDispatchExtensions/WheelEventDispatchExtensionsTest.cs
@@ -7,7 +7,7 @@ public WheelEventDispatchExtensionsTest(ITestOutputHelper outputHelper) : base(o
 	}
 
 	public static IEnumerable<object[]> Helpers { get; }
-		= GetEventHelperMethods(typeof(MouseEventDispatchExtensions), x => x.Name.Contains("Wheel", StringComparison.OrdinalIgnoreCase));
+		= GetEventHelperMethods(x => x.Name.Contains("Wheel", StringComparison.OrdinalIgnoreCase));
 
 	protected override string ElementName => "button";