@@ -130,7 +130,7 @@ discard block  | 
                                                    ||
| 130 | 130 | ClassesLoaderInterface $loader,  | 
                                                        
| 131 | 131 | ListenerInvoker $invoker,  | 
                                                        
| 132 | 132 |      ): void { | 
                                                        
| 133 | -        if ($config->isLoadClassesEnabled()) { | 
                                                        |
| 133 | +        if ($config->isLoadClassesEnabled()){ | 
                                                        |
| 134 | 134 | $this->loadReflections($invoker, $classes->getClasses(...), $loader->loadClasses(...));  | 
                                                        
| 135 | 135 | }  | 
                                                        
| 136 | 136 | }  | 
                                                        
@@ -141,7 +141,7 @@ discard block  | 
                                                    ||
| 141 | 141 | EnumsLoaderInterface $loader,  | 
                                                        
| 142 | 142 | ListenerInvoker $invoker,  | 
                                                        
| 143 | 143 |      ): void { | 
                                                        
| 144 | -        if ($config->isLoadEnumsEnabled()) { | 
                                                        |
| 144 | +        if ($config->isLoadEnumsEnabled()){ | 
                                                        |
| 145 | 145 | $this->loadReflections($invoker, $enums->getEnums(...), $loader->loadEnums(...));  | 
                                                        
| 146 | 146 | }  | 
                                                        
| 147 | 147 | }  | 
                                                        
@@ -152,7 +152,7 @@ discard block  | 
                                                    ||
| 152 | 152 | InterfacesLoaderInterface $loader,  | 
                                                        
| 153 | 153 | ListenerInvoker $invoker,  | 
                                                        
| 154 | 154 |      ): void { | 
                                                        
| 155 | -        if ($config->isLoadInterfacesEnabled()) { | 
                                                        |
| 155 | +        if ($config->isLoadInterfacesEnabled()){ | 
                                                        |
| 156 | 156 | $this->loadReflections($invoker, $interfaces->getInterfaces(...), $loader->loadInterfaces(...));  | 
                                                        
| 157 | 157 | }  | 
                                                        
| 158 | 158 | }  | 
                                                        
@@ -170,15 +170,15 @@ discard block  | 
                                                    ||
| 170 | 170 | |
| 171 | 171 | // First, we check if the listener has been cached. If it has, we will load the classes/enums/interfaces  | 
                                                        
| 172 | 172 | // from the cache.  | 
                                                        
| 173 | -        foreach ($listeners as $i => $listener) { | 
                                                        |
| 174 | -            if ($loader($listener)) { | 
                                                        |
| 173 | +        foreach ($listeners as $i => $listener){ | 
                                                        |
| 174 | +            if ($loader($listener)){ | 
                                                        |
| 175 | 175 | unset($listeners[$i]);  | 
                                                        
| 176 | 176 | }  | 
                                                        
| 177 | 177 | }  | 
                                                        
| 178 | 178 | |
| 179 | 179 | // If there are no listeners left, we don't need to use static analysis at all and save  | 
                                                        
| 180 | 180 | // valuable time.  | 
                                                        
| 181 | -        if ($listeners === []) { | 
                                                        |
| 181 | +        if ($listeners === []){ | 
                                                        |
| 182 | 182 | return;  | 
                                                        
| 183 | 183 | }  | 
                                                        
| 184 | 184 | |
@@ -186,14 +186,14 @@ discard block  | 
                                                    ||
| 186 | 186 | // Please note that this is a very expensive operation and should be avoided if possible.  | 
                                                        
| 187 | 187 | // Use #[TargetClass] or #[TargetAttribute] attributes in your listeners to cache the classes/enums/interfaces.  | 
                                                        
| 188 | 188 | $classes = $reflections();  | 
                                                        
| 189 | -        foreach ($listeners as $listener) { | 
                                                        |
| 189 | +        foreach ($listeners as $listener){ | 
                                                        |
| 190 | 190 | $invoker->invoke($listener, $classes);  | 
                                                        
| 191 | 191 | }  | 
                                                        
| 192 | 192 | }  | 
                                                        
| 193 | 193 | |
| 194 | 194 | private function finalizeListeners(): void  | 
                                                        
| 195 | 195 |      { | 
                                                        
| 196 | -        foreach ($this->listeners as $listener) { | 
                                                        |
| 196 | +        foreach ($this->listeners as $listener){ | 
                                                        |
| 197 | 197 | $listener->finalize();  | 
                                                        
| 198 | 198 | }  | 
                                                        
| 199 | 199 | // We don't need the listeners anymore, so we will clear them from memory.  | 
                                                        
@@ -130,7 +130,8 @@ discard block  | 
                                                    ||
| 130 | 130 | ClassesLoaderInterface $loader,  | 
                                                        
| 131 | 131 | ListenerInvoker $invoker,  | 
                                                        
| 132 | 132 |      ): void { | 
                                                        
| 133 | -        if ($config->isLoadClassesEnabled()) { | 
                                                        |
| 133 | + if ($config->isLoadClassesEnabled())  | 
                                                        |
| 134 | +        { | 
                                                        |
| 134 | 135 | $this->loadReflections($invoker, $classes->getClasses(...), $loader->loadClasses(...));  | 
                                                        
| 135 | 136 | }  | 
                                                        
| 136 | 137 | }  | 
                                                        
@@ -141,7 +142,8 @@ discard block  | 
                                                    ||
| 141 | 142 | EnumsLoaderInterface $loader,  | 
                                                        
| 142 | 143 | ListenerInvoker $invoker,  | 
                                                        
| 143 | 144 |      ): void { | 
                                                        
| 144 | -        if ($config->isLoadEnumsEnabled()) { | 
                                                        |
| 145 | + if ($config->isLoadEnumsEnabled())  | 
                                                        |
| 146 | +        { | 
                                                        |
| 145 | 147 | $this->loadReflections($invoker, $enums->getEnums(...), $loader->loadEnums(...));  | 
                                                        
| 146 | 148 | }  | 
                                                        
| 147 | 149 | }  | 
                                                        
@@ -152,7 +154,8 @@ discard block  | 
                                                    ||
| 152 | 154 | InterfacesLoaderInterface $loader,  | 
                                                        
| 153 | 155 | ListenerInvoker $invoker,  | 
                                                        
| 154 | 156 |      ): void { | 
                                                        
| 155 | -        if ($config->isLoadInterfacesEnabled()) { | 
                                                        |
| 157 | + if ($config->isLoadInterfacesEnabled())  | 
                                                        |
| 158 | +        { | 
                                                        |
| 156 | 159 | $this->loadReflections($invoker, $interfaces->getInterfaces(...), $loader->loadInterfaces(...));  | 
                                                        
| 157 | 160 | }  | 
                                                        
| 158 | 161 | }  | 
                                                        
@@ -170,15 +173,18 @@ discard block  | 
                                                    ||
| 170 | 173 | |
| 171 | 174 | // First, we check if the listener has been cached. If it has, we will load the classes/enums/interfaces  | 
                                                        
| 172 | 175 | // from the cache.  | 
                                                        
| 173 | -        foreach ($listeners as $i => $listener) { | 
                                                        |
| 174 | -            if ($loader($listener)) { | 
                                                        |
| 176 | + foreach ($listeners as $i => $listener)  | 
                                                        |
| 177 | +        { | 
                                                        |
| 178 | + if ($loader($listener))  | 
                                                        |
| 179 | +            { | 
                                                        |
| 175 | 180 | unset($listeners[$i]);  | 
                                                        
| 176 | 181 | }  | 
                                                        
| 177 | 182 | }  | 
                                                        
| 178 | 183 | |
| 179 | 184 | // If there are no listeners left, we don't need to use static analysis at all and save  | 
                                                        
| 180 | 185 | // valuable time.  | 
                                                        
| 181 | -        if ($listeners === []) { | 
                                                        |
| 186 | + if ($listeners === [])  | 
                                                        |
| 187 | +        { | 
                                                        |
| 182 | 188 | return;  | 
                                                        
| 183 | 189 | }  | 
                                                        
| 184 | 190 | |
@@ -186,14 +192,16 @@ discard block  | 
                                                    ||
| 186 | 192 | // Please note that this is a very expensive operation and should be avoided if possible.  | 
                                                        
| 187 | 193 | // Use #[TargetClass] or #[TargetAttribute] attributes in your listeners to cache the classes/enums/interfaces.  | 
                                                        
| 188 | 194 | $classes = $reflections();  | 
                                                        
| 189 | -        foreach ($listeners as $listener) { | 
                                                        |
| 195 | + foreach ($listeners as $listener)  | 
                                                        |
| 196 | +        { | 
                                                        |
| 190 | 197 | $invoker->invoke($listener, $classes);  | 
                                                        
| 191 | 198 | }  | 
                                                        
| 192 | 199 | }  | 
                                                        
| 193 | 200 | |
| 194 | 201 | private function finalizeListeners(): void  | 
                                                        
| 195 | 202 |      { | 
                                                        
| 196 | -        foreach ($this->listeners as $listener) { | 
                                                        |
| 203 | + foreach ($this->listeners as $listener)  | 
                                                        |
| 204 | +        { | 
                                                        |
| 197 | 205 | $listener->finalize();  | 
                                                        
| 198 | 206 | }  | 
                                                        
| 199 | 207 | // We don't need the listeners anymore, so we will clear them from memory.  |