Passed
Push — master ( 8e918b...ec4c7c )
by Lars
03:22
created
src/voku/helper/UTF8.php 1 patch
Spacing   +347 added lines, -348 removed lines patch added patch discarded remove patch
@@ -243,7 +243,7 @@  discard block
 block discarded – undo
243 243
             return '';
244 244
         }
245 245
 
246
-        return (string) self::substr($str, $pos, 1);
246
+        return (string)self::substr($str, $pos, 1);
247 247
     }
248 248
 
249 249
     /**
@@ -258,7 +258,7 @@  discard block
 block discarded – undo
258 258
     public static function add_bom_to_string(string $str): string
259 259
     {
260 260
         if (self::string_has_bom($str) === false) {
261
-            $str = self::bom() . $str;
261
+            $str = self::bom().$str;
262 262
         }
263 263
 
264 264
         return $str;
@@ -315,7 +315,7 @@  discard block
 block discarded – undo
315 315
             return '';
316 316
         }
317 317
 
318
-        $substrIndex = $posStart + (int) self::strlen($start, $encoding);
318
+        $substrIndex = $posStart + (int)self::strlen($start, $encoding);
319 319
         $posEnd = self::strpos($str, $end, $substrIndex, $encoding);
320 320
         if (
321 321
             $posEnd === false
@@ -325,7 +325,7 @@  discard block
 block discarded – undo
325 325
             return '';
326 326
         }
327 327
 
328
-        return (string) self::substr($str, $substrIndex, $posEnd - $substrIndex, $encoding);
328
+        return (string)self::substr($str, $substrIndex, $posEnd - $substrIndex, $encoding);
329 329
     }
330 330
 
331 331
     /**
@@ -387,7 +387,7 @@  discard block
 block discarded – undo
387 387
      */
388 388
     public static function char_at(string $str, int $index, string $encoding = 'UTF-8'): string
389 389
     {
390
-        return (string) self::substr($str, $index, 1, $encoding);
390
+        return (string)self::substr($str, $index, 1, $encoding);
391 391
     }
392 392
 
393 393
     /**
@@ -483,10 +483,10 @@  discard block
 block discarded – undo
483 483
             &&
484 484
             self::$SUPPORT['mbstring'] === false
485 485
         ) {
486
-            \trigger_error('UTF8::chr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
486
+            \trigger_error('UTF8::chr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
487 487
         }
488 488
 
489
-        $cacheKey = $code_point . $encoding;
489
+        $cacheKey = $code_point.$encoding;
490 490
         if (isset($CHAR_CACHE[$cacheKey]) === true) {
491 491
             return $CHAR_CACHE[$cacheKey];
492 492
         }
@@ -496,7 +496,7 @@  discard block
 block discarded – undo
496 496
             if (self::$CHR === null) {
497 497
                 $chrTmp = self::getData('chr');
498 498
                 if ($chrTmp) {
499
-                    self::$CHR = (array) $chrTmp;
499
+                    self::$CHR = (array)$chrTmp;
500 500
                 }
501 501
             }
502 502
 
@@ -526,11 +526,11 @@  discard block
 block discarded – undo
526 526
         if (self::$CHR === null) {
527 527
             $chrTmp = self::getData('chr');
528 528
             if ($chrTmp) {
529
-                self::$CHR = (array) $chrTmp;
529
+                self::$CHR = (array)$chrTmp;
530 530
             }
531 531
         }
532 532
 
533
-        $code_point = (int) $code_point;
533
+        $code_point = (int)$code_point;
534 534
         if ($code_point <= 0x7F) {
535 535
             /**
536 536
              * @psalm-suppress PossiblyNullArrayAccess
@@ -540,22 +540,22 @@  discard block
 block discarded – undo
540 540
             /**
541 541
              * @psalm-suppress PossiblyNullArrayAccess
542 542
              */
543
-            $chr = self::$CHR[($code_point >> 6) + 0xC0] .
543
+            $chr = self::$CHR[($code_point >> 6) + 0xC0].
544 544
                    self::$CHR[($code_point & 0x3F) + 0x80];
545 545
         } elseif ($code_point <= 0xFFFF) {
546 546
             /**
547 547
              * @psalm-suppress PossiblyNullArrayAccess
548 548
              */
549
-            $chr = self::$CHR[($code_point >> 12) + 0xE0] .
550
-                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80] .
549
+            $chr = self::$CHR[($code_point >> 12) + 0xE0].
550
+                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80].
551 551
                    self::$CHR[($code_point & 0x3F) + 0x80];
552 552
         } else {
553 553
             /**
554 554
              * @psalm-suppress PossiblyNullArrayAccess
555 555
              */
556
-            $chr = self::$CHR[($code_point >> 18) + 0xF0] .
557
-                   self::$CHR[(($code_point >> 12) & 0x3F) + 0x80] .
558
-                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80] .
556
+            $chr = self::$CHR[($code_point >> 18) + 0xF0].
557
+                   self::$CHR[(($code_point >> 12) & 0x3F) + 0x80].
558
+                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80].
559 559
                    self::$CHR[($code_point & 0x3F) + 0x80];
560 560
         }
561 561
 
@@ -607,7 +607,7 @@  discard block
 block discarded – undo
607 607
 
608 608
         if (self::$SUPPORT['mbstring_func_overload'] === true) {
609 609
             return \array_map(
610
-                static function (string $data): int {
610
+                static function(string $data): int {
611 611
                     return self::strlen_in_byte($data);
612 612
                 },
613 613
                 $strSplit
@@ -674,7 +674,7 @@  discard block
 block discarded – undo
674 674
             $char = '';
675 675
         }
676 676
 
677
-        return self::int_to_hex(self::ord((string) $char), $pfix);
677
+        return self::int_to_hex(self::ord((string)$char), $pfix);
678 678
     }
679 679
 
680 680
     /**
@@ -748,7 +748,7 @@  discard block
 block discarded – undo
748 748
         | ( [\x80-\xBF] )                 # invalid byte in range 10000000 - 10111111
749 749
         | ( [\xC0-\xFF] )                 # invalid byte in range 11000000 - 11111111
750 750
         /x';
751
-        $str = (string) \preg_replace($regx, '$1', $str);
751
+        $str = (string)\preg_replace($regx, '$1', $str);
752 752
 
753 753
         if ($replace_diamond_question_mark === true) {
754 754
             $str = self::replace_diamond_question_mark($str, '');
@@ -783,7 +783,7 @@  discard block
 block discarded – undo
783 783
     public static function cleanup($str): string
784 784
     {
785 785
         // init
786
-        $str = (string) $str;
786
+        $str = (string)$str;
787 787
 
788 788
         if ($str === '') {
789 789
             return '';
@@ -892,7 +892,7 @@  discard block
 block discarded – undo
892 892
      */
893 893
     public static function css_stripe_media_queries(string $str): string
894 894
     {
895
-        return (string) \preg_replace(
895
+        return (string)\preg_replace(
896 896
             '#@media\\s+(?:only\\s)?(?:[\\s{\\(]|screen|all)\\s?[^{]+{.*}\\s*}\\s*#misU',
897 897
             '',
898 898
             $str
@@ -919,7 +919,7 @@  discard block
 block discarded – undo
919 919
      */
920 920
     public static function decimal_to_chr($int): string
921 921
     {
922
-        return self::html_entity_decode('&#' . $int . ';', \ENT_QUOTES | \ENT_HTML5);
922
+        return self::html_entity_decode('&#'.$int.';', \ENT_QUOTES | \ENT_HTML5);
923 923
     }
924 924
 
925 925
     /**
@@ -996,7 +996,7 @@  discard block
 block discarded – undo
996 996
         if ($toEncoding === 'JSON') {
997 997
             $return = self::json_encode($str);
998 998
             if ($return === false) {
999
-                throw new \InvalidArgumentException('The input string [' . $str . '] can not be used for json_encode().');
999
+                throw new \InvalidArgumentException('The input string ['.$str.'] can not be used for json_encode().');
1000 1000
             }
1001 1001
 
1002 1002
             return $return;
@@ -1082,7 +1082,7 @@  discard block
 block discarded – undo
1082 1082
             &&
1083 1083
             self::$SUPPORT['mbstring'] === false
1084 1084
         ) {
1085
-            \trigger_error('UTF8::encode() without mbstring cannot handle "' . $toEncoding . '" encoding', \E_USER_WARNING);
1085
+            \trigger_error('UTF8::encode() without mbstring cannot handle "'.$toEncoding.'" encoding', \E_USER_WARNING);
1086 1086
         }
1087 1087
 
1088 1088
         if (!isset(self::$SUPPORT['already_checked_via_portable_utf8'])) {
@@ -1171,18 +1171,18 @@  discard block
 block discarded – undo
1171 1171
         $trimChars = "\t\r\n -_()!~?=+/*\\,.:;\"'[]{}`&";
1172 1172
 
1173 1173
         if ($length === null) {
1174
-            $length = (int) \round((int) self::strlen($str, $encoding) / 2, 0);
1174
+            $length = (int)\round((int)self::strlen($str, $encoding) / 2, 0);
1175 1175
         }
1176 1176
 
1177 1177
         if (empty($search)) {
1178 1178
             if ($length > 0) {
1179
-                $stringLength = (int) self::strlen($str, $encoding);
1179
+                $stringLength = (int)self::strlen($str, $encoding);
1180 1180
                 $end = ($length - 1) > $stringLength ? $stringLength : ($length - 1);
1181 1181
             } else {
1182 1182
                 $end = 0;
1183 1183
             }
1184 1184
 
1185
-            $pos = (int) \min(
1185
+            $pos = (int)\min(
1186 1186
                 self::strpos($str, ' ', $end, $encoding),
1187 1187
                 self::strpos($str, '.', $end, $encoding)
1188 1188
             );
@@ -1193,20 +1193,20 @@  discard block
 block discarded – undo
1193 1193
                     return '';
1194 1194
                 }
1195 1195
 
1196
-                return \rtrim($strSub, $trimChars) . $replacerForSkippedText;
1196
+                return \rtrim($strSub, $trimChars).$replacerForSkippedText;
1197 1197
             }
1198 1198
 
1199 1199
             return $str;
1200 1200
         }
1201 1201
 
1202
-        $wordPos = (int) self::stripos($str, $search, 0, $encoding);
1203
-        $halfSide = (int) ($wordPos - $length / 2 + (int) self::strlen($search, $encoding) / 2);
1202
+        $wordPos = (int)self::stripos($str, $search, 0, $encoding);
1203
+        $halfSide = (int)($wordPos - $length / 2 + (int)self::strlen($search, $encoding) / 2);
1204 1204
 
1205 1205
         $pos_start = 0;
1206 1206
         if ($halfSide > 0) {
1207 1207
             $halfText = self::substr($str, 0, $halfSide, $encoding);
1208 1208
             if ($halfText !== false) {
1209
-                $pos_start = (int) \max(
1209
+                $pos_start = (int)\max(
1210 1210
                     self::strrpos($halfText, ' ', 0, $encoding),
1211 1211
                     self::strrpos($halfText, '.', 0, $encoding)
1212 1212
                 );
@@ -1215,35 +1215,35 @@  discard block
 block discarded – undo
1215 1215
 
1216 1216
         if ($wordPos && $halfSide > 0) {
1217 1217
             $offset = $pos_start + $length - 1;
1218
-            $realLength = (int) self::strlen($str, $encoding);
1218
+            $realLength = (int)self::strlen($str, $encoding);
1219 1219
 
1220 1220
             if ($offset > $realLength) {
1221 1221
                 $offset = $realLength;
1222 1222
             }
1223 1223
 
1224
-            $pos_end = (int) \min(
1224
+            $pos_end = (int)\min(
1225 1225
                     self::strpos($str, ' ', $offset, $encoding),
1226 1226
                     self::strpos($str, '.', $offset, $encoding)
1227 1227
                 ) - $pos_start;
1228 1228
 
1229 1229
             if (!$pos_end || $pos_end <= 0) {
1230
-                $strSub = self::substr($str, $pos_start, (int) self::strlen($str), $encoding);
1230
+                $strSub = self::substr($str, $pos_start, (int)self::strlen($str), $encoding);
1231 1231
                 if ($strSub !== false) {
1232
-                    $extract = $replacerForSkippedText . \ltrim($strSub, $trimChars);
1232
+                    $extract = $replacerForSkippedText.\ltrim($strSub, $trimChars);
1233 1233
                 } else {
1234 1234
                     $extract = '';
1235 1235
                 }
1236 1236
             } else {
1237 1237
                 $strSub = self::substr($str, $pos_start, $pos_end, $encoding);
1238 1238
                 if ($strSub !== false) {
1239
-                    $extract = $replacerForSkippedText . \trim($strSub, $trimChars) . $replacerForSkippedText;
1239
+                    $extract = $replacerForSkippedText.\trim($strSub, $trimChars).$replacerForSkippedText;
1240 1240
                 } else {
1241 1241
                     $extract = '';
1242 1242
                 }
1243 1243
             }
1244 1244
         } else {
1245 1245
             $offset = $length - 1;
1246
-            $trueLength = (int) self::strlen($str, $encoding);
1246
+            $trueLength = (int)self::strlen($str, $encoding);
1247 1247
 
1248 1248
             if ($offset > $trueLength) {
1249 1249
                 $offset = $trueLength;
@@ -1257,7 +1257,7 @@  discard block
 block discarded – undo
1257 1257
             if ($pos_end) {
1258 1258
                 $strSub = self::substr($str, 0, $pos_end, $encoding);
1259 1259
                 if ($strSub !== false) {
1260
-                    $extract = \rtrim($strSub, $trimChars) . $replacerForSkippedText;
1260
+                    $extract = \rtrim($strSub, $trimChars).$replacerForSkippedText;
1261 1261
                 } else {
1262 1262
                     $extract = '';
1263 1263
                 }
@@ -1377,7 +1377,7 @@  discard block
 block discarded – undo
1377 1377
     {
1378 1378
         $file_content = \file_get_contents($file_path);
1379 1379
         if ($file_content === false) {
1380
-            throw new \RuntimeException('file_get_contents() returned false for:' . $file_path);
1380
+            throw new \RuntimeException('file_get_contents() returned false for:'.$file_path);
1381 1381
         }
1382 1382
 
1383 1383
         return self::string_has_bom($file_content);
@@ -1440,7 +1440,7 @@  discard block
 block discarded – undo
1440 1440
                     ) {
1441 1441
                         // Prevent leading combining chars
1442 1442
                         // for NFC-safe concatenations.
1443
-                        $var = $leading_combining . $var;
1443
+                        $var = $leading_combining.$var;
1444 1444
                     }
1445 1445
                 }
1446 1446
 
@@ -1674,7 +1674,7 @@  discard block
 block discarded – undo
1674 1674
             return '';
1675 1675
         }
1676 1676
 
1677
-        return (string) self::substr($str, 0, $n, $encoding);
1677
+        return (string)self::substr($str, 0, $n, $encoding);
1678 1678
     }
1679 1679
 
1680 1680
     /**
@@ -1749,7 +1749,7 @@  discard block
 block discarded – undo
1749 1749
             return $str;
1750 1750
         }
1751 1751
 
1752
-        $str = (string) $str;
1752
+        $str = (string)$str;
1753 1753
         $last = '';
1754 1754
         while ($last !== $str) {
1755 1755
             $last = $str;
@@ -1940,7 +1940,7 @@  discard block
 block discarded – undo
1940 1940
         }
1941 1941
 
1942 1942
         $str_info = \unpack('C2chars', $str_info);
1943
-        $type_code = (int) ($str_info['chars1'] . $str_info['chars2']);
1943
+        $type_code = (int)($str_info['chars1'].$str_info['chars2']);
1944 1944
 
1945 1945
         // DEBUG
1946 1946
         //var_dump($type_code);
@@ -2023,7 +2023,7 @@  discard block
 block discarded – undo
2023 2023
         // init
2024 2024
         $i = 0;
2025 2025
         $str = '';
2026
-        $maxlength = (int) self::strlen($possibleChars, $encoding);
2026
+        $maxlength = (int)self::strlen($possibleChars, $encoding);
2027 2027
 
2028 2028
         if ($maxlength === 0) {
2029 2029
             return '';
@@ -2055,16 +2055,16 @@  discard block
 block discarded – undo
2055 2055
      */
2056 2056
     public static function get_unique_string($entropyExtra = '', bool $md5 = true): string
2057 2057
     {
2058
-        $uniqueHelper = \random_int(0, \mt_getrandmax()) .
2059
-                        \session_id() .
2060
-                        ($_SERVER['REMOTE_ADDR'] ?? '') .
2061
-                        ($_SERVER['SERVER_ADDR'] ?? '') .
2058
+        $uniqueHelper = \random_int(0, \mt_getrandmax()).
2059
+                        \session_id().
2060
+                        ($_SERVER['REMOTE_ADDR'] ?? '').
2061
+                        ($_SERVER['SERVER_ADDR'] ?? '').
2062 2062
                         $entropyExtra;
2063 2063
 
2064 2064
         $uniqueString = \uniqid($uniqueHelper, true);
2065 2065
 
2066 2066
         if ($md5) {
2067
-            $uniqueString = \md5($uniqueString . $uniqueHelper);
2067
+            $uniqueString = \md5($uniqueString.$uniqueHelper);
2068 2068
         }
2069 2069
 
2070 2070
         return $uniqueString;
@@ -2134,7 +2134,7 @@  discard block
 block discarded – undo
2134 2134
     public static function hex_to_int($hexDec)
2135 2135
     {
2136 2136
         // init
2137
-        $hexDec = (string) $hexDec;
2137
+        $hexDec = (string)$hexDec;
2138 2138
 
2139 2139
         if ($hexDec === '') {
2140 2140
             return false;
@@ -2209,7 +2209,7 @@  discard block
 block discarded – undo
2209 2209
         return \implode(
2210 2210
             '',
2211 2211
             \array_map(
2212
-                static function (string $chr) use ($keepAsciiChars, $encoding): string {
2212
+                static function(string $chr) use ($keepAsciiChars, $encoding): string {
2213 2213
                     return self::single_chr_html_encode($chr, $keepAsciiChars, $encoding);
2214 2214
                 },
2215 2215
                 self::split($str)
@@ -2325,7 +2325,7 @@  discard block
 block discarded – undo
2325 2325
             &&
2326 2326
             self::$SUPPORT['mbstring'] === false
2327 2327
         ) {
2328
-            \trigger_error('UTF8::html_entity_decode() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
2328
+            \trigger_error('UTF8::html_entity_decode() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
2329 2329
         }
2330 2330
 
2331 2331
         if (!isset(self::$SUPPORT['already_checked_via_portable_utf8'])) {
@@ -2343,14 +2343,14 @@  discard block
 block discarded – undo
2343 2343
                     $encoding
2344 2344
                 );
2345 2345
             } else {
2346
-                $str = (string) \preg_replace_callback(
2346
+                $str = (string)\preg_replace_callback(
2347 2347
                     "/&#\d{2,6};/",
2348 2348
                     /**
2349 2349
                      * @param string[] $matches
2350 2350
                      *
2351 2351
                      * @return string
2352 2352
                      */
2353
-                    static function (array $matches) use ($encoding): string {
2353
+                    static function(array $matches) use ($encoding): string {
2354 2354
                         // always fallback via symfony polyfill
2355 2355
                         $returnTmp = \mb_convert_encoding($matches[0], $encoding, 'HTML-ENTITIES');
2356 2356
 
@@ -2366,7 +2366,7 @@  discard block
 block discarded – undo
2366 2366
 
2367 2367
             // decode numeric & UTF16 two byte entities
2368 2368
             $str = \html_entity_decode(
2369
-                (string) \preg_replace('/(&#(?:x0*[0-9a-f]{2,6}(?![0-9a-f;])|(?:0*\d{2,6}(?![0-9;]))))/iS', '$1;', $str),
2369
+                (string)\preg_replace('/(&#(?:x0*[0-9a-f]{2,6}(?![0-9a-f;])|(?:0*\d{2,6}(?![0-9;]))))/iS', '$1;', $str),
2370 2370
                 $flags,
2371 2371
                 $encoding
2372 2372
             );
@@ -2403,7 +2403,7 @@  discard block
 block discarded – undo
2403 2403
      */
2404 2404
     public static function html_stripe_empty_tags(string $str): string
2405 2405
     {
2406
-        return (string) \preg_replace(
2406
+        return (string)\preg_replace(
2407 2407
             "/<[^\/>]*>(([\s]?)*|)<\/[^>]*>/iu",
2408 2408
             '',
2409 2409
             $str
@@ -2692,9 +2692,9 @@  discard block
 block discarded – undo
2692 2692
     {
2693 2693
         $hex = \dechex($int);
2694 2694
 
2695
-        $hex = (\strlen($hex) < 4 ? \substr('0000' . $hex, -4) : $hex);
2695
+        $hex = (\strlen($hex) < 4 ? \substr('0000'.$hex, -4) : $hex);
2696 2696
 
2697
-        return $pfix . $hex . '';
2697
+        return $pfix.$hex.'';
2698 2698
     }
2699 2699
 
2700 2700
     /**
@@ -2935,7 +2935,7 @@  discard block
 block discarded – undo
2935 2935
             return false;
2936 2936
         }
2937 2937
 
2938
-        $base64String = (string) \base64_decode($str, true);
2938
+        $base64String = (string)\base64_decode($str, true);
2939 2939
 
2940 2940
         return $base64String && \base64_encode($base64String) === $str;
2941 2941
     }
@@ -2950,7 +2950,7 @@  discard block
 block discarded – undo
2950 2950
      */
2951 2951
     public static function is_binary($input, bool $strict = false): bool
2952 2952
     {
2953
-        $input = (string) $input;
2953
+        $input = (string)$input;
2954 2954
         if ($input === '') {
2955 2955
             return false;
2956 2956
         }
@@ -3199,7 +3199,7 @@  discard block
 block discarded – undo
3199 3199
     public static function is_utf16($str, $checkIfStringIsBinary = true)
3200 3200
     {
3201 3201
         // init
3202
-        $str = (string) $str;
3202
+        $str = (string)$str;
3203 3203
         $strChars = [];
3204 3204
 
3205 3205
         if (
@@ -3277,7 +3277,7 @@  discard block
 block discarded – undo
3277 3277
     public static function is_utf32($str, $checkIfStringIsBinary = true)
3278 3278
     {
3279 3279
         // init
3280
-        $str = (string) $str;
3280
+        $str = (string)$str;
3281 3281
         $strChars = [];
3282 3282
 
3283 3283
         if (
@@ -3401,7 +3401,7 @@  discard block
 block discarded – undo
3401 3401
             self::$ORD = self::getData('ord');
3402 3402
         }
3403 3403
 
3404
-        $len = self::strlen_in_byte((string) $str);
3404
+        $len = self::strlen_in_byte((string)$str);
3405 3405
         /** @noinspection ForeachInvariantsInspection */
3406 3406
         for ($i = 0; $i < $len; ++$i) {
3407 3407
             $in = self::$ORD[$str[$i]];
@@ -3630,17 +3630,17 @@  discard block
 block discarded – undo
3630 3630
      */
3631 3631
     public static function lcfirst(string $str, string $encoding = 'UTF-8', bool $cleanUtf8 = false, string $lang = null, bool $tryToKeepStringLength = false): string
3632 3632
     {
3633
-        $strPartTwo = (string) self::substr($str, 1, null, $encoding, $cleanUtf8);
3633
+        $strPartTwo = (string)self::substr($str, 1, null, $encoding, $cleanUtf8);
3634 3634
 
3635 3635
         $strPartOne = self::strtolower(
3636
-            (string) self::substr($str, 0, 1, $encoding, $cleanUtf8),
3636
+            (string)self::substr($str, 0, 1, $encoding, $cleanUtf8),
3637 3637
             $encoding,
3638 3638
             $cleanUtf8,
3639 3639
             $lang,
3640 3640
             $tryToKeepStringLength
3641 3641
         );
3642 3642
 
3643
-        return $strPartOne . $strPartTwo;
3643
+        return $strPartOne.$strPartTwo;
3644 3644
     }
3645 3645
 
3646 3646
     /**
@@ -3796,7 +3796,7 @@  discard block
 block discarded – undo
3796 3796
     {
3797 3797
         $bytes = self::chr_size_list($str);
3798 3798
         if (\count($bytes) > 0) {
3799
-            return (int) \max($bytes);
3799
+            return (int)\max($bytes);
3800 3800
         }
3801 3801
 
3802 3802
         return 0;
@@ -3871,7 +3871,7 @@  discard block
 block discarded – undo
3871 3871
         static $STATIC_NORMALIZE_ENCODING_CACHE = [];
3872 3872
 
3873 3873
         // init
3874
-        $encoding = (string) $encoding;
3874
+        $encoding = (string)$encoding;
3875 3875
 
3876 3876
         if (
3877 3877
             !$encoding
@@ -3923,7 +3923,7 @@  discard block
 block discarded – undo
3923 3923
 
3924 3924
         $encodingOrig = $encoding;
3925 3925
         $encoding = \strtoupper($encoding);
3926
-        $encodingUpperHelper = (string) \preg_replace('/[^a-zA-Z0-9\s]/', '', $encoding);
3926
+        $encodingUpperHelper = (string)\preg_replace('/[^a-zA-Z0-9\s]/', '', $encoding);
3927 3927
 
3928 3928
         $equivalences = [
3929 3929
             'ISO8859'     => 'ISO-8859-1',
@@ -4009,7 +4009,7 @@  discard block
 block discarded – undo
4009 4009
      */
4010 4010
     public static function normalize_line_ending(string $str): string
4011 4011
     {
4012
-        return (string) \str_replace(["\r\n", "\r"], "\n", $str);
4012
+        return (string)\str_replace(["\r\n", "\r"], "\n", $str);
4013 4013
     }
4014 4014
 
4015 4015
     /**
@@ -4057,7 +4057,7 @@  discard block
 block discarded – undo
4057 4057
         }
4058 4058
 
4059 4059
         static $WHITESPACE_CACHE = [];
4060
-        $cacheKey = (int) $keepNonBreakingSpace;
4060
+        $cacheKey = (int)$keepNonBreakingSpace;
4061 4061
 
4062 4062
         if (!isset($WHITESPACE_CACHE[$cacheKey])) {
4063 4063
             $WHITESPACE_CACHE[$cacheKey] = self::$WHITESPACE_TABLE;
@@ -4097,7 +4097,7 @@  discard block
 block discarded – undo
4097 4097
     public static function ord($chr, string $encoding = 'UTF-8'): int
4098 4098
     {
4099 4099
         // init
4100
-        $chr = (string) $chr;
4100
+        $chr = (string)$chr;
4101 4101
 
4102 4102
         static $CHAR_CACHE = [];
4103 4103
 
@@ -4108,7 +4108,7 @@  discard block
 block discarded – undo
4108 4108
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
4109 4109
         }
4110 4110
 
4111
-        $cacheKey = $chr_orig . $encoding;
4111
+        $cacheKey = $chr_orig.$encoding;
4112 4112
         if (isset($CHAR_CACHE[$cacheKey]) === true) {
4113 4113
             return $CHAR_CACHE[$cacheKey];
4114 4114
         }
@@ -4139,22 +4139,22 @@  discard block
 block discarded – undo
4139 4139
         }
4140 4140
 
4141 4141
         /** @noinspection CallableParameterUseCaseInTypeContextInspection */
4142
-        $chr = \unpack('C*', (string) self::substr($chr, 0, 4, 'CP850'));
4142
+        $chr = \unpack('C*', (string)self::substr($chr, 0, 4, 'CP850'));
4143 4143
         $code = $chr ? $chr[1] : 0;
4144 4144
 
4145 4145
         if ($code >= 0xF0 && isset($chr[4])) {
4146 4146
             /** @noinspection UnnecessaryCastingInspection */
4147
-            return $CHAR_CACHE[$cacheKey] = (int) ((($code - 0xF0) << 18) + (($chr[2] - 0x80) << 12) + (($chr[3] - 0x80) << 6) + $chr[4] - 0x80);
4147
+            return $CHAR_CACHE[$cacheKey] = (int)((($code - 0xF0) << 18) + (($chr[2] - 0x80) << 12) + (($chr[3] - 0x80) << 6) + $chr[4] - 0x80);
4148 4148
         }
4149 4149
 
4150 4150
         if ($code >= 0xE0 && isset($chr[3])) {
4151 4151
             /** @noinspection UnnecessaryCastingInspection */
4152
-            return $CHAR_CACHE[$cacheKey] = (int) ((($code - 0xE0) << 12) + (($chr[2] - 0x80) << 6) + $chr[3] - 0x80);
4152
+            return $CHAR_CACHE[$cacheKey] = (int)((($code - 0xE0) << 12) + (($chr[2] - 0x80) << 6) + $chr[3] - 0x80);
4153 4153
         }
4154 4154
 
4155 4155
         if ($code >= 0xC0 && isset($chr[2])) {
4156 4156
             /** @noinspection UnnecessaryCastingInspection */
4157
-            return $CHAR_CACHE[$cacheKey] = (int) ((($code - 0xC0) << 6) + $chr[2] - 0x80);
4157
+            return $CHAR_CACHE[$cacheKey] = (int)((($code - 0xC0) << 6) + $chr[2] - 0x80);
4158 4158
         }
4159 4159
 
4160 4160
         return $CHAR_CACHE[$cacheKey] = $code;
@@ -4207,7 +4207,7 @@  discard block
 block discarded – undo
4207 4207
     public static function pcre_utf8_support(): bool
4208 4208
     {
4209 4209
         /** @noinspection PhpUsageOfSilenceOperatorInspection */
4210
-        return (bool) @\preg_match('//u', '');
4210
+        return (bool)@\preg_match('//u', '');
4211 4211
     }
4212 4212
 
4213 4213
     /**
@@ -4233,10 +4233,10 @@  discard block
 block discarded – undo
4233 4233
         }
4234 4234
 
4235 4235
         /** @noinspection PhpComposerExtensionStubsInspection */
4236
-        if (\ctype_digit((string) $var1)) {
4237
-            $start = (int) $var1;
4236
+        if (\ctype_digit((string)$var1)) {
4237
+            $start = (int)$var1;
4238 4238
         } /** @noinspection PhpComposerExtensionStubsInspection */ elseif (\ctype_xdigit($var1)) {
4239
-            $start = (int) self::hex_to_int($var1);
4239
+            $start = (int)self::hex_to_int($var1);
4240 4240
         } else {
4241 4241
             $start = self::ord($var1);
4242 4242
         }
@@ -4246,10 +4246,10 @@  discard block
 block discarded – undo
4246 4246
         }
4247 4247
 
4248 4248
         /** @noinspection PhpComposerExtensionStubsInspection */
4249
-        if (\ctype_digit((string) $var2)) {
4250
-            $end = (int) $var2;
4249
+        if (\ctype_digit((string)$var2)) {
4250
+            $end = (int)$var2;
4251 4251
         } /** @noinspection PhpComposerExtensionStubsInspection */ elseif (\ctype_xdigit($var2)) {
4252
-            $end = (int) self::hex_to_int($var2);
4252
+            $end = (int)self::hex_to_int($var2);
4253 4253
         } else {
4254 4254
             $end = self::ord($var2);
4255 4255
         }
@@ -4259,8 +4259,8 @@  discard block
 block discarded – undo
4259 4259
         }
4260 4260
 
4261 4261
         return \array_map(
4262
-            static function (int $i): string {
4263
-                return (string) self::chr($i);
4262
+            static function(int $i): string {
4263
+                return (string)self::chr($i);
4264 4264
             },
4265 4265
             \range($start, $end)
4266 4266
         );
@@ -4293,7 +4293,7 @@  discard block
 block discarded – undo
4293 4293
 
4294 4294
         $pattern = '/%u([0-9a-f]{3,4})/i';
4295 4295
         if (\preg_match($pattern, $str)) {
4296
-            $str = (string) \preg_replace($pattern, '&#x\\1;', \rawurldecode($str));
4296
+            $str = (string)\preg_replace($pattern, '&#x\\1;', \rawurldecode($str));
4297 4297
         }
4298 4298
 
4299 4299
         $flags = \ENT_QUOTES | \ENT_HTML5;
@@ -4341,8 +4341,8 @@  discard block
 block discarded – undo
4341 4341
             $delimiter = '/';
4342 4342
         }
4343 4343
 
4344
-        return (string) \preg_replace(
4345
-            $delimiter . $pattern . $delimiter . 'u' . $options,
4344
+        return (string)\preg_replace(
4345
+            $delimiter.$pattern.$delimiter.'u'.$options,
4346 4346
             $replacement,
4347 4347
             $str
4348 4348
         );
@@ -4385,9 +4385,9 @@  discard block
 block discarded – undo
4385 4385
                     return '';
4386 4386
                 }
4387 4387
 
4388
-                $strLength -= (int) $bomByteLength;
4388
+                $strLength -= (int)$bomByteLength;
4389 4389
 
4390
-                $str = (string) $strTmp;
4390
+                $str = (string)$strTmp;
4391 4391
             }
4392 4392
         }
4393 4393
 
@@ -4411,7 +4411,7 @@  discard block
 block discarded – undo
4411 4411
         if (\is_array($what) === true) {
4412 4412
             /** @noinspection ForeachSourceInspection */
4413 4413
             foreach ($what as $item) {
4414
-                $str = (string) \preg_replace('/(' . \preg_quote($item, '/') . ')+/', $item, $str);
4414
+                $str = (string)\preg_replace('/('.\preg_quote($item, '/').')+/', $item, $str);
4415 4415
             }
4416 4416
         }
4417 4417
 
@@ -4443,7 +4443,7 @@  discard block
 block discarded – undo
4443 4443
      */
4444 4444
     public static function remove_html_breaks(string $str, string $replacement = ''): string
4445 4445
     {
4446
-        return (string) \preg_replace("#/\r\n|\r|\n|<br.*/?>#isU", $replacement, $str);
4446
+        return (string)\preg_replace("#/\r\n|\r|\n|<br.*/?>#isU", $replacement, $str);
4447 4447
     }
4448 4448
 
4449 4449
     /**
@@ -4474,7 +4474,7 @@  discard block
 block discarded – undo
4474 4474
         $non_displayables[] = '/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]+/S'; // 00-08, 11, 12, 14-31, 127
4475 4475
 
4476 4476
         do {
4477
-            $str = (string) \preg_replace($non_displayables, $replacement, $str, -1, $count);
4477
+            $str = (string)\preg_replace($non_displayables, $replacement, $str, -1, $count);
4478 4478
         } while ($count !== 0);
4479 4479
 
4480 4480
         return $str;
@@ -4492,9 +4492,9 @@  discard block
 block discarded – undo
4492 4492
     public static function remove_left(string $str, string $substring, string $encoding = 'UTF-8'): string
4493 4493
     {
4494 4494
         if (self::str_starts_with($str, $substring)) {
4495
-            return (string) self::substr(
4495
+            return (string)self::substr(
4496 4496
                 $str,
4497
-                (int) self::strlen($substring, $encoding),
4497
+                (int)self::strlen($substring, $encoding),
4498 4498
                 null,
4499 4499
                 $encoding
4500 4500
             );
@@ -4515,10 +4515,10 @@  discard block
 block discarded – undo
4515 4515
     public static function remove_right(string $str, string $substring, string $encoding = 'UTF-8'): string
4516 4516
     {
4517 4517
         if (self::str_ends_with($str, $substring)) {
4518
-            return (string) self::substr(
4518
+            return (string)self::substr(
4519 4519
                 $str,
4520 4520
                 0,
4521
-                (int) self::strlen($str, $encoding) - (int) self::strlen($substring, $encoding)
4521
+                (int)self::strlen($str, $encoding) - (int)self::strlen($substring, $encoding)
4522 4522
             );
4523 4523
         }
4524 4524
 
@@ -4654,7 +4654,7 @@  discard block
 block discarded – undo
4654 4654
 
4655 4655
         echo '<pre>';
4656 4656
         foreach (self::$SUPPORT as $key => &$value) {
4657
-            echo $key . ' - ' . \print_r($value, true) . "\n<br>";
4657
+            echo $key.' - '.\print_r($value, true)."\n<br>";
4658 4658
         }
4659 4659
         unset($value);
4660 4660
         echo '</pre>';
@@ -4687,7 +4687,7 @@  discard block
 block discarded – undo
4687 4687
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
4688 4688
         }
4689 4689
 
4690
-        return '&#' . self::ord($char, $encoding) . ';';
4690
+        return '&#'.self::ord($char, $encoding).';';
4691 4691
     }
4692 4692
 
4693 4693
     /**
@@ -4726,7 +4726,7 @@  discard block
 block discarded – undo
4726 4726
         }
4727 4727
 
4728 4728
         // init
4729
-        $str = (string) $str;
4729
+        $str = (string)$str;
4730 4730
 
4731 4731
         if ($str === '') {
4732 4732
             return [];
@@ -4769,7 +4769,7 @@  discard block
 block discarded – undo
4769 4769
                     ($str[$i] & "\xE0") === "\xC0"
4770 4770
                 ) {
4771 4771
                     if (($str[$i + 1] & "\xC0") === "\x80") {
4772
-                        $ret[] = $str[$i] . $str[$i + 1];
4772
+                        $ret[] = $str[$i].$str[$i + 1];
4773 4773
 
4774 4774
                         ++$i;
4775 4775
                     }
@@ -4783,7 +4783,7 @@  discard block
 block discarded – undo
4783 4783
                         &&
4784 4784
                         ($str[$i + 2] & "\xC0") === "\x80"
4785 4785
                     ) {
4786
-                        $ret[] = $str[$i] . $str[$i + 1] . $str[$i + 2];
4786
+                        $ret[] = $str[$i].$str[$i + 1].$str[$i + 2];
4787 4787
 
4788 4788
                         $i += 2;
4789 4789
                     }
@@ -4799,7 +4799,7 @@  discard block
 block discarded – undo
4799 4799
                         &&
4800 4800
                         ($str[$i + 3] & "\xC0") === "\x80"
4801 4801
                     ) {
4802
-                        $ret[] = $str[$i] . $str[$i + 1] . $str[$i + 2] . $str[$i + 3];
4802
+                        $ret[] = $str[$i].$str[$i + 1].$str[$i + 2].$str[$i + 3];
4803 4803
 
4804 4804
                         $i += 3;
4805 4805
                     }
@@ -4811,7 +4811,7 @@  discard block
 block discarded – undo
4811 4811
             $ret = \array_chunk($ret, $length);
4812 4812
 
4813 4813
             return \array_map(
4814
-                static function (array $item): string {
4814
+                static function(array $item): string {
4815 4815
                     return \implode('', $item);
4816 4816
                 },
4817 4817
                 $ret
@@ -4841,16 +4841,16 @@  discard block
 block discarded – undo
4841 4841
     public static function str_camelize(string $str, string $encoding = 'UTF-8', bool $cleanUtf8 = false, string $lang = null, bool $tryToKeepStringLength = false): string
4842 4842
     {
4843 4843
         $str = self::lcfirst(self::trim($str), $encoding, $cleanUtf8, $lang, $tryToKeepStringLength);
4844
-        $str = (string) \preg_replace('/^[-_]+/', '', $str);
4844
+        $str = (string)\preg_replace('/^[-_]+/', '', $str);
4845 4845
 
4846
-        $str = (string) \preg_replace_callback(
4846
+        $str = (string)\preg_replace_callback(
4847 4847
             '/[-_\s]+(.)?/u',
4848 4848
             /**
4849 4849
              * @param array $match
4850 4850
              *
4851 4851
              * @return string
4852 4852
              */
4853
-            static function (array $match) use ($encoding, $cleanUtf8, $lang, $tryToKeepStringLength): string {
4853
+            static function(array $match) use ($encoding, $cleanUtf8, $lang, $tryToKeepStringLength): string {
4854 4854
                 if (isset($match[1])) {
4855 4855
                     return self::strtoupper($match[1], $encoding, $cleanUtf8, $lang, $tryToKeepStringLength);
4856 4856
                 }
@@ -4860,14 +4860,14 @@  discard block
 block discarded – undo
4860 4860
             $str
4861 4861
         );
4862 4862
 
4863
-        return (string) \preg_replace_callback(
4863
+        return (string)\preg_replace_callback(
4864 4864
             '/[\d]+(.)?/u',
4865 4865
             /**
4866 4866
              * @param array $match
4867 4867
              *
4868 4868
              * @return string
4869 4869
              */
4870
-            static function (array $match) use ($encoding, $cleanUtf8, $lang, $tryToKeepStringLength): string {
4870
+            static function(array $match) use ($encoding, $cleanUtf8, $lang, $tryToKeepStringLength): string {
4871 4871
                 return self::strtoupper($match[0], $encoding, $cleanUtf8, $lang, $tryToKeepStringLength);
4872 4872
             },
4873 4873
             $str
@@ -4912,7 +4912,7 @@  discard block
 block discarded – undo
4912 4912
         // only a fallback to prevent BC in the api ...
4913 4913
         /** @psalm-suppress RedundantConditionGivenDocblockType */
4914 4914
         if ($caseSensitive !== false && $caseSensitive !== true) {
4915
-            $encoding = (string) $caseSensitive;
4915
+            $encoding = (string)$caseSensitive;
4916 4916
         }
4917 4917
 
4918 4918
         if ($caseSensitive) {
@@ -4947,7 +4947,7 @@  discard block
 block discarded – undo
4947 4947
         // only a fallback to prevent BC in the api ...
4948 4948
         /** @psalm-suppress RedundantConditionGivenDocblockType */
4949 4949
         if ($caseSensitive !== false && $caseSensitive !== true) {
4950
-            $encoding = (string) $caseSensitive;
4950
+            $encoding = (string)$caseSensitive;
4951 4951
         }
4952 4952
 
4953 4953
         foreach ($needles as &$needle) {
@@ -5029,11 +5029,11 @@  discard block
 block discarded – undo
5029 5029
     ): string {
5030 5030
         $str = self::trim($str);
5031 5031
 
5032
-        $str = (string) \preg_replace('/\B([A-Z])/u', '-\1', $str);
5032
+        $str = (string)\preg_replace('/\B([A-Z])/u', '-\1', $str);
5033 5033
 
5034 5034
         $str = self::strtolower($str, $encoding, $cleanUtf8, $lang, $tryToKeepStringLength);
5035 5035
 
5036
-        return (string) \preg_replace('/[-_\s]+/u', $delimiter, $str);
5036
+        return (string)\preg_replace('/[-_\s]+/u', $delimiter, $str);
5037 5037
     }
5038 5038
 
5039 5039
     /**
@@ -5048,7 +5048,7 @@  discard block
 block discarded – undo
5048 5048
     public static function str_detect_encoding($str)
5049 5049
     {
5050 5050
         // init
5051
-        $str = (string) $str;
5051
+        $str = (string)$str;
5052 5052
 
5053 5053
         //
5054 5054
         // 1.) check binary strings (010001001...) like UTF-16 / UTF-32 / PDF / Images / ...
@@ -5154,7 +5154,7 @@  discard block
 block discarded – undo
5154 5154
         foreach (self::$ENCODINGS as $encodingTmp) {
5155 5155
             // INFO: //IGNORE but still throw notice
5156 5156
             /** @noinspection PhpUsageOfSilenceOperatorInspection */
5157
-            if ((string) @\iconv($encodingTmp, $encodingTmp . '//IGNORE', $str) === $str) {
5157
+            if ((string)@\iconv($encodingTmp, $encodingTmp.'//IGNORE', $str) === $str) {
5158 5158
                 return $encodingTmp;
5159 5159
             }
5160 5160
         }
@@ -5216,7 +5216,7 @@  discard block
 block discarded – undo
5216 5216
     public static function str_ensure_left(string $str, string $substring): string
5217 5217
     {
5218 5218
         if (!self::str_starts_with($str, $substring)) {
5219
-            $str = $substring . $str;
5219
+            $str = $substring.$str;
5220 5220
         }
5221 5221
 
5222 5222
         return $str;
@@ -5412,15 +5412,15 @@  discard block
 block discarded – undo
5412 5412
      */
5413 5413
     public static function str_insert(string $str, string $substring, int $index, string $encoding = 'UTF-8'): string
5414 5414
     {
5415
-        $len = (int) self::strlen($str, $encoding);
5415
+        $len = (int)self::strlen($str, $encoding);
5416 5416
 
5417 5417
         if ($index > $len) {
5418 5418
             return $str;
5419 5419
         }
5420 5420
 
5421
-        return (string) self::substr($str, 0, $index, $encoding) .
5422
-               $substring .
5423
-               (string) self::substr($str, $index, $len, $encoding);
5421
+        return (string)self::substr($str, 0, $index, $encoding).
5422
+               $substring.
5423
+               (string)self::substr($str, $index, $len, $encoding);
5424 5424
     }
5425 5425
 
5426 5426
     /**
@@ -5450,15 +5450,15 @@  discard block
 block discarded – undo
5450 5450
      */
5451 5451
     public static function str_ireplace($search, $replace, $subject, &$count = null)
5452 5452
     {
5453
-        $search = (array) $search;
5453
+        $search = (array)$search;
5454 5454
 
5455 5455
         /** @noinspection AlterInForeachInspection */
5456 5456
         foreach ($search as &$s) {
5457
-            $s = (string) $s;
5457
+            $s = (string)$s;
5458 5458
             if ($s === '') {
5459 5459
                 $s = '/^(?<=.)$/';
5460 5460
             } else {
5461
-                $s = '/' . \preg_quote($s, '/') . '/ui';
5461
+                $s = '/'.\preg_quote($s, '/').'/ui';
5462 5462
             }
5463 5463
         }
5464 5464
 
@@ -5490,11 +5490,11 @@  discard block
 block discarded – undo
5490 5490
         }
5491 5491
 
5492 5492
         if ($search === '') {
5493
-            return $str . $replacement;
5493
+            return $str.$replacement;
5494 5494
         }
5495 5495
 
5496 5496
         if (\stripos($str, $search) === 0) {
5497
-            return $replacement . \substr($str, \strlen($search));
5497
+            return $replacement.\substr($str, \strlen($search));
5498 5498
         }
5499 5499
 
5500 5500
         return $str;
@@ -5522,11 +5522,11 @@  discard block
 block discarded – undo
5522 5522
         }
5523 5523
 
5524 5524
         if ($search === '') {
5525
-            return $str . $replacement;
5525
+            return $str.$replacement;
5526 5526
         }
5527 5527
 
5528 5528
         if (\stripos($str, $search, \strlen($str) - \strlen($search)) !== false) {
5529
-            $str = \substr($str, 0, -\strlen($search)) . $replacement;
5529
+            $str = \substr($str, 0, -\strlen($search)).$replacement;
5530 5530
         }
5531 5531
 
5532 5532
         return $str;
@@ -5602,9 +5602,9 @@  discard block
 block discarded – undo
5602 5602
             return '';
5603 5603
         }
5604 5604
 
5605
-        return (string) self::substr(
5605
+        return (string)self::substr(
5606 5606
             $str,
5607
-            $offset + (int) self::strlen($separator, $encoding),
5607
+            $offset + (int)self::strlen($separator, $encoding),
5608 5608
             null,
5609 5609
             $encoding
5610 5610
         );
@@ -5634,9 +5634,9 @@  discard block
 block discarded – undo
5634 5634
             return '';
5635 5635
         }
5636 5636
 
5637
-        return (string) self::substr(
5637
+        return (string)self::substr(
5638 5638
             $str,
5639
-            $offset + (int) self::strlen($separator, $encoding),
5639
+            $offset + (int)self::strlen($separator, $encoding),
5640 5640
             null,
5641 5641
             $encoding
5642 5642
         );
@@ -5666,7 +5666,7 @@  discard block
 block discarded – undo
5666 5666
             return '';
5667 5667
         }
5668 5668
 
5669
-        return (string) self::substr($str, 0, $offset, $encoding);
5669
+        return (string)self::substr($str, 0, $offset, $encoding);
5670 5670
     }
5671 5671
 
5672 5672
     /**
@@ -5693,7 +5693,7 @@  discard block
 block discarded – undo
5693 5693
             return '';
5694 5694
         }
5695 5695
 
5696
-        return (string) self::substr($str, 0, $offset, $encoding);
5696
+        return (string)self::substr($str, 0, $offset, $encoding);
5697 5697
     }
5698 5698
 
5699 5699
     /**
@@ -5772,7 +5772,7 @@  discard block
 block discarded – undo
5772 5772
             return '';
5773 5773
         }
5774 5774
 
5775
-        return (string) self::substr($str, -$n, null, $encoding);
5775
+        return (string)self::substr($str, -$n, null, $encoding);
5776 5776
     }
5777 5777
 
5778 5778
     /**
@@ -5795,11 +5795,11 @@  discard block
 block discarded – undo
5795 5795
             return '';
5796 5796
         }
5797 5797
 
5798
-        if ((int) self::strlen($str, $encoding) <= $length) {
5798
+        if ((int)self::strlen($str, $encoding) <= $length) {
5799 5799
             return $str;
5800 5800
         }
5801 5801
 
5802
-        return (string) self::substr($str, 0, $length - (int) self::strlen($strAddOn), $encoding) . $strAddOn;
5802
+        return (string)self::substr($str, 0, $length - (int)self::strlen($strAddOn), $encoding).$strAddOn;
5803 5803
     }
5804 5804
 
5805 5805
     /**
@@ -5822,17 +5822,17 @@  discard block
 block discarded – undo
5822 5822
             return '';
5823 5823
         }
5824 5824
 
5825
-        if ((int) self::strlen($str, $encoding) <= $length) {
5825
+        if ((int)self::strlen($str, $encoding) <= $length) {
5826 5826
             return $str;
5827 5827
         }
5828 5828
 
5829 5829
         if (self::substr($str, $length - 1, 1, $encoding) === ' ') {
5830
-            return ((string) self::substr($str, 0, $length - 1, $encoding)) . $strAddOn;
5830
+            return ((string)self::substr($str, 0, $length - 1, $encoding)).$strAddOn;
5831 5831
         }
5832 5832
 
5833 5833
         $str = self::substr($str, 0, $length, $encoding);
5834 5834
         if ($str === false) {
5835
-            return '' . $strAddOn;
5835
+            return ''.$strAddOn;
5836 5836
         }
5837 5837
 
5838 5838
         $array = \explode(' ', $str);
@@ -5840,10 +5840,10 @@  discard block
 block discarded – undo
5840 5840
         $new_str = \implode(' ', $array);
5841 5841
 
5842 5842
         if ($new_str === '') {
5843
-            return ((string) self::substr($str, 0, $length - 1, $encoding)) . $strAddOn;
5843
+            return ((string)self::substr($str, 0, $length - 1, $encoding)).$strAddOn;
5844 5844
         }
5845 5845
 
5846
-        return $new_str . $strAddOn;
5846
+        return $new_str.$strAddOn;
5847 5847
     }
5848 5848
 
5849 5849
     /**
@@ -5857,7 +5857,7 @@  discard block
 block discarded – undo
5857 5857
      */
5858 5858
     public static function str_longest_common_prefix(string $str, string $otherStr, string $encoding = 'UTF-8'): string
5859 5859
     {
5860
-        $maxLength = \min(self::strlen($str, $encoding), (int) self::strlen($otherStr, $encoding));
5860
+        $maxLength = \min(self::strlen($str, $encoding), (int)self::strlen($otherStr, $encoding));
5861 5861
 
5862 5862
         $longestCommonPrefix = '';
5863 5863
         for ($i = 0; $i < $maxLength; ++$i) {
@@ -5891,8 +5891,8 @@  discard block
 block discarded – undo
5891 5891
     {
5892 5892
         // Uses dynamic programming to solve
5893 5893
         // http://en.wikipedia.org/wiki/Longest_common_substring_problem
5894
-        $strLength = (int) self::strlen($str, $encoding);
5895
-        $otherLength = (int) self::strlen($otherStr, $encoding);
5894
+        $strLength = (int)self::strlen($str, $encoding);
5895
+        $otherLength = (int)self::strlen($otherStr, $encoding);
5896 5896
 
5897 5897
         // Return if either string is empty
5898 5898
         if ($strLength === 0 || $otherLength === 0) {
@@ -5924,7 +5924,7 @@  discard block
 block discarded – undo
5924 5924
             }
5925 5925
         }
5926 5926
 
5927
-        return (string) self::substr($str, $end - $len, $len, $encoding);
5927
+        return (string)self::substr($str, $end - $len, $len, $encoding);
5928 5928
     }
5929 5929
 
5930 5930
     /**
@@ -5938,7 +5938,7 @@  discard block
 block discarded – undo
5938 5938
      */
5939 5939
     public static function str_longest_common_suffix(string $str, string $otherStr, string $encoding = 'UTF-8'): string
5940 5940
     {
5941
-        $maxLength = \min(self::strlen($str, $encoding), (int) self::strlen($otherStr, $encoding));
5941
+        $maxLength = \min(self::strlen($str, $encoding), (int)self::strlen($otherStr, $encoding));
5942 5942
 
5943 5943
         $longestCommonSuffix = '';
5944 5944
         for ($i = 1; $i <= $maxLength; ++$i) {
@@ -5949,7 +5949,7 @@  discard block
 block discarded – undo
5949 5949
                 &&
5950 5950
                 $char === self::substr($otherStr, -$i, 1, $encoding)
5951 5951
             ) {
5952
-                $longestCommonSuffix = $char . $longestCommonSuffix;
5952
+                $longestCommonSuffix = $char.$longestCommonSuffix;
5953 5953
             } else {
5954 5954
                 break;
5955 5955
             }
@@ -5968,7 +5968,7 @@  discard block
 block discarded – undo
5968 5968
      */
5969 5969
     public static function str_matches_pattern(string $str, string $pattern): bool
5970 5970
     {
5971
-        return (bool) \preg_match('/' . $pattern . '/u', $str);
5971
+        return (bool)\preg_match('/'.$pattern.'/u', $str);
5972 5972
     }
5973 5973
 
5974 5974
     /**
@@ -5985,7 +5985,7 @@  discard block
 block discarded – undo
5985 5985
     public static function str_offset_exists(string $str, int $offset, string $encoding = 'UTF-8'): bool
5986 5986
     {
5987 5987
         // init
5988
-        $length = (int) self::strlen($str, $encoding);
5988
+        $length = (int)self::strlen($str, $encoding);
5989 5989
 
5990 5990
         if ($offset >= 0) {
5991 5991
             return $length > $offset;
@@ -6011,7 +6011,7 @@  discard block
 block discarded – undo
6011 6011
     public static function str_offset_get(string $str, int $index, string $encoding = 'UTF-8'): string
6012 6012
     {
6013 6013
         // init
6014
-        $length = (int) self::strlen($str);
6014
+        $length = (int)self::strlen($str);
6015 6015
 
6016 6016
         if (
6017 6017
             ($index >= 0 && $length <= $index)
@@ -6045,7 +6045,7 @@  discard block
 block discarded – undo
6045 6045
             return '';
6046 6046
         }
6047 6047
 
6048
-        if ($pad_type !== (int) $pad_type) {
6048
+        if ($pad_type !== (int)$pad_type) {
6049 6049
             if ($pad_type === 'left') {
6050 6050
                 $pad_type = \STR_PAD_LEFT;
6051 6051
             } elseif ($pad_type === 'right') {
@@ -6054,46 +6054,46 @@  discard block
 block discarded – undo
6054 6054
                 $pad_type = \STR_PAD_BOTH;
6055 6055
             } else {
6056 6056
                 throw new \InvalidArgumentException(
6057
-                    'Pad expects $padType to be "STR_PAD_*" or ' . "to be one of 'left', 'right' or 'both'"
6057
+                    'Pad expects $padType to be "STR_PAD_*" or '."to be one of 'left', 'right' or 'both'"
6058 6058
                 );
6059 6059
             }
6060 6060
         }
6061 6061
 
6062
-        $str_length = (int) self::strlen($str, $encoding);
6062
+        $str_length = (int)self::strlen($str, $encoding);
6063 6063
 
6064 6064
         if (
6065 6065
             $pad_length > 0
6066 6066
             &&
6067 6067
             $pad_length >= $str_length
6068 6068
         ) {
6069
-            $ps_length = (int) self::strlen($pad_string, $encoding);
6069
+            $ps_length = (int)self::strlen($pad_string, $encoding);
6070 6070
 
6071 6071
             $diff = ($pad_length - $str_length);
6072 6072
 
6073 6073
             switch ($pad_type) {
6074 6074
                 case \STR_PAD_LEFT:
6075
-                    $pre = \str_repeat($pad_string, (int) \ceil($diff / $ps_length));
6076
-                    $pre = (string) self::substr($pre, 0, $diff, $encoding);
6075
+                    $pre = \str_repeat($pad_string, (int)\ceil($diff / $ps_length));
6076
+                    $pre = (string)self::substr($pre, 0, $diff, $encoding);
6077 6077
                     $post = '';
6078 6078
 
6079 6079
                     break;
6080 6080
 
6081 6081
                 case \STR_PAD_BOTH:
6082
-                    $pre = \str_repeat($pad_string, (int) \ceil($diff / $ps_length / 2));
6083
-                    $pre = (string) self::substr($pre, 0, (int) \floor($diff / 2), $encoding);
6084
-                    $post = \str_repeat($pad_string, (int) \ceil($diff / $ps_length / 2));
6085
-                    $post = (string) self::substr($post, 0, (int) \ceil($diff / 2), $encoding);
6082
+                    $pre = \str_repeat($pad_string, (int)\ceil($diff / $ps_length / 2));
6083
+                    $pre = (string)self::substr($pre, 0, (int)\floor($diff / 2), $encoding);
6084
+                    $post = \str_repeat($pad_string, (int)\ceil($diff / $ps_length / 2));
6085
+                    $post = (string)self::substr($post, 0, (int)\ceil($diff / 2), $encoding);
6086 6086
 
6087 6087
                     break;
6088 6088
 
6089 6089
                 case \STR_PAD_RIGHT:
6090 6090
                 default:
6091
-                    $post = \str_repeat($pad_string, (int) \ceil($diff / $ps_length));
6092
-                    $post = (string) self::substr($post, 0, $diff, $encoding);
6091
+                    $post = \str_repeat($pad_string, (int)\ceil($diff / $ps_length));
6092
+                    $post = (string)self::substr($post, 0, $diff, $encoding);
6093 6093
                     $pre = '';
6094 6094
             }
6095 6095
 
6096
-            return $pre . $str . $post;
6096
+            return $pre.$str.$post;
6097 6097
         }
6098 6098
 
6099 6099
         return $str;
@@ -6112,9 +6112,9 @@  discard block
 block discarded – undo
6112 6112
      */
6113 6113
     public static function str_pad_both(string $str, int $length, string $padStr = ' ', string $encoding = 'UTF-8'): string
6114 6114
     {
6115
-        $padding = $length - (int) self::strlen($str, $encoding);
6115
+        $padding = $length - (int)self::strlen($str, $encoding);
6116 6116
 
6117
-        return self::apply_padding($str, (int) \floor($padding / 2), (int) \ceil($padding / 2), $padStr, $encoding);
6117
+        return self::apply_padding($str, (int)\floor($padding / 2), (int)\ceil($padding / 2), $padStr, $encoding);
6118 6118
     }
6119 6119
 
6120 6120
     /**
@@ -6130,7 +6130,7 @@  discard block
 block discarded – undo
6130 6130
      */
6131 6131
     public static function str_pad_left(string $str, int $length, string $padStr = ' ', string $encoding = 'UTF-8'): string
6132 6132
     {
6133
-        return self::apply_padding($str, $length - (int) self::strlen($str), 0, $padStr, $encoding);
6133
+        return self::apply_padding($str, $length - (int)self::strlen($str), 0, $padStr, $encoding);
6134 6134
     }
6135 6135
 
6136 6136
     /**
@@ -6146,7 +6146,7 @@  discard block
 block discarded – undo
6146 6146
      */
6147 6147
     public static function str_pad_right(string $str, int $length, string $padStr = ' ', string $encoding = 'UTF-8'): string
6148 6148
     {
6149
-        return self::apply_padding($str, 0, $length - (int) self::strlen($str), $padStr, $encoding);
6149
+        return self::apply_padding($str, 0, $length - (int)self::strlen($str), $padStr, $encoding);
6150 6150
     }
6151 6151
 
6152 6152
     /**
@@ -6231,11 +6231,11 @@  discard block
 block discarded – undo
6231 6231
         }
6232 6232
 
6233 6233
         if ($search === '') {
6234
-            return $str . $replacement;
6234
+            return $str.$replacement;
6235 6235
         }
6236 6236
 
6237 6237
         if (\strpos($str, $search) === 0) {
6238
-            return $replacement . \substr($str, \strlen($search));
6238
+            return $replacement.\substr($str, \strlen($search));
6239 6239
         }
6240 6240
 
6241 6241
         return $str;
@@ -6263,11 +6263,11 @@  discard block
 block discarded – undo
6263 6263
         }
6264 6264
 
6265 6265
         if ($search === '') {
6266
-            return $str . $replacement;
6266
+            return $str.$replacement;
6267 6267
         }
6268 6268
 
6269 6269
         if (\strpos($str, $search, \strlen($str) - \strlen($search)) !== false) {
6270
-            $str = \substr($str, 0, -\strlen($search)) . $replacement;
6270
+            $str = \substr($str, 0, -\strlen($search)).$replacement;
6271 6271
         }
6272 6272
 
6273 6273
         return $str;
@@ -6289,7 +6289,7 @@  discard block
 block discarded – undo
6289 6289
         $pos = self::strpos($subject, $search);
6290 6290
         if ($pos !== false) {
6291 6291
             /** @psalm-suppress InvalidReturnStatement */
6292
-            return self::substr_replace($subject, $replace, $pos, (int) self::strlen($search));
6292
+            return self::substr_replace($subject, $replace, $pos, (int)self::strlen($search));
6293 6293
         }
6294 6294
 
6295 6295
         return $subject;
@@ -6311,7 +6311,7 @@  discard block
 block discarded – undo
6311 6311
         $pos = self::strrpos($subject, $search);
6312 6312
         if ($pos !== false) {
6313 6313
             /** @psalm-suppress InvalidReturnStatement */
6314
-            return self::substr_replace($subject, $replace, $pos, (int) self::strlen($search));
6314
+            return self::substr_replace($subject, $replace, $pos, (int)self::strlen($search));
6315 6315
         }
6316 6316
 
6317 6317
         return $subject;
@@ -6328,7 +6328,7 @@  discard block
 block discarded – undo
6328 6328
      */
6329 6329
     public static function str_shuffle(string $str): string
6330 6330
     {
6331
-        $indexes = \range(0, (int) self::strlen($str) - 1);
6331
+        $indexes = \range(0, (int)self::strlen($str) - 1);
6332 6332
         /** @noinspection NonSecureShuffleUsageInspection */
6333 6333
         \shuffle($indexes);
6334 6334
 
@@ -6361,11 +6361,11 @@  discard block
 block discarded – undo
6361 6361
     public static function str_slice(string $str, int $start, int $end = null, string $encoding = 'UTF-8')
6362 6362
     {
6363 6363
         if ($end === null) {
6364
-            $length = (int) self::strlen($str);
6364
+            $length = (int)self::strlen($str);
6365 6365
         } elseif ($end >= 0 && $end <= $start) {
6366 6366
             return '';
6367 6367
         } elseif ($end < 0) {
6368
-            $length = (int) self::strlen($str) + $end - $start;
6368
+            $length = (int)self::strlen($str) + $end - $start;
6369 6369
         } else {
6370 6370
             $length = $end - $start;
6371 6371
         }
@@ -6386,31 +6386,31 @@  discard block
 block discarded – undo
6386 6386
         $str = self::normalize_whitespace($str);
6387 6387
         $str = \str_replace('-', '_', $str);
6388 6388
 
6389
-        $str = (string) \preg_replace_callback(
6389
+        $str = (string)\preg_replace_callback(
6390 6390
             '/([\d|A-Z])/u',
6391 6391
             /**
6392 6392
              * @param string[] $matches
6393 6393
              *
6394 6394
              * @return string
6395 6395
              */
6396
-            static function (array $matches) use ($encoding): string {
6396
+            static function(array $matches) use ($encoding): string {
6397 6397
                 $match = $matches[1];
6398
-                $matchInt = (int) $match;
6398
+                $matchInt = (int)$match;
6399 6399
 
6400
-                if ((string) $matchInt === $match) {
6401
-                    return '_' . $match . '_';
6400
+                if ((string)$matchInt === $match) {
6401
+                    return '_'.$match.'_';
6402 6402
                 }
6403 6403
 
6404
-                return '_' . self::strtolower($match, $encoding);
6404
+                return '_'.self::strtolower($match, $encoding);
6405 6405
             },
6406 6406
             $str
6407 6407
         );
6408 6408
 
6409
-        $str = (string) \preg_replace(
6409
+        $str = (string)\preg_replace(
6410 6410
             [
6411
-                '/\s+/',        // convert spaces to "_"
6412
-                '/^\s+|\s+$/',  // trim leading & trailing spaces
6413
-                '/_+/',         // remove double "_"
6411
+                '/\s+/', // convert spaces to "_"
6412
+                '/^\s+|\s+$/', // trim leading & trailing spaces
6413
+                '/_+/', // remove double "_"
6414 6414
             ],
6415 6415
             [
6416 6416
                 '_',
@@ -6497,7 +6497,7 @@  discard block
 block discarded – undo
6497 6497
             $limit = -1;
6498 6498
         }
6499 6499
 
6500
-        $array = \preg_split('/' . \preg_quote($pattern, '/') . '/u', $str, $limit);
6500
+        $array = \preg_split('/'.\preg_quote($pattern, '/').'/u', $str, $limit);
6501 6501
 
6502 6502
         if ($array === false) {
6503 6503
             return [];
@@ -6580,9 +6580,9 @@  discard block
 block discarded – undo
6580 6580
             return '';
6581 6581
         }
6582 6582
 
6583
-        return (string) self::substr(
6583
+        return (string)self::substr(
6584 6584
             $str,
6585
-            $offset + (int) self::strlen($separator, $encoding),
6585
+            $offset + (int)self::strlen($separator, $encoding),
6586 6586
             null,
6587 6587
             $encoding
6588 6588
         );
@@ -6612,9 +6612,9 @@  discard block
 block discarded – undo
6612 6612
             return '';
6613 6613
         }
6614 6614
 
6615
-        return (string) self::substr(
6615
+        return (string)self::substr(
6616 6616
             $str,
6617
-            $offset + (int) self::strlen($separator, $encoding),
6617
+            $offset + (int)self::strlen($separator, $encoding),
6618 6618
             null,
6619 6619
             $encoding
6620 6620
         );
@@ -6644,7 +6644,7 @@  discard block
 block discarded – undo
6644 6644
             return '';
6645 6645
         }
6646 6646
 
6647
-        return (string) self::substr(
6647
+        return (string)self::substr(
6648 6648
             $str,
6649 6649
             0,
6650 6650
             $offset,
@@ -6676,7 +6676,7 @@  discard block
 block discarded – undo
6676 6676
             return '';
6677 6677
         }
6678 6678
 
6679
-        return (string) self::substr(
6679
+        return (string)self::substr(
6680 6680
             $str,
6681 6681
             0,
6682 6682
             $offset,
@@ -6867,16 +6867,16 @@  discard block
 block discarded – undo
6867 6867
         }
6868 6868
 
6869 6869
         // the main substitutions
6870
-        $str = (string) \preg_replace_callback(
6870
+        $str = (string)\preg_replace_callback(
6871 6871
             '~\b (_*) (?:                                                              # 1. Leading underscore and
6872 6872
                         ( (?<=[ ][/\\\\]) [[:alpha:]]+ [-_[:alpha:]/\\\\]+ |              # 2. file path or 
6873
-                          [-_[:alpha:]]+ [@.:] [-_[:alpha:]@.:/]+ ' . $apostropheRx . ' ) #    URL, domain, or email
6873
+                          [-_[:alpha:]]+ [@.:] [-_[:alpha:]@.:/]+ ' . $apostropheRx.' ) #    URL, domain, or email
6874 6874
                         |
6875
-                        ( (?i: ' . $smallWordsRx . ' ) ' . $apostropheRx . ' )            # 3. or small word (case-insensitive)
6875
+                        ( (?i: ' . $smallWordsRx.' ) '.$apostropheRx.' )            # 3. or small word (case-insensitive)
6876 6876
                         |
6877
-                        ( [[:alpha:]] [[:lower:]\'’()\[\]{}]* ' . $apostropheRx . ' )     # 4. or word w/o internal caps
6877
+                        ( [[:alpha:]] [[:lower:]\'’()\[\]{}]* ' . $apostropheRx.' )     # 4. or word w/o internal caps
6878 6878
                         |
6879
-                        ( [[:alpha:]] [[:alpha:]\'’()\[\]{}]* ' . $apostropheRx . ' )     # 5. or some other word
6879
+                        ( [[:alpha:]] [[:alpha:]\'’()\[\]{}]* ' . $apostropheRx.' )     # 5. or some other word
6880 6880
                       ) (_*) \b                                                           # 6. With trailing underscore
6881 6881
                     ~ux',
6882 6882
             /**
@@ -6884,7 +6884,7 @@  discard block
 block discarded – undo
6884 6884
              *
6885 6885
              * @return string
6886 6886
              */
6887
-            static function (array $matches) use ($encoding): string {
6887
+            static function(array $matches) use ($encoding): string {
6888 6888
                 // preserve leading underscore
6889 6889
                 $str = $matches[1];
6890 6890
                 if ($matches[2]) {
@@ -6909,26 +6909,26 @@  discard block
 block discarded – undo
6909 6909
         );
6910 6910
 
6911 6911
         // Exceptions for small words: capitalize at start of title...
6912
-        $str = (string) \preg_replace_callback(
6912
+        $str = (string)\preg_replace_callback(
6913 6913
             '~(  \A [[:punct:]]*                # start of title...
6914 6914
                       |  [:.;?!][ ]+               # or of subsentence...
6915 6915
                       |  [ ][\'"“‘(\[][ ]* )       # or of inserted subphrase...
6916
-                      ( ' . $smallWordsRx . ' ) \b # ...followed by small word
6916
+                      ( ' . $smallWordsRx.' ) \b # ...followed by small word
6917 6917
                      ~uxi',
6918 6918
             /**
6919 6919
              * @param string[] $matches
6920 6920
              *
6921 6921
              * @return string
6922 6922
              */
6923
-            static function (array $matches) use ($encoding): string {
6924
-                return $matches[1] . static::str_upper_first($matches[2], $encoding);
6923
+            static function(array $matches) use ($encoding): string {
6924
+                return $matches[1].static::str_upper_first($matches[2], $encoding);
6925 6925
             },
6926 6926
             $str
6927 6927
         );
6928 6928
 
6929 6929
         // ...and end of title
6930
-        $str = (string) \preg_replace_callback(
6931
-            '~\b ( ' . $smallWordsRx . ' ) # small word...
6930
+        $str = (string)\preg_replace_callback(
6931
+            '~\b ( '.$smallWordsRx.' ) # small word...
6932 6932
                       (?= [[:punct:]]* \Z     # ...at the end of the title...
6933 6933
                       |   [\'"’”)\]] [ ] )    # ...or of an inserted subphrase?
6934 6934
                      ~uxi',
@@ -6937,7 +6937,7 @@  discard block
 block discarded – undo
6937 6937
              *
6938 6938
              * @return string
6939 6939
              */
6940
-            static function (array $matches) use ($encoding): string {
6940
+            static function(array $matches) use ($encoding): string {
6941 6941
                 return static::str_upper_first($matches[1], $encoding);
6942 6942
             },
6943 6943
             $str
@@ -6945,10 +6945,10 @@  discard block
 block discarded – undo
6945 6945
 
6946 6946
         // Exceptions for small words in hyphenated compound words.
6947 6947
         // e.g. "in-flight" -> In-Flight
6948
-        $str = (string) \preg_replace_callback(
6948
+        $str = (string)\preg_replace_callback(
6949 6949
             '~\b
6950 6950
                         (?<! -)                   # Negative lookbehind for a hyphen; we do not want to match man-in-the-middle but do want (in-flight)
6951
-                        ( ' . $smallWordsRx . ' )
6951
+                        ( ' . $smallWordsRx.' )
6952 6952
                         (?= -[[:alpha:]]+)        # lookahead for "-someword"
6953 6953
                        ~uxi',
6954 6954
             /**
@@ -6956,18 +6956,18 @@  discard block
 block discarded – undo
6956 6956
              *
6957 6957
              * @return string
6958 6958
              */
6959
-            static function (array $matches) use ($encoding): string {
6959
+            static function(array $matches) use ($encoding): string {
6960 6960
                 return static::str_upper_first($matches[1], $encoding);
6961 6961
             },
6962 6962
             $str
6963 6963
         );
6964 6964
 
6965 6965
         // e.g. "Stand-in" -> "Stand-In" (Stand is already capped at this point)
6966
-        $str = (string) \preg_replace_callback(
6966
+        $str = (string)\preg_replace_callback(
6967 6967
             '~\b
6968 6968
                       (?<!…)                    # Negative lookbehind for a hyphen; we do not want to match man-in-the-middle but do want (stand-in)
6969 6969
                       ( [[:alpha:]]+- )         # $1 = first word and hyphen, should already be properly capped
6970
-                      ( ' . $smallWordsRx . ' ) # ...followed by small word
6970
+                      ( ' . $smallWordsRx.' ) # ...followed by small word
6971 6971
                       (?!	- )                   # Negative lookahead for another -
6972 6972
                      ~uxi',
6973 6973
             /**
@@ -6975,8 +6975,8 @@  discard block
 block discarded – undo
6975 6975
              *
6976 6976
              * @return string
6977 6977
              */
6978
-            static function (array $matches) use ($encoding): string {
6979
-                return $matches[1] . static::str_upper_first($matches[2], $encoding);
6978
+            static function(array $matches) use ($encoding): string {
6979
+                return $matches[1].static::str_upper_first($matches[2], $encoding);
6980 6980
             },
6981 6981
             $str
6982 6982
         );
@@ -7069,7 +7069,7 @@  discard block
 block discarded – undo
7069 7069
         );
7070 7070
 
7071 7071
         foreach ($tmpReturn as &$item) {
7072
-            $item = (string) $item;
7072
+            $item = (string)$item;
7073 7073
         }
7074 7074
 
7075 7075
         return $tmpReturn;
@@ -7106,21 +7106,21 @@  discard block
 block discarded – undo
7106 7106
     public static function str_truncate($str, int $length, string $substring = '', string $encoding = 'UTF-8'): string
7107 7107
     {
7108 7108
         // init
7109
-        $str = (string) $str;
7109
+        $str = (string)$str;
7110 7110
 
7111 7111
         if ($str === '') {
7112 7112
             return '';
7113 7113
         }
7114 7114
 
7115
-        if ($length >= (int) self::strlen($str, $encoding)) {
7115
+        if ($length >= (int)self::strlen($str, $encoding)) {
7116 7116
             return $str;
7117 7117
         }
7118 7118
 
7119 7119
         // Need to further trim the string so we can append the substring
7120
-        $substringLength = (int) self::strlen($substring, $encoding);
7120
+        $substringLength = (int)self::strlen($substring, $encoding);
7121 7121
         $length -= $substringLength;
7122 7122
 
7123
-        return ((string) self::substr($str, 0, $length, $encoding)) . $substring;
7123
+        return ((string)self::substr($str, 0, $length, $encoding)).$substring;
7124 7124
     }
7125 7125
 
7126 7126
     /**
@@ -7145,12 +7145,12 @@  discard block
 block discarded – undo
7145 7145
         bool $ignoreDoNotSplitWordsForOneWord = false
7146 7146
     ): string
7147 7147
     {
7148
-        if ($length >= (int) self::strlen($str, $encoding)) {
7148
+        if ($length >= (int)self::strlen($str, $encoding)) {
7149 7149
             return $str;
7150 7150
         }
7151 7151
 
7152 7152
         // need to further trim the string so we can append the substring
7153
-        $substringLength = (int) self::strlen($substring, $encoding);
7153
+        $substringLength = (int)self::strlen($substring, $encoding);
7154 7154
         $length -= $substringLength;
7155 7155
 
7156 7156
         $truncated = self::substr($str, 0, $length, $encoding);
@@ -7169,11 +7169,11 @@  discard block
 block discarded – undo
7169 7169
                 ||
7170 7170
                 ($strPosSpace !== false && $ignoreDoNotSplitWordsForOneWord === false)
7171 7171
             ) {
7172
-                $truncated = (string) self::substr($truncated, 0, (int) $lastPos, $encoding);
7172
+                $truncated = (string)self::substr($truncated, 0, (int)$lastPos, $encoding);
7173 7173
             }
7174 7174
         }
7175 7175
 
7176
-        return $truncated . $substring;
7176
+        return $truncated.$substring;
7177 7177
     }
7178 7178
 
7179 7179
     /**
@@ -7253,13 +7253,13 @@  discard block
 block discarded – undo
7253 7253
             }
7254 7254
         } elseif ($format === 2) {
7255 7255
             $numberOfWords = [];
7256
-            $offset = (int) self::strlen($strParts[0]);
7256
+            $offset = (int)self::strlen($strParts[0]);
7257 7257
             for ($i = 1; $i < $len; $i += 2) {
7258 7258
                 $numberOfWords[$offset] = $strParts[$i];
7259
-                $offset += (int) self::strlen($strParts[$i]) + (int) self::strlen($strParts[$i + 1]);
7259
+                $offset += (int)self::strlen($strParts[$i]) + (int)self::strlen($strParts[$i + 1]);
7260 7260
             }
7261 7261
         } else {
7262
-            $numberOfWords = (int) (($len - 1) / 2);
7262
+            $numberOfWords = (int)(($len - 1) / 2);
7263 7263
         }
7264 7264
 
7265 7265
         return $numberOfWords;
@@ -7319,7 +7319,7 @@  discard block
 block discarded – undo
7319 7319
     public static function strcmp(string $str1, string $str2): int
7320 7320
     {
7321 7321
         /** @noinspection PhpUndefinedClassInspection */
7322
-        return $str1 . '' === $str2 . '' ? 0 : \strcmp(
7322
+        return $str1.'' === $str2.'' ? 0 : \strcmp(
7323 7323
             \Normalizer::normalize($str1, \Normalizer::NFD),
7324 7324
             \Normalizer::normalize($str2, \Normalizer::NFD)
7325 7325
         );
@@ -7338,12 +7338,12 @@  discard block
 block discarded – undo
7338 7338
     public static function strcspn(string $str, string $charList, int $offset = null, int $length = null): int
7339 7339
     {
7340 7340
         if ($charList === '') {
7341
-            return (int) self::strlen($str);
7341
+            return (int)self::strlen($str);
7342 7342
         }
7343 7343
 
7344 7344
         if ($offset !== null || $length !== null) {
7345 7345
             /** @noinspection UnnecessaryCastingInspection */
7346
-            $strTmp = self::substr($str, (int) $offset, $length);
7346
+            $strTmp = self::substr($str, (int)$offset, $length);
7347 7347
             if ($strTmp === false) {
7348 7348
                 return 0;
7349 7349
             }
@@ -7355,7 +7355,7 @@  discard block
 block discarded – undo
7355 7355
         }
7356 7356
 
7357 7357
         $matches = [];
7358
-        if (\preg_match('/^(.*?)' . self::rxClass($charList) . '/us', $str, $matches)) {
7358
+        if (\preg_match('/^(.*?)'.self::rxClass($charList).'/us', $str, $matches)) {
7359 7359
             $return = self::strlen($matches[1]);
7360 7360
             if ($return === false) {
7361 7361
                 return 0;
@@ -7364,7 +7364,7 @@  discard block
 block discarded – undo
7364 7364
             return $return;
7365 7365
         }
7366 7366
 
7367
-        return (int) self::strlen($str);
7367
+        return (int)self::strlen($str);
7368 7368
     }
7369 7369
 
7370 7370
     /**
@@ -7460,7 +7460,7 @@  discard block
 block discarded – undo
7460 7460
         }
7461 7461
 
7462 7462
         /** @noinspection UnnecessaryCastingInspection */
7463
-        return \strip_tags($str, (string) $allowable_tags);
7463
+        return \strip_tags($str, (string)$allowable_tags);
7464 7464
     }
7465 7465
 
7466 7466
     /**
@@ -7478,7 +7478,7 @@  discard block
 block discarded – undo
7478 7478
             return '';
7479 7479
         }
7480 7480
 
7481
-        return (string) \preg_replace('/[[:space:]]+/u', '', $str);
7481
+        return (string)\preg_replace('/[[:space:]]+/u', '', $str);
7482 7482
     }
7483 7483
 
7484 7484
     /**
@@ -7599,7 +7599,7 @@  discard block
 block discarded – undo
7599 7599
             &&
7600 7600
             self::$SUPPORT['mbstring'] === false
7601 7601
         ) {
7602
-            \trigger_error('UTF8::stristr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
7602
+            \trigger_error('UTF8::stristr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
7603 7603
         }
7604 7604
 
7605 7605
         if (self::$SUPPORT['mbstring'] === true) {
@@ -7621,7 +7621,7 @@  discard block
 block discarded – undo
7621 7621
             return \stristr($haystack, $needle, $before_needle);
7622 7622
         }
7623 7623
 
7624
-        \preg_match('/^(.*?)' . \preg_quote($needle, '/') . '/usi', $haystack, $match);
7624
+        \preg_match('/^(.*?)'.\preg_quote($needle, '/').'/usi', $haystack, $match);
7625 7625
 
7626 7626
         if (!isset($match[1])) {
7627 7627
             return false;
@@ -7631,7 +7631,7 @@  discard block
 block discarded – undo
7631 7631
             return $match[1];
7632 7632
         }
7633 7633
 
7634
-        return self::substr($haystack, (int) self::strlen($match[1]));
7634
+        return self::substr($haystack, (int)self::strlen($match[1]));
7635 7635
     }
7636 7636
 
7637 7637
     /**
@@ -7690,7 +7690,7 @@  discard block
 block discarded – undo
7690 7690
             &&
7691 7691
             self::$SUPPORT['iconv'] === false
7692 7692
         ) {
7693
-            \trigger_error('UTF8::strlen() without mbstring / iconv cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
7693
+            \trigger_error('UTF8::strlen() without mbstring / iconv cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
7694 7694
         }
7695 7695
 
7696 7696
         //
@@ -7816,7 +7816,7 @@  discard block
 block discarded – undo
7816 7816
      */
7817 7817
     public static function strnatcmp(string $str1, string $str2): int
7818 7818
     {
7819
-        return $str1 . '' === $str2 . '' ? 0 : \strnatcmp((string) self::strtonatfold($str1), (string) self::strtonatfold($str2));
7819
+        return $str1.'' === $str2.'' ? 0 : \strnatcmp((string)self::strtonatfold($str1), (string)self::strtonatfold($str2));
7820 7820
     }
7821 7821
 
7822 7822
     /**
@@ -7859,8 +7859,8 @@  discard block
 block discarded – undo
7859 7859
      */
7860 7860
     public static function strncmp(string $str1, string $str2, int $len): int
7861 7861
     {
7862
-        $str1 = (string) self::substr($str1, 0, $len);
7863
-        $str2 = (string) self::substr($str2, 0, $len);
7862
+        $str1 = (string)self::substr($str1, 0, $len);
7863
+        $str2 = (string)self::substr($str2, 0, $len);
7864 7864
 
7865 7865
         return self::strcmp($str1, $str2);
7866 7866
     }
@@ -7881,8 +7881,8 @@  discard block
 block discarded – undo
7881 7881
             return false;
7882 7882
         }
7883 7883
 
7884
-        if (\preg_match('/' . self::rxClass($char_list) . '/us', $haystack, $m)) {
7885
-            return \substr($haystack, (int) \strpos($haystack, $m[0]));
7884
+        if (\preg_match('/'.self::rxClass($char_list).'/us', $haystack, $m)) {
7885
+            return \substr($haystack, (int)\strpos($haystack, $m[0]));
7886 7886
         }
7887 7887
 
7888 7888
         return false;
@@ -7910,10 +7910,10 @@  discard block
 block discarded – undo
7910 7910
         }
7911 7911
 
7912 7912
         // iconv and mbstring do not support integer $needle
7913
-        if ((int) $needle === $needle && $needle >= 0) {
7914
-            $needle = (string) self::chr($needle);
7913
+        if ((int)$needle === $needle && $needle >= 0) {
7914
+            $needle = (string)self::chr($needle);
7915 7915
         }
7916
-        $needle = (string) $needle;
7916
+        $needle = (string)$needle;
7917 7917
 
7918 7918
         if ($needle === '') {
7919 7919
             return false;
@@ -7953,7 +7953,7 @@  discard block
 block discarded – undo
7953 7953
             &&
7954 7954
             self::$SUPPORT['mbstring'] === false
7955 7955
         ) {
7956
-            \trigger_error('UTF8::strpos() without mbstring / iconv cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
7956
+            \trigger_error('UTF8::strpos() without mbstring / iconv cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
7957 7957
         }
7958 7958
 
7959 7959
         //
@@ -8021,7 +8021,7 @@  discard block
 block discarded – undo
8021 8021
         if ($haystackTmp === false) {
8022 8022
             $haystackTmp = '';
8023 8023
         }
8024
-        $haystack = (string) $haystackTmp;
8024
+        $haystack = (string)$haystackTmp;
8025 8025
 
8026 8026
         if ($offset < 0) {
8027 8027
             $offset = 0;
@@ -8033,7 +8033,7 @@  discard block
 block discarded – undo
8033 8033
         }
8034 8034
 
8035 8035
         if ($pos) {
8036
-            return $offset + (int) self::strlen(\substr($haystack, 0, $pos), $encoding);
8036
+            return $offset + (int)self::strlen(\substr($haystack, 0, $pos), $encoding);
8037 8037
         }
8038 8038
 
8039 8039
         return $offset + 0;
@@ -8119,7 +8119,7 @@  discard block
 block discarded – undo
8119 8119
             &&
8120 8120
             self::$SUPPORT['mbstring'] === false
8121 8121
         ) {
8122
-            \trigger_error('UTF8::strrchr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
8122
+            \trigger_error('UTF8::strrchr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
8123 8123
         }
8124 8124
 
8125 8125
         if (self::$SUPPORT['mbstring'] === true) {
@@ -8151,7 +8151,7 @@  discard block
 block discarded – undo
8151 8151
             if ($needleTmp === false) {
8152 8152
                 return false;
8153 8153
             }
8154
-            $needle = (string) $needleTmp;
8154
+            $needle = (string)$needleTmp;
8155 8155
 
8156 8156
             $pos = \iconv_strrpos($haystack, $needle, $encoding);
8157 8157
             if ($pos === false) {
@@ -8173,7 +8173,7 @@  discard block
 block discarded – undo
8173 8173
         if ($needleTmp === false) {
8174 8174
             return false;
8175 8175
         }
8176
-        $needle = (string) $needleTmp;
8176
+        $needle = (string)$needleTmp;
8177 8177
 
8178 8178
         $pos = self::strrpos($haystack, $needle, 0, $encoding);
8179 8179
         if ($pos === false) {
@@ -8201,7 +8201,7 @@  discard block
 block discarded – undo
8201 8201
         }
8202 8202
 
8203 8203
         $reversed = '';
8204
-        $i = (int) self::strlen($str);
8204
+        $i = (int)self::strlen($str);
8205 8205
         while ($i--) {
8206 8206
             $reversedTmp = self::substr($str, $i, 1);
8207 8207
             if ($reversedTmp !== false) {
@@ -8269,7 +8269,7 @@  discard block
 block discarded – undo
8269 8269
         if ($needleTmp === false) {
8270 8270
             return false;
8271 8271
         }
8272
-        $needle = (string) $needleTmp;
8272
+        $needle = (string)$needleTmp;
8273 8273
 
8274 8274
         $pos = self::strripos($haystack, $needle, 0, $encoding);
8275 8275
         if ($pos === false) {
@@ -8303,10 +8303,10 @@  discard block
 block discarded – undo
8303 8303
         }
8304 8304
 
8305 8305
         // iconv and mbstring do not support integer $needle
8306
-        if ((int) $needle === $needle && $needle >= 0) {
8307
-            $needle = (string) self::chr($needle);
8306
+        if ((int)$needle === $needle && $needle >= 0) {
8307
+            $needle = (string)self::chr($needle);
8308 8308
         }
8309
-        $needle = (string) $needle;
8309
+        $needle = (string)$needle;
8310 8310
 
8311 8311
         if ($needle === '') {
8312 8312
             return false;
@@ -8343,7 +8343,7 @@  discard block
 block discarded – undo
8343 8343
             &&
8344 8344
             self::$SUPPORT['mbstring'] === false
8345 8345
         ) {
8346
-            \trigger_error('UTF8::strripos() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
8346
+            \trigger_error('UTF8::strripos() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
8347 8347
         }
8348 8348
 
8349 8349
         //
@@ -8450,10 +8450,10 @@  discard block
 block discarded – undo
8450 8450
         }
8451 8451
 
8452 8452
         // iconv and mbstring do not support integer $needle
8453
-        if ((int) $needle === $needle && $needle >= 0) {
8454
-            $needle = (string) self::chr($needle);
8453
+        if ((int)$needle === $needle && $needle >= 0) {
8454
+            $needle = (string)self::chr($needle);
8455 8455
         }
8456
-        $needle = (string) $needle;
8456
+        $needle = (string)$needle;
8457 8457
 
8458 8458
         if ($needle === '') {
8459 8459
             return false;
@@ -8490,7 +8490,7 @@  discard block
 block discarded – undo
8490 8490
             &&
8491 8491
             self::$SUPPORT['mbstring'] === false
8492 8492
         ) {
8493
-            \trigger_error('UTF8::strrpos() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
8493
+            \trigger_error('UTF8::strrpos() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
8494 8494
         }
8495 8495
 
8496 8496
         //
@@ -8550,7 +8550,7 @@  discard block
 block discarded – undo
8550 8550
             if ($haystackTmp === false) {
8551 8551
                 $haystackTmp = '';
8552 8552
             }
8553
-            $haystack = (string) $haystackTmp;
8553
+            $haystack = (string)$haystackTmp;
8554 8554
         }
8555 8555
 
8556 8556
         $pos = self::strrpos_in_byte($haystack, $needle);
@@ -8563,7 +8563,7 @@  discard block
 block discarded – undo
8563 8563
             return false;
8564 8564
         }
8565 8565
 
8566
-        return $offset + (int) self::strlen($strTmp);
8566
+        return $offset + (int)self::strlen($strTmp);
8567 8567
     }
8568 8568
 
8569 8569
     /**
@@ -8615,7 +8615,7 @@  discard block
 block discarded – undo
8615 8615
     public static function strspn(string $str, string $mask, int $offset = 0, int $length = null)
8616 8616
     {
8617 8617
         if ($offset || $length !== null) {
8618
-            $str = (string) self::substr($str, $offset, $length);
8618
+            $str = (string)self::substr($str, $offset, $length);
8619 8619
         }
8620 8620
 
8621 8621
         if ($str === '' || $mask === '') {
@@ -8624,7 +8624,7 @@  discard block
 block discarded – undo
8624 8624
 
8625 8625
         $matches = [];
8626 8626
 
8627
-        return \preg_match('/^' . self::rxClass($mask) . '+/u', $str, $matches) ? (int) self::strlen($matches[0]) : 0;
8627
+        return \preg_match('/^'.self::rxClass($mask).'+/u', $str, $matches) ? (int)self::strlen($matches[0]) : 0;
8628 8628
     }
8629 8629
 
8630 8630
     /**
@@ -8680,7 +8680,7 @@  discard block
 block discarded – undo
8680 8680
             &&
8681 8681
             self::$SUPPORT['mbstring'] === false
8682 8682
         ) {
8683
-            \trigger_error('UTF8::strstr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
8683
+            \trigger_error('UTF8::strstr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
8684 8684
         }
8685 8685
 
8686 8686
         //
@@ -8718,7 +8718,7 @@  discard block
 block discarded – undo
8718 8718
         // fallback via vanilla php
8719 8719
         //
8720 8720
 
8721
-        \preg_match('/^(.*?)' . \preg_quote($needle, '/') . '/us', $haystack, $match);
8721
+        \preg_match('/^(.*?)'.\preg_quote($needle, '/').'/us', $haystack, $match);
8722 8722
 
8723 8723
         if (!isset($match[1])) {
8724 8724
             return false;
@@ -8728,7 +8728,7 @@  discard block
 block discarded – undo
8728 8728
             return $match[1];
8729 8729
         }
8730 8730
 
8731
-        return self::substr($haystack, (int) self::strlen($match[1]));
8731
+        return self::substr($haystack, (int)self::strlen($match[1]));
8732 8732
     }
8733 8733
 
8734 8734
     /**
@@ -8827,7 +8827,7 @@  discard block
 block discarded – undo
8827 8827
     public static function strtolower($str, string $encoding = 'UTF-8', bool $cleanUtf8 = false, string $lang = null, bool $tryToKeepStringLength = false): string
8828 8828
     {
8829 8829
         // init
8830
-        $str = (string) $str;
8830
+        $str = (string)$str;
8831 8831
 
8832 8832
         if ($str === '') {
8833 8833
             return '';
@@ -8854,9 +8854,9 @@  discard block
 block discarded – undo
8854 8854
             }
8855 8855
 
8856 8856
             if (self::$SUPPORT['intl'] === true) {
8857
-                $langCode = $lang . '-Lower';
8857
+                $langCode = $lang.'-Lower';
8858 8858
                 if (!\in_array($langCode, self::$SUPPORT['intl__transliterator_list_ids'], true)) {
8859
-                    \trigger_error('UTF8::strtolower() cannot handle special language: ' . $lang, \E_USER_WARNING);
8859
+                    \trigger_error('UTF8::strtolower() cannot handle special language: '.$lang, \E_USER_WARNING);
8860 8860
 
8861 8861
                     $langCode = 'Any-Lower';
8862 8862
                 }
@@ -8865,7 +8865,7 @@  discard block
 block discarded – undo
8865 8865
                 return \transliterator_transliterate($langCode, $str);
8866 8866
             }
8867 8867
 
8868
-            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang" parameter: ' . $lang, \E_USER_WARNING);
8868
+            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang" parameter: '.$lang, \E_USER_WARNING);
8869 8869
         }
8870 8870
 
8871 8871
         // always fallback via symfony polyfill
@@ -8889,7 +8889,7 @@  discard block
 block discarded – undo
8889 8889
     public static function strtoupper($str, string $encoding = 'UTF-8', bool $cleanUtf8 = false, string $lang = null, bool $tryToKeepStringLength = false): string
8890 8890
     {
8891 8891
         // init
8892
-        $str = (string) $str;
8892
+        $str = (string)$str;
8893 8893
 
8894 8894
         if ($str === '') {
8895 8895
             return '';
@@ -8916,9 +8916,9 @@  discard block
 block discarded – undo
8916 8916
             }
8917 8917
 
8918 8918
             if (self::$SUPPORT['intl'] === true) {
8919
-                $langCode = $lang . '-Upper';
8919
+                $langCode = $lang.'-Upper';
8920 8920
                 if (!\in_array($langCode, self::$SUPPORT['intl__transliterator_list_ids'], true)) {
8921
-                    \trigger_error('UTF8::strtoupper() without intl for special language: ' . $lang, \E_USER_WARNING);
8921
+                    \trigger_error('UTF8::strtoupper() without intl for special language: '.$lang, \E_USER_WARNING);
8922 8922
 
8923 8923
                     $langCode = 'Any-Upper';
8924 8924
                 }
@@ -8927,7 +8927,7 @@  discard block
 block discarded – undo
8927 8927
                 return \transliterator_transliterate($langCode, $str);
8928 8928
             }
8929 8929
 
8930
-            \trigger_error('UTF8::strtolower() without intl + PHP >= 5.4 cannot handle the "lang"-parameter: ' . $lang, \E_USER_WARNING);
8930
+            \trigger_error('UTF8::strtolower() without intl + PHP >= 5.4 cannot handle the "lang"-parameter: '.$lang, \E_USER_WARNING);
8931 8931
         }
8932 8932
 
8933 8933
         // always fallback via symfony polyfill
@@ -8971,7 +8971,7 @@  discard block
 block discarded – undo
8971 8971
 
8972 8972
             $from = \array_combine($from, $to);
8973 8973
             if ($from === false) {
8974
-                throw new \InvalidArgumentException('The number of elements for each array isn\'t equal or the arrays are empty: (from: ' . \print_r($from, true) . ' | to: ' . \print_r($to, true) . ')');
8974
+                throw new \InvalidArgumentException('The number of elements for each array isn\'t equal or the arrays are empty: (from: '.\print_r($from, true).' | to: '.\print_r($to, true).')');
8975 8975
             }
8976 8976
         }
8977 8977
 
@@ -9028,9 +9028,9 @@  discard block
 block discarded – undo
9028 9028
         }
9029 9029
 
9030 9030
         $wide = 0;
9031
-        $str = (string) \preg_replace('/[\x{1100}-\x{115F}\x{2329}\x{232A}\x{2E80}-\x{303E}\x{3040}-\x{A4CF}\x{AC00}-\x{D7A3}\x{F900}-\x{FAFF}\x{FE10}-\x{FE19}\x{FE30}-\x{FE6F}\x{FF00}-\x{FF60}\x{FFE0}-\x{FFE6}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}]/u', '', $str, -1, $wide);
9031
+        $str = (string)\preg_replace('/[\x{1100}-\x{115F}\x{2329}\x{232A}\x{2E80}-\x{303E}\x{3040}-\x{A4CF}\x{AC00}-\x{D7A3}\x{F900}-\x{FAFF}\x{FE10}-\x{FE19}\x{FE30}-\x{FE6F}\x{FF00}-\x{FF60}\x{FFE0}-\x{FFE6}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}]/u', '', $str, -1, $wide);
9032 9032
 
9033
-        return ($wide << 1) + (int) self::strlen($str, 'UTF-8');
9033
+        return ($wide << 1) + (int)self::strlen($str, 'UTF-8');
9034 9034
     }
9035 9035
 
9036 9036
     /**
@@ -9126,9 +9126,9 @@  discard block
 block discarded – undo
9126 9126
         }
9127 9127
 
9128 9128
         if ($length === null) {
9129
-            $length = (int) $str_length;
9129
+            $length = (int)$str_length;
9130 9130
         } else {
9131
-            $length = (int) $length;
9131
+            $length = (int)$length;
9132 9132
         }
9133 9133
 
9134 9134
         if (
@@ -9136,7 +9136,7 @@  discard block
 block discarded – undo
9136 9136
             &&
9137 9137
             self::$SUPPORT['mbstring'] === false
9138 9138
         ) {
9139
-            \trigger_error('UTF8::substr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
9139
+            \trigger_error('UTF8::substr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
9140 9140
         }
9141 9141
 
9142 9142
         //
@@ -9215,8 +9215,8 @@  discard block
 block discarded – undo
9215 9215
             ||
9216 9216
             $length !== null
9217 9217
         ) {
9218
-            $str1 = (string) self::substr($str1, $offset, $length);
9219
-            $str2 = (string) self::substr($str2, 0, (int) self::strlen($str1));
9218
+            $str1 = (string)self::substr($str1, $offset, $length);
9219
+            $str2 = (string)self::substr($str2, 0, (int)self::strlen($str1));
9220 9220
         }
9221 9221
 
9222 9222
         if ($case_insensitivity === true) {
@@ -9262,7 +9262,7 @@  discard block
 block discarded – undo
9262 9262
                 if ($lengthTmp === false) {
9263 9263
                     return false;
9264 9264
                 }
9265
-                $length = (int) $lengthTmp;
9265
+                $length = (int)$lengthTmp;
9266 9266
             }
9267 9267
 
9268 9268
             if (
@@ -9279,7 +9279,7 @@  discard block
 block discarded – undo
9279 9279
                 return false;
9280 9280
             }
9281 9281
 
9282
-            $haystack = (string) self::substr($haystack, $offset, $length, $encoding);
9282
+            $haystack = (string)self::substr($haystack, $offset, $length, $encoding);
9283 9283
         }
9284 9284
 
9285 9285
         if ($encoding !== 'UTF-8' && $encoding !== 'CP850') {
@@ -9302,14 +9302,14 @@  discard block
 block discarded – undo
9302 9302
             &&
9303 9303
             self::$SUPPORT['mbstring'] === false
9304 9304
         ) {
9305
-            \trigger_error('UTF8::substr_count() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
9305
+            \trigger_error('UTF8::substr_count() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
9306 9306
         }
9307 9307
 
9308 9308
         if (self::$SUPPORT['mbstring'] === true) {
9309 9309
             return \mb_substr_count($haystack, $needle, $encoding);
9310 9310
         }
9311 9311
 
9312
-        \preg_match_all('/' . \preg_quote($needle, '/') . '/us', $haystack, $matches, \PREG_SET_ORDER);
9312
+        \preg_match_all('/'.\preg_quote($needle, '/').'/us', $haystack, $matches, \PREG_SET_ORDER);
9313 9313
 
9314 9314
         return \count($matches);
9315 9315
     }
@@ -9356,7 +9356,7 @@  discard block
 block discarded – undo
9356 9356
                 if ($lengthTmp === false) {
9357 9357
                     return false;
9358 9358
                 }
9359
-                $length = (int) $lengthTmp;
9359
+                $length = (int)$lengthTmp;
9360 9360
             }
9361 9361
 
9362 9362
             if (
@@ -9377,7 +9377,7 @@  discard block
 block discarded – undo
9377 9377
             if ($haystackTmp === false) {
9378 9378
                 $haystackTmp = '';
9379 9379
             }
9380
-            $haystack = (string) $haystackTmp;
9380
+            $haystack = (string)$haystackTmp;
9381 9381
         }
9382 9382
 
9383 9383
         if (self::$SUPPORT['mbstring_func_overload'] === true) {
@@ -9413,7 +9413,7 @@  discard block
 block discarded – undo
9413 9413
         // only a fallback to prevent BC in the api ...
9414 9414
         /** @psalm-suppress RedundantConditionGivenDocblockType */
9415 9415
         if ($caseSensitive !== false && $caseSensitive !== true) {
9416
-            $encoding = (string) $caseSensitive;
9416
+            $encoding = (string)$caseSensitive;
9417 9417
         }
9418 9418
 
9419 9419
         if (!$caseSensitive) {
@@ -9421,7 +9421,7 @@  discard block
 block discarded – undo
9421 9421
             $substring = self::strtocasefold($substring, true, false, $encoding, null, false);
9422 9422
         }
9423 9423
 
9424
-        return (int) self::substr_count($str, $substring, 0, null, $encoding);
9424
+        return (int)self::substr_count($str, $substring, 0, null, $encoding);
9425 9425
     }
9426 9426
 
9427 9427
     /**
@@ -9443,7 +9443,7 @@  discard block
 block discarded – undo
9443 9443
         }
9444 9444
 
9445 9445
         if (self::str_istarts_with($haystack, $needle) === true) {
9446
-            $haystack = (string) self::substr($haystack, (int) self::strlen($needle));
9446
+            $haystack = (string)self::substr($haystack, (int)self::strlen($needle));
9447 9447
         }
9448 9448
 
9449 9449
         return $haystack;
@@ -9508,7 +9508,7 @@  discard block
 block discarded – undo
9508 9508
         }
9509 9509
 
9510 9510
         if (self::str_iends_with($haystack, $needle) === true) {
9511
-            $haystack = (string) self::substr($haystack, 0, (int) self::strlen($haystack) - (int) self::strlen($needle));
9511
+            $haystack = (string)self::substr($haystack, 0, (int)self::strlen($haystack) - (int)self::strlen($needle));
9512 9512
         }
9513 9513
 
9514 9514
         return $haystack;
@@ -9533,7 +9533,7 @@  discard block
 block discarded – undo
9533 9533
         }
9534 9534
 
9535 9535
         if (self::str_starts_with($haystack, $needle) === true) {
9536
-            $haystack = (string) self::substr($haystack, (int) self::strlen($needle));
9536
+            $haystack = (string)self::substr($haystack, (int)self::strlen($needle));
9537 9537
         }
9538 9538
 
9539 9539
         return $haystack;
@@ -9580,7 +9580,7 @@  discard block
 block discarded – undo
9580 9580
             if (\is_array($offset) === true) {
9581 9581
                 $offset = \array_slice($offset, 0, $num);
9582 9582
                 foreach ($offset as &$valueTmp) {
9583
-                    $valueTmp = (int) $valueTmp === $valueTmp ? $valueTmp : 0;
9583
+                    $valueTmp = (int)$valueTmp === $valueTmp ? $valueTmp : 0;
9584 9584
                 }
9585 9585
                 unset($valueTmp);
9586 9586
             } else {
@@ -9594,7 +9594,7 @@  discard block
 block discarded – undo
9594 9594
                 $length = \array_slice($length, 0, $num);
9595 9595
                 foreach ($length as &$valueTmpV2) {
9596 9596
                     if ($valueTmpV2 !== null) {
9597
-                        $valueTmpV2 = (int) $valueTmpV2 === $valueTmpV2 ? $valueTmpV2 : $num;
9597
+                        $valueTmpV2 = (int)$valueTmpV2 === $valueTmpV2 ? $valueTmpV2 : $num;
9598 9598
                     } else {
9599 9599
                         $valueTmpV2 = 0;
9600 9600
                     }
@@ -9617,8 +9617,8 @@  discard block
 block discarded – undo
9617 9617
         }
9618 9618
 
9619 9619
         // init
9620
-        $str = (string) $str;
9621
-        $replacement = (string) $replacement;
9620
+        $str = (string)$str;
9621
+        $replacement = (string)$replacement;
9622 9622
 
9623 9623
         if (\is_array($length) === true) {
9624 9624
             throw new \InvalidArgumentException('Parameter "$length" can only be an array, if "$str" is also an array.');
@@ -9634,8 +9634,7 @@  discard block
 block discarded – undo
9634 9634
 
9635 9635
         if (self::is_ascii($str)) {
9636 9636
             return ($length === null) ?
9637
-                \substr_replace($str, $replacement, $offset) :
9638
-                \substr_replace($str, $replacement, $offset, $length);
9637
+                \substr_replace($str, $replacement, $offset) : \substr_replace($str, $replacement, $offset, $length);
9639 9638
         }
9640 9639
 
9641 9640
         if (!isset(self::$SUPPORT['already_checked_via_portable_utf8'])) {
@@ -9643,16 +9642,16 @@  discard block
 block discarded – undo
9643 9642
         }
9644 9643
 
9645 9644
         if (self::$SUPPORT['mbstring'] === true) {
9646
-            $string_length = (int) self::strlen($str, $encoding);
9645
+            $string_length = (int)self::strlen($str, $encoding);
9647 9646
 
9648 9647
             if ($offset < 0) {
9649
-                $offset = (int) \max(0, $string_length + $offset);
9648
+                $offset = (int)\max(0, $string_length + $offset);
9650 9649
             } elseif ($offset > $string_length) {
9651 9650
                 $offset = $string_length;
9652 9651
             }
9653 9652
 
9654 9653
             if ($length !== null && $length < 0) {
9655
-                $length = (int) \max(0, $string_length - $offset + $length);
9654
+                $length = (int)\max(0, $string_length - $offset + $length);
9656 9655
             } elseif ($length === null || $length > $string_length) {
9657 9656
                 $length = $string_length;
9658 9657
             }
@@ -9663,9 +9662,9 @@  discard block
 block discarded – undo
9663 9662
             }
9664 9663
 
9665 9664
             /** @noinspection AdditionOperationOnArraysInspection */
9666
-            return (string) self::substr($str, 0, $offset, $encoding) .
9667
-                   $replacement .
9668
-                   (string) self::substr($str, $offset + $length, $string_length - $offset - $length, $encoding);
9665
+            return (string)self::substr($str, 0, $offset, $encoding).
9666
+                   $replacement.
9667
+                   (string)self::substr($str, $offset + $length, $string_length - $offset - $length, $encoding);
9669 9668
         }
9670 9669
 
9671 9670
         \preg_match_all('/./us', $str, $smatches);
@@ -9677,7 +9676,7 @@  discard block
 block discarded – undo
9677 9676
                 // e.g.: non mbstring support + invalid chars
9678 9677
                 return '';
9679 9678
             }
9680
-            $length = (int) $lengthTmp;
9679
+            $length = (int)$lengthTmp;
9681 9680
         }
9682 9681
 
9683 9682
         \array_splice($smatches[0], $offset, $length, $rmatches[0]);
@@ -9704,7 +9703,7 @@  discard block
 block discarded – undo
9704 9703
         }
9705 9704
 
9706 9705
         if (self::str_ends_with($haystack, $needle) === true) {
9707
-            $haystack = (string) self::substr($haystack, 0, (int) self::strlen($haystack) - (int) self::strlen($needle));
9706
+            $haystack = (string)self::substr($haystack, 0, (int)self::strlen($haystack) - (int)self::strlen($needle));
9708 9707
         }
9709 9708
 
9710 9709
         return $haystack;
@@ -9735,7 +9734,7 @@  discard block
 block discarded – undo
9735 9734
             $str = self::clean($str);
9736 9735
         }
9737 9736
 
9738
-        return (string) (self::strtolower($str, $encoding) ^ self::strtoupper($str, $encoding) ^ $str);
9737
+        return (string)(self::strtolower($str, $encoding) ^ self::strtoupper($str, $encoding) ^ $str);
9739 9738
     }
9740 9739
 
9741 9740
     /**
@@ -10030,7 +10029,7 @@  discard block
 block discarded – undo
10030 10029
     public static function to_boolean($str): bool
10031 10030
     {
10032 10031
         // init
10033
-        $str = (string) $str;
10032
+        $str = (string)$str;
10034 10033
 
10035 10034
         if ($str === '') {
10036 10035
             return false;
@@ -10056,10 +10055,10 @@  discard block
 block discarded – undo
10056 10055
 
10057 10056
         /** @noinspection CallableParameterUseCaseInTypeContextInspection */
10058 10057
         if (\is_numeric($str)) {
10059
-            return ((float) $str + 0) > 0;
10058
+            return ((float)$str + 0) > 0;
10060 10059
         }
10061 10060
 
10062
-        return (bool) self::trim($str);
10061
+        return (bool)self::trim($str);
10063 10062
     }
10064 10063
 
10065 10064
     /**
@@ -10080,11 +10079,11 @@  discard block
 block discarded – undo
10080 10079
 
10081 10080
         $fallback_char_escaped = \preg_quote($fallback_char, '/');
10082 10081
 
10083
-        $string = (string) \preg_replace(
10082
+        $string = (string)\preg_replace(
10084 10083
             [
10085
-                '/[^' . $fallback_char_escaped . '\.\-a-zA-Z0-9\s]/', // 1) remove un-needed chars
10086
-                '/[\s]+/',                                            // 2) convert spaces to $fallback_char
10087
-                '/[' . $fallback_char_escaped . ']+/',                // 3) remove double $fallback_char's
10084
+                '/[^'.$fallback_char_escaped.'\.\-a-zA-Z0-9\s]/', // 1) remove un-needed chars
10085
+                '/[\s]+/', // 2) convert spaces to $fallback_char
10086
+                '/['.$fallback_char_escaped.']+/', // 3) remove double $fallback_char's
10088 10087
             ],
10089 10088
             [
10090 10089
                 '',
@@ -10115,7 +10114,7 @@  discard block
 block discarded – undo
10115 10114
             return $str;
10116 10115
         }
10117 10116
 
10118
-        $str = (string) $str;
10117
+        $str = (string)$str;
10119 10118
         if ($str === '') {
10120 10119
             return '';
10121 10120
         }
@@ -10162,7 +10161,7 @@  discard block
 block discarded – undo
10162 10161
             return $str;
10163 10162
         }
10164 10163
 
10165
-        $str = (string) $str;
10164
+        $str = (string)$str;
10166 10165
         if ($str === '') {
10167 10166
             return $str;
10168 10167
         }
@@ -10184,7 +10183,7 @@  discard block
 block discarded – undo
10184 10183
                     $c2 = $i + 1 >= $max ? "\x00" : $str[$i + 1];
10185 10184
 
10186 10185
                     if ($c2 >= "\x80" && $c2 <= "\xBF") { // yeah, almost sure it's UTF8 already
10187
-                        $buf .= $c1 . $c2;
10186
+                        $buf .= $c1.$c2;
10188 10187
                         ++$i;
10189 10188
                     } else { // not valid UTF8 - convert it
10190 10189
                         $buf .= self::to_utf8_convert_helper($c1);
@@ -10195,7 +10194,7 @@  discard block
 block discarded – undo
10195 10194
                     $c3 = $i + 2 >= $max ? "\x00" : $str[$i + 2];
10196 10195
 
10197 10196
                     if ($c2 >= "\x80" && $c2 <= "\xBF" && $c3 >= "\x80" && $c3 <= "\xBF") { // yeah, almost sure it's UTF8 already
10198
-                        $buf .= $c1 . $c2 . $c3;
10197
+                        $buf .= $c1.$c2.$c3;
10199 10198
                         $i += 2;
10200 10199
                     } else { // not valid UTF8 - convert it
10201 10200
                         $buf .= self::to_utf8_convert_helper($c1);
@@ -10207,7 +10206,7 @@  discard block
 block discarded – undo
10207 10206
                     $c4 = $i + 3 >= $max ? "\x00" : $str[$i + 3];
10208 10207
 
10209 10208
                     if ($c2 >= "\x80" && $c2 <= "\xBF" && $c3 >= "\x80" && $c3 <= "\xBF" && $c4 >= "\x80" && $c4 <= "\xBF") { // yeah, almost sure it's UTF8 already
10210
-                        $buf .= $c1 . $c2 . $c3 . $c4;
10209
+                        $buf .= $c1.$c2.$c3.$c4;
10211 10210
                         $i += 3;
10212 10211
                     } else { // not valid UTF8 - convert it
10213 10212
                         $buf .= self::to_utf8_convert_helper($c1);
@@ -10231,7 +10230,7 @@  discard block
 block discarded – undo
10231 10230
              *
10232 10231
              * @return string
10233 10232
              */
10234
-            static function (array $match): string {
10233
+            static function(array $match): string {
10235 10234
                 // always fallback via symfony polyfill
10236 10235
                 return \mb_convert_encoding(\pack('H*', $match[1]), 'UTF-8', 'UCS-2BE');
10237 10236
             },
@@ -10299,17 +10298,17 @@  discard block
 block discarded – undo
10299 10298
             $str = self::clean($str);
10300 10299
         }
10301 10300
 
10302
-        $strPartTwo = (string) self::substr($str, 1, null, $encoding);
10301
+        $strPartTwo = (string)self::substr($str, 1, null, $encoding);
10303 10302
 
10304 10303
         $strPartOne = self::strtoupper(
10305
-            (string) self::substr($str, 0, 1, $encoding),
10304
+            (string)self::substr($str, 0, 1, $encoding),
10306 10305
             $encoding,
10307 10306
             $cleanUtf8,
10308 10307
             $lang,
10309 10308
             $tryToKeepStringLength
10310 10309
         );
10311 10310
 
10312
-        return $strPartOne . $strPartTwo;
10311
+        return $strPartOne.$strPartTwo;
10313 10312
     }
10314 10313
 
10315 10314
     /**
@@ -10355,7 +10354,7 @@  discard block
 block discarded – undo
10355 10354
             $str = self::clean($str);
10356 10355
         }
10357 10356
 
10358
-        $usePhpDefaultFunctions = !(bool) ($charlist . \implode('', $exceptions));
10357
+        $usePhpDefaultFunctions = !(bool)($charlist.\implode('', $exceptions));
10359 10358
 
10360 10359
         if (
10361 10360
             $usePhpDefaultFunctions === true
@@ -10412,7 +10411,7 @@  discard block
 block discarded – undo
10412 10411
 
10413 10412
         $pattern = '/%u([0-9a-f]{3,4})/i';
10414 10413
         if (\preg_match($pattern, $str)) {
10415
-            $str = (string) \preg_replace($pattern, '&#x\\1;', \urldecode($str));
10414
+            $str = (string)\preg_replace($pattern, '&#x\\1;', \urldecode($str));
10416 10415
         }
10417 10416
 
10418 10417
         $flags = \ENT_QUOTES | \ENT_HTML5;
@@ -10756,7 +10755,7 @@  discard block
 block discarded – undo
10756 10755
         if (
10757 10756
             $keepUtf8Chars === true
10758 10757
             &&
10759
-            self::strlen($return) >= (int) self::strlen($str_backup)
10758
+            self::strlen($return) >= (int)self::strlen($str_backup)
10760 10759
         ) {
10761 10760
             return $str_backup;
10762 10761
         }
@@ -10854,17 +10853,17 @@  discard block
 block discarded – undo
10854 10853
             return '';
10855 10854
         }
10856 10855
 
10857
-        \preg_match('/^\s*+(?:\S++\s*+){1,' . $limit . '}/u', $str, $matches);
10856
+        \preg_match('/^\s*+(?:\S++\s*+){1,'.$limit.'}/u', $str, $matches);
10858 10857
 
10859 10858
         if (
10860 10859
             !isset($matches[0])
10861 10860
             ||
10862
-            self::strlen($str) === (int) self::strlen($matches[0])
10861
+            self::strlen($str) === (int)self::strlen($matches[0])
10863 10862
         ) {
10864 10863
             return $str;
10865 10864
         }
10866 10865
 
10867
-        return self::rtrim($matches[0]) . $strAddOn;
10866
+        return self::rtrim($matches[0]).$strAddOn;
10868 10867
     }
10869 10868
 
10870 10869
     /**
@@ -10930,7 +10929,7 @@  discard block
 block discarded – undo
10930 10929
             $strReturn .= $break;
10931 10930
         }
10932 10931
 
10933
-        return $strReturn . \implode('', $chars);
10932
+        return $strReturn.\implode('', $chars);
10934 10933
     }
10935 10934
 
10936 10935
     /**
@@ -10943,7 +10942,7 @@  discard block
 block discarded – undo
10943 10942
      */
10944 10943
     public static function wordwrap_per_line(string $str, int $limit): string
10945 10944
     {
10946
-        $strings = (array) \preg_split('/\\r\\n|\\r|\\n/', $str);
10945
+        $strings = (array)\preg_split('/\\r\\n|\\r|\\n/', $str);
10947 10946
 
10948 10947
         $string = '';
10949 10948
         foreach ($strings as &$value) {
@@ -10982,7 +10981,7 @@  discard block
 block discarded – undo
10982 10981
      */
10983 10982
     private static function apply_padding(string $str, int $left = 0, int $right = 0, string $padStr = ' ', string $encoding = 'UTF-8'): string
10984 10983
     {
10985
-        $strlen = (int) self::strlen($str, $encoding);
10984
+        $strlen = (int)self::strlen($str, $encoding);
10986 10985
 
10987 10986
         if ($left && $right) {
10988 10987
             $length = ($left + $right) + $strlen;
@@ -11014,13 +11013,13 @@  discard block
 block discarded – undo
11014 11013
         $lower = self::$COMMON_CASE_FOLD['lower'];
11015 11014
 
11016 11015
         if ($useLower === true) {
11017
-            $str = (string) \str_replace(
11016
+            $str = (string)\str_replace(
11018 11017
                 $upper,
11019 11018
                 $lower,
11020 11019
                 $str
11021 11020
             );
11022 11021
         } else {
11023
-            $str = (string) \str_replace(
11022
+            $str = (string)\str_replace(
11024 11023
                 $lower,
11025 11024
                 $upper,
11026 11025
                 $str
@@ -11034,9 +11033,9 @@  discard block
 block discarded – undo
11034 11033
             }
11035 11034
 
11036 11035
             if ($useLower === true) {
11037
-                $str = (string) \str_replace($FULL_CASE_FOLD[0], $FULL_CASE_FOLD[1], $str);
11036
+                $str = (string)\str_replace($FULL_CASE_FOLD[0], $FULL_CASE_FOLD[1], $str);
11038 11037
             } else {
11039
-                $str = (string) \str_replace($FULL_CASE_FOLD[1], $FULL_CASE_FOLD[0], $str);
11038
+                $str = (string)\str_replace($FULL_CASE_FOLD[1], $FULL_CASE_FOLD[0], $str);
11040 11039
             }
11041 11040
         }
11042 11041
 
@@ -11054,7 +11053,7 @@  discard block
 block discarded – undo
11054 11053
     {
11055 11054
         /** @noinspection PhpIncludeInspection */
11056 11055
         /** @psalm-suppress UnresolvableInclude */
11057
-        return include __DIR__ . '/data/' . $file . '.php';
11056
+        return include __DIR__.'/data/'.$file.'.php';
11058 11057
     }
11059 11058
 
11060 11059
     /**
@@ -11066,7 +11065,7 @@  discard block
 block discarded – undo
11066 11065
      */
11067 11066
     private static function getDataIfExists(string $file)
11068 11067
     {
11069
-        $file = __DIR__ . '/data/' . $file . '.php';
11068
+        $file = __DIR__.'/data/'.$file.'.php';
11070 11069
         if (\file_exists($file)) {
11071 11070
             /** @noinspection PhpIncludeInspection */
11072 11071
             return include $file;
@@ -11090,7 +11089,7 @@  discard block
 block discarded – undo
11090 11089
         /** @noinspection PhpUsageOfSilenceOperatorInspection */
11091 11090
         return \defined('MB_OVERLOAD_STRING')
11092 11091
                &&
11093
-               ((int) @\ini_get('mbstring.func_overload') & \MB_OVERLOAD_STRING);
11092
+               ((int)@\ini_get('mbstring.func_overload') & \MB_OVERLOAD_STRING);
11094 11093
     }
11095 11094
 
11096 11095
     /**
@@ -11140,7 +11139,7 @@  discard block
 block discarded – undo
11140 11139
     {
11141 11140
         static $RX_CLASSS_CACHE = [];
11142 11141
 
11143
-        $cacheKey = $s . $class;
11142
+        $cacheKey = $s.$class;
11144 11143
 
11145 11144
         if (isset($RX_CLASSS_CACHE[$cacheKey])) {
11146 11145
             return $RX_CLASSS_CACHE[$cacheKey];
@@ -11151,7 +11150,7 @@  discard block
 block discarded – undo
11151 11150
         /** @noinspection SuspiciousLoopInspection */
11152 11151
         foreach (self::str_split($s) as &$s) {
11153 11152
             if ($s === '-') {
11154
-                $class[0] = '-' . $class[0];
11153
+                $class[0] = '-'.$class[0];
11155 11154
             } elseif (!isset($s[2])) {
11156 11155
                 $class[0] .= \preg_quote($s, '/');
11157 11156
             } elseif (self::strlen($s) === 1) {
@@ -11163,13 +11162,13 @@  discard block
 block discarded – undo
11163 11162
         unset($s);
11164 11163
 
11165 11164
         if ($class[0]) {
11166
-            $class[0] = '[' . $class[0] . ']';
11165
+            $class[0] = '['.$class[0].']';
11167 11166
         }
11168 11167
 
11169 11168
         if (\count($class) === 1) {
11170 11169
             $return = $class[0];
11171 11170
         } else {
11172
-            $return = '(?:' . \implode('|', $class) . ')';
11171
+            $return = '(?:'.\implode('|', $class).')';
11173 11172
         }
11174 11173
 
11175 11174
         $RX_CLASSS_CACHE[$cacheKey] = $return;
@@ -11308,8 +11307,8 @@  discard block
 block discarded – undo
11308 11307
             $buf .= self::$WIN1252_TO_UTF8[$ordC1];
11309 11308
         } else {
11310 11309
             $cc1 = self::$CHR[$ordC1 / 64] | "\xC0";
11311
-            $cc2 = ((string) $input & "\x3F") | "\x80";
11312
-            $buf .= $cc1 . $cc2;
11310
+            $cc2 = ((string)$input & "\x3F") | "\x80";
11311
+            $buf .= $cc1.$cc2;
11313 11312
         }
11314 11313
 
11315 11314
         return $buf;
Please login to merge, or discard this patch.