diff --git a/src/functions.php b/src/functions.php
index 429f0e73..2177dc23 100644
--- a/src/functions.php
+++ b/src/functions.php
@@ -354,7 +354,7 @@ function _checkTypehint(callable $callback, $object)
 
     // Extract the type of the argument and handle different possibilities
     $type = $expectedException->getType();
-    
+
     $isTypeUnion = true;
     $types = [];
 
@@ -379,14 +379,18 @@ function _checkTypehint(callable $callback, $object)
     }
 
     foreach ($types as $type) {
-        if (!$type instanceof \ReflectionNamedType) {
-            throw new \LogicException('This implementation does not support groups of intersection or union types');
-        }
-
-        // A named-type can be either a class-name or a built-in type like string, int, array, etc.
-        $matches = ($type->isBuiltin() && \gettype($object) === $type->getName())
-            || (new \ReflectionClass($type->getName()))->isInstance($object);
 
+        if ($type instanceof \ReflectionIntersectionType) {
+            foreach ($type->getTypes() as $typeToMatch) {
+                if (!($matches = ($typeToMatch->isBuiltin() && \gettype($object) === $typeToMatch->getName())
+                    || (new \ReflectionClass($typeToMatch->getName()))->isInstance($object))) {
+                    break;
+                }
+            }
+        } else {
+            $matches = ($type->isBuiltin() && \gettype($object) === $type->getName())
+                || (new \ReflectionClass($type->getName()))->isInstance($object);
+        }
 
         // If we look for a single match (union), we can return early on match
         // If we look for a full match (intersection), we can return early on mismatch
diff --git a/tests/FunctionCheckTypehintTest.php b/tests/FunctionCheckTypehintTest.php
index b8d3fbe7..719f5e05 100644
--- a/tests/FunctionCheckTypehintTest.php
+++ b/tests/FunctionCheckTypehintTest.php
@@ -117,6 +117,39 @@ public function shouldAcceptStaticClassCallbackWithIntersectionTypehint()
         self::assertTrue(_checkTypehint(['React\Promise\CallbackWithIntersectionTypehintClass', 'testCallbackStatic'], new CountableException()));
     }
 
+    /**
+     * @test
+     * @requires PHP 8.2
+     */
+    public function shouldAcceptInvokableObjectCallbackWithDNFTypehint()
+    {
+        self::assertFalse(_checkTypehint(new CallbackWithDNFTypehintClass(), new \RuntimeException()));
+        self::assertTrue(_checkTypehint(new CallbackWithDNFTypehintClass(), new ArrayAccessibleException()));
+        self::assertTrue(_checkTypehint(new CallbackWithDNFTypehintClass(), new CountableException()));
+    }
+
+    /**
+     * @test
+     * @requires PHP 8.2
+     */
+    public function shouldAcceptObjectMethodCallbackWithDNFTypehint()
+    {
+        self::assertFalse(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new \RuntimeException()));
+        self::assertTrue(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new CountableException()));
+        self::assertTrue(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new ArrayAccessibleException()));
+    }
+
+    /**
+     * @test
+     * @requires PHP 8.2
+     */
+    public function shouldAcceptStaticClassCallbackWithDNFTypehint()
+    {
+        self::assertFalse(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new \RuntimeException()));
+        self::assertTrue(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new CountableException()));
+        self::assertTrue(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new ArrayAccessibleException()));
+    }
+
     /** @test */
     public function shouldAcceptClosureCallbackWithoutTypehint()
     {
diff --git a/tests/fixtures/ArrayAccessibleException.php b/tests/fixtures/ArrayAccessibleException.php
new file mode 100644
index 00000000..71b7ad2a
--- /dev/null
+++ b/tests/fixtures/ArrayAccessibleException.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace React\Promise;
+
+use RuntimeException;
+
+class ArrayAccessibleException extends RuntimeException implements \ArrayAccess
+{
+    public function offsetExists(mixed $offset): bool
+    {
+        return true;
+    }
+
+    public function offsetGet(mixed $offset): mixed
+    {
+        return $offset;
+    }
+
+    public function offsetSet(mixed $offset, mixed $value): void {}
+
+    public function offsetUnset(mixed $offset): void {}
+}
diff --git a/tests/fixtures/CallbackWithDNFTypehintClass.php b/tests/fixtures/CallbackWithDNFTypehintClass.php
new file mode 100644
index 00000000..391916b1
--- /dev/null
+++ b/tests/fixtures/CallbackWithDNFTypehintClass.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace React\Promise;
+
+use Countable;
+use RuntimeException;
+
+class CallbackWithDNFTypehintClass
+{
+    public function __invoke((RuntimeException&Countable)|(RuntimeException&\ArrayAccess) $e)
+    {
+    }
+
+public function testCallback((RuntimeException&Countable)|(RuntimeException&\ArrayAccess) $e)
+    {
+    }
+
+    public static function testCallbackStatic((RuntimeException&Countable)|(RuntimeException&\ArrayAccess) $e)
+    {
+    }
+}