@@ -33,7 +33,7 @@  | 
                                                    ||
| 33 | 33 | *  | 
                                                        
| 34 | 34 | * @return string The human representation for a given value  | 
                                                        
| 35 | 35 | */  | 
                                                        
| 36 | - public static function readableForValue(string|int $value): string;  | 
                                                        |
| 36 | + public static function readableForValue(string | int $value): string;  | 
                                                        |
| 37 | 37 | |
| 38 | 38 | /**  | 
                                                        
| 39 | 39 | * Gets the human representation for a given name.  | 
                                                        
@@ -21,7 +21,7 @@ discard block  | 
                                                    ||
| 21 | 21 | /**  | 
                                                        
| 22 | 22 |       * {@inheritdoc} | 
                                                        
| 23 | 23 | */  | 
                                                        
| 24 | - public static function readableForValue(string|int $value): string  | 
                                                        |
| 24 | + public static function readableForValue(string | int $value): string  | 
                                                        |
| 25 | 25 |      { | 
                                                        
| 26 | 26 | /** @var ReadableEnumInterface $case */  | 
                                                        
| 27 | 27 | $case = static::from($value);  | 
                                                        
@@ -38,7 +38,7 @@ discard block  | 
                                                    ||
| 38 | 38 | static $map;  | 
                                                        
| 39 | 39 | |
| 40 | 40 |          if (null === $map) { | 
                                                        
| 41 | - $map = array_combine(array_map(static fn (\UnitEnum $e) => $e->name, static::cases()), static::cases());  | 
                                                        |
| 41 | + $map = array_combine(array_map(static fn(\UnitEnum $e) => $e->name, static::cases()), static::cases());  | 
                                                        |
| 42 | 42 | }  | 
                                                        
| 43 | 43 | |
| 44 | 44 |          if (!isset($map[$name])) { | 
                                                        
@@ -125,9 +125,4 @@  | 
                                                    ||
| 125 | 125 | |
| 126 | 126 | protected function onNullFromPhp(): int|string|null  | 
                                                        
| 127 | 127 |                          { | 
                                                        
| 128 | -                            return {$defaultOnNullCode}; | 
                                                        |
| 129 | - }  | 
                                                        |
| 130 | - PHP;  | 
                                                        |
| 131 | - }  | 
                                                        |
| 132 | - }  | 
                                                        |
| 133 | -}  | 
                                                        |
| 128 | +                            return {$defaultOnNullCode} | 
                                                        |
| 134 | 129 | \ No newline at end of file  | 
                                                        
@@ -125,9 +125,4 @@  | 
                                                    ||
| 125 | 125 | |
| 126 | 126 | protected function onNullFromPhp(): int|string|null  | 
                                                        
| 127 | 127 |                          { | 
                                                        
| 128 | -                            return {$defaultOnNullCode}; | 
                                                        |
| 129 | - }  | 
                                                        |
| 130 | - PHP;  | 
                                                        |
| 131 | - }  | 
                                                        |
| 132 | - }  | 
                                                        |
| 133 | -}  | 
                                                        |
| 128 | +                            return {$defaultOnNullCode} | 
                                                        |
| 134 | 129 | \ No newline at end of file  | 
                                                        
@@ -67,7 +67,7 @@ discard block  | 
                                                    ||
| 67 | 67 | string $classname,  | 
                                                        
| 68 | 68 | string $enumClass,  | 
                                                        
| 69 | 69 | string $name,  | 
                                                        
| 70 | - \BackedEnum|int|string|null $defaultOnNull = null  | 
                                                        |
| 70 | + \BackedEnum | int | string | null $defaultOnNull = null  | 
                                                        |
| 71 | 71 |      ): string { | 
                                                        
| 72 | 72 | $code = <<<PHP  | 
                                                        
| 73 | 73 | protected function getEnumClass(): string  | 
                                                        
@@ -125,9 +125,4 @@ discard block  | 
                                                    ||
| 125 | 125 | |
| 126 | 126 | protected function onNullFromPhp(): int|string|null  | 
                                                        
| 127 | 127 |                          { | 
                                                        
| 128 | -                            return {$defaultOnNullCode}; | 
                                                        |
| 129 | - }  | 
                                                        |
| 130 | - PHP;  | 
                                                        |
| 131 | - }  | 
                                                        |
| 132 | - }  | 
                                                        |
| 133 | -}  | 
                                                        |
| 128 | +                            return {$defaultOnNullCode} | 
                                                        |
| 134 | 129 | \ No newline at end of file  | 
                                                        
@@ -125,9 +125,4 @@  | 
                                                    ||
| 125 | 125 | |
| 126 | 126 | protected function onNullFromPhp(): int|string|null  | 
                                                        
| 127 | 127 |                          { | 
                                                        
| 128 | -                            return {$defaultOnNullCode}; | 
                                                        |
| 129 | - }  | 
                                                        |
| 130 | - PHP;  | 
                                                        |
| 131 | - }  | 
                                                        |
| 132 | - }  | 
                                                        |
| 133 | -}  | 
                                                        |
| 128 | +                            return {$defaultOnNullCode} | 
                                                        |
| 134 | 129 | \ No newline at end of file  | 
                                                        
@@ -125,9 +125,4 @@  | 
                                                    ||
| 125 | 125 | |
| 126 | 126 | protected function onNullFromPhp(): int|string|null  | 
                                                        
| 127 | 127 |                          { | 
                                                        
| 128 | -                            return {$defaultOnNullCode}; | 
                                                        |
| 129 | - }  | 
                                                        |
| 130 | - PHP;  | 
                                                        |
| 131 | - }  | 
                                                        |
| 132 | - }  | 
                                                        |
| 133 | -}  | 
                                                        |
| 128 | +                            return {$defaultOnNullCode} | 
                                                        |
| 134 | 129 | \ No newline at end of file  | 
                                                        
@@ -39,7 +39,7 @@ discard block  | 
                                                    ||
| 39 | 39 | /**  | 
                                                        
| 40 | 40 | * What should be returned on null value from PHP.  | 
                                                        
| 41 | 41 | */  | 
                                                        
| 42 | - protected function onNullFromPhp(): int|string|null  | 
                                                        |
| 42 | + protected function onNullFromPhp(): int | string | null  | 
                                                        |
| 43 | 43 |      { | 
                                                        
| 44 | 44 | return null;  | 
                                                        
| 45 | 45 | }  | 
                                                        
@@ -116,7 +116,7 @@ discard block  | 
                                                    ||
| 116 | 116 | *  | 
                                                        
| 117 | 117 | * @param int|string $value  | 
                                                        
| 118 | 118 | */  | 
                                                        
| 119 | - private function cast($value): int|string  | 
                                                        |
| 119 | + private function cast($value): int | string  | 
                                                        |
| 120 | 120 |      { | 
                                                        
| 121 | 121 | return $this->isIntBackedEnum() ? (int) $value : (string) $value;  | 
                                                        
| 122 | 122 | }  | 
                                                        
@@ -60,7 +60,7 @@ discard block  | 
                                                    ||
| 60 | 60 | /**  | 
                                                        
| 61 | 61 | * @param class-string<\BackedEnum>|\BackedEnum $enumOrType  | 
                                                        
| 62 | 62 | */  | 
                                                        
| 63 | - public static function from(string|\BackedEnum $enumOrType, \BackedEnum ...$flags): static  | 
                                                        |
| 63 | + public static function from(string | \BackedEnum $enumOrType, \BackedEnum ...$flags): static  | 
                                                        |
| 64 | 64 |      { | 
                                                        
| 65 | 65 |          if ($enumOrType instanceof \BackedEnum) { | 
                                                        
| 66 | 66 |              if ('int' !== (string) (new \ReflectionEnum($enumOrType))->getBackingType()) { | 
                                                        
@@ -77,7 +77,7 @@ discard block  | 
                                                    ||
| 77 | 77 | $type = $enumOrType;  | 
                                                        
| 78 | 78 | }  | 
                                                        
| 79 | 79 | |
| 80 | - return new static($type, static::encodeBits(array_map(static fn (\BackedEnum $flag) => $flag->value, $flags)));  | 
                                                        |
| 80 | + return new static($type, static::encodeBits(array_map(static fn(\BackedEnum $flag) => $flag->value, $flags)));  | 
                                                        |
| 81 | 81 | }  | 
                                                        
| 82 | 82 | |
| 83 | 83 | public static function accepts(string $enumType, int $value): bool  | 
                                                        
@@ -102,7 +102,7 @@ discard block  | 
                                                    ||
| 102 | 102 | return array_values(  | 
                                                        
| 103 | 103 | array_filter(  | 
                                                        
| 104 | 104 | array_map(  | 
                                                        
| 105 | - static fn ($k, $v) => $v === '1' ? (1 << $k) : null,  | 
                                                        |
| 105 | + static fn($k, $v) => $v === '1' ? (1 << $k) : null,  | 
                                                        |
| 106 | 106 | array_keys($bits),  | 
                                                        
| 107 | 107 | array_values($bits),  | 
                                                        
| 108 | 108 | )  | 
                                                        
@@ -161,7 +161,7 @@ discard block  | 
                                                    ||
| 161 | 161 | */  | 
                                                        
| 162 | 162 | public function getFlags(): array  | 
                                                        
| 163 | 163 |      { | 
                                                        
| 164 | - return array_map(fn (int $bit) => $this->type::from($bit), $this->bits);  | 
                                                        |
| 164 | + return array_map(fn(int $bit) => $this->type::from($bit), $this->bits);  | 
                                                        |
| 165 | 165 | }  | 
                                                        
| 166 | 166 | |
| 167 | 167 | /**  | 
                                                        
@@ -181,7 +181,7 @@ discard block  | 
                                                    ||
| 181 | 181 | */  | 
                                                        
| 182 | 182 | public function hasFlags(\BackedEnum ...$flags): bool  | 
                                                        
| 183 | 183 |      { | 
                                                        
| 184 | - $bits = static::encodeBits(array_map(static fn (\BackedEnum $flag) => $flag->value, $flags));  | 
                                                        |
| 184 | + $bits = static::encodeBits(array_map(static fn(\BackedEnum $flag) => $flag->value, $flags));  | 
                                                        |
| 185 | 185 | |
| 186 | 186 |          if ($flags >= 1) { | 
                                                        
| 187 | 187 | return $bits === ($bits & self::encodeBits($this->bits));  | 
                                                        
@@ -232,6 +232,6 @@ discard block  | 
                                                    ||
| 232 | 232 | */  | 
                                                        
| 233 | 233 | private function flagsToBits(\BackedEnum ...$flags): array  | 
                                                        
| 234 | 234 |      { | 
                                                        
| 235 | - return array_map(static fn (\BackedEnum $flag) => $flag->value, $flags);  | 
                                                        |
| 235 | + return array_map(static fn(\BackedEnum $flag) => $flag->value, $flags);  | 
                                                        |
| 236 | 236 | }  | 
                                                        
| 237 | 237 | }  |