Passed
Push — master ( 6eaa7f...c08b92 )
by Lars
04:10
created
src/voku/helper/UTF8.php 1 patch
Spacing   +456 added lines, -457 removed lines patch added patch discarded remove patch
@@ -271,10 +271,10 @@  discard block
 block discarded – undo
271 271
         }
272 272
 
273 273
         if ($encoding === 'UTF-8') {
274
-            return (string) \mb_substr($str, $pos, 1);
274
+            return (string)\mb_substr($str, $pos, 1);
275 275
         }
276 276
 
277
-        return (string) self::substr($str, $pos, 1, $encoding);
277
+        return (string)self::substr($str, $pos, 1, $encoding);
278 278
     }
279 279
 
280 280
     /**
@@ -294,7 +294,7 @@  discard block
 block discarded – undo
294 294
     public static function add_bom_to_string(string $str): string
295 295
     {
296 296
         if (!self::string_has_bom($str)) {
297
-            $str = self::bom() . $str;
297
+            $str = self::bom().$str;
298 298
         }
299 299
 
300 300
         return $str;
@@ -329,8 +329,8 @@  discard block
 block discarded – undo
329 329
         $return = [];
330 330
         foreach ($array as $key => &$value) {
331 331
             $key = $case === \CASE_LOWER
332
-                ? self::strtolower((string) $key, $encoding)
333
-                : self::strtoupper((string) $key, $encoding);
332
+                ? self::strtolower((string)$key, $encoding)
333
+                : self::strtoupper((string)$key, $encoding);
334 334
 
335 335
             $return[$key] = $value;
336 336
         }
@@ -366,7 +366,7 @@  discard block
 block discarded – undo
366 366
                 return '';
367 367
             }
368 368
 
369
-            $substr_index = $start_position + (int) \mb_strlen($start);
369
+            $substr_index = $start_position + (int)\mb_strlen($start);
370 370
             $end_position = \mb_strpos($str, $end, $substr_index);
371 371
             if (
372 372
                 $end_position === false
@@ -376,7 +376,7 @@  discard block
 block discarded – undo
376 376
                 return '';
377 377
             }
378 378
 
379
-            return (string) \mb_substr($str, $substr_index, $end_position - $substr_index);
379
+            return (string)\mb_substr($str, $substr_index, $end_position - $substr_index);
380 380
         }
381 381
 
382 382
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
@@ -386,7 +386,7 @@  discard block
 block discarded – undo
386 386
             return '';
387 387
         }
388 388
 
389
-        $substr_index = $start_position + (int) self::strlen($start, $encoding);
389
+        $substr_index = $start_position + (int)self::strlen($start, $encoding);
390 390
         $end_position = self::strpos($str, $end, $substr_index, $encoding);
391 391
         if (
392 392
             $end_position === false
@@ -396,7 +396,7 @@  discard block
 block discarded – undo
396 396
             return '';
397 397
         }
398 398
 
399
-        return (string) self::substr(
399
+        return (string)self::substr(
400 400
             $str,
401 401
             $substr_index,
402 402
             $end_position - $substr_index,
@@ -480,10 +480,10 @@  discard block
 block discarded – undo
480 480
     public static function char_at(string $str, int $index, string $encoding = 'UTF-8'): string
481 481
     {
482 482
         if ($encoding === 'UTF-8') {
483
-            return (string) \mb_substr($str, $index, 1);
483
+            return (string)\mb_substr($str, $index, 1);
484 484
         }
485 485
 
486
-        return (string) self::substr($str, $index, 1, $encoding);
486
+        return (string)self::substr($str, $index, 1, $encoding);
487 487
     }
488 488
 
489 489
     /**
@@ -601,14 +601,14 @@  discard block
 block discarded – undo
601 601
             /**
602 602
              * @psalm-suppress ImpureFunctionCall - is is only a warning
603 603
              */
604
-            \trigger_error('UTF8::chr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
604
+            \trigger_error('UTF8::chr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
605 605
         }
606 606
 
607 607
         if (!\is_int($code_point) || $code_point <= 0) {
608 608
             return null;
609 609
         }
610 610
 
611
-        $cache_key = $code_point . '_' . $encoding;
611
+        $cache_key = $code_point.'_'.$encoding;
612 612
         if (isset($CHAR_CACHE[$cache_key])) {
613 613
             return $CHAR_CACHE[$cache_key];
614 614
         }
@@ -654,27 +654,27 @@  discard block
 block discarded – undo
654 654
             self::$CHR = self::getData('chr');
655 655
         }
656 656
 
657
-        $code_point = (int) $code_point;
657
+        $code_point = (int)$code_point;
658 658
         if ($code_point <= 0x7FF) {
659 659
             /**
660 660
              * @psalm-suppress PossiblyNullArrayAccess
661 661
              */
662
-            $chr = self::$CHR[($code_point >> 6) + 0xC0] .
662
+            $chr = self::$CHR[($code_point >> 6) + 0xC0].
663 663
                    self::$CHR[($code_point & 0x3F) + 0x80];
664 664
         } elseif ($code_point <= 0xFFFF) {
665 665
             /**
666 666
              * @psalm-suppress PossiblyNullArrayAccess
667 667
              */
668
-            $chr = self::$CHR[($code_point >> 12) + 0xE0] .
669
-                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80] .
668
+            $chr = self::$CHR[($code_point >> 12) + 0xE0].
669
+                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80].
670 670
                    self::$CHR[($code_point & 0x3F) + 0x80];
671 671
         } else {
672 672
             /**
673 673
              * @psalm-suppress PossiblyNullArrayAccess
674 674
              */
675
-            $chr = self::$CHR[($code_point >> 18) + 0xF0] .
676
-                   self::$CHR[(($code_point >> 12) & 0x3F) + 0x80] .
677
-                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80] .
675
+            $chr = self::$CHR[($code_point >> 18) + 0xF0].
676
+                   self::$CHR[(($code_point >> 12) & 0x3F) + 0x80].
677
+                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80].
678 678
                    self::$CHR[($code_point & 0x3F) + 0x80];
679 679
         }
680 680
 
@@ -731,7 +731,7 @@  discard block
 block discarded – undo
731 731
 
732 732
         if (self::$SUPPORT['mbstring_func_overload'] === true) {
733 733
             return \array_map(
734
-                static function (string $data): int {
734
+                static function(string $data): int {
735 735
                     // "mb_" is available if overload is used, so use it ...
736 736
                     return \mb_strlen($data, 'CP850'); // 8-BIT
737 737
                 },
@@ -818,7 +818,7 @@  discard block
 block discarded – undo
818 818
             $char = '';
819 819
         }
820 820
 
821
-        return self::int_to_hex(self::ord((string) $char), $prefix);
821
+        return self::int_to_hex(self::ord((string)$char), $prefix);
822 822
     }
823 823
 
824 824
     /**
@@ -915,7 +915,7 @@  discard block
 block discarded – undo
915 915
         | ( [\xC0-\xFF] )                 # invalid byte in range 11000000 - 11111111
916 916
         /x';
917 917
         /** @noinspection NotOptimalRegularExpressionsInspection */
918
-        $str = (string) \preg_replace($regex, '$1', $str);
918
+        $str = (string)\preg_replace($regex, '$1', $str);
919 919
 
920 920
         if ($replace_diamond_question_mark) {
921 921
             $str = self::replace_diamond_question_mark($str);
@@ -954,7 +954,7 @@  discard block
 block discarded – undo
954 954
     public static function cleanup($str): string
955 955
     {
956 956
         // init
957
-        $str = (string) $str;
957
+        $str = (string)$str;
958 958
 
959 959
         if ($str === '') {
960 960
             return '';
@@ -1056,7 +1056,7 @@  discard block
 block discarded – undo
1056 1056
     {
1057 1057
         if (self::$SUPPORT['mbstring'] === true) {
1058 1058
             /** @noinspection PhpComposerExtensionStubsInspection */
1059
-            return \trim((string) \mb_ereg_replace('[[:space:]]+', ' ', $str));
1059
+            return \trim((string)\mb_ereg_replace('[[:space:]]+', ' ', $str));
1060 1060
         }
1061 1061
 
1062 1062
         return \trim(self::regex_replace($str, '[[:space:]]+', ' '));
@@ -1161,9 +1161,9 @@  discard block
 block discarded – undo
1161 1161
         // - 0-9 (U+0061 - U+007A)
1162 1162
         // - ISO 10646 characters U+00A1 and higher
1163 1163
         // We strip out any character not in the above list.
1164
-        $str = (string) \preg_replace('/[^\x{002D}\x{0030}-\x{0039}\x{0041}-\x{005A}\x{005F}\x{0061}-\x{007A}\x{00A1}-\x{FFFF}]/u', '', $str);
1164
+        $str = (string)\preg_replace('/[^\x{002D}\x{0030}-\x{0039}\x{0041}-\x{005A}\x{005F}\x{0061}-\x{007A}\x{00A1}-\x{FFFF}]/u', '', $str);
1165 1165
         // Identifiers cannot start with a digit, two hyphens, or a hyphen followed by a digit.
1166
-        $str = (string) \preg_replace(['/^[0-9]/', '/^(-[0-9])|^(--)/'], ['_', '__'], $str);
1166
+        $str = (string)\preg_replace(['/^[0-9]/', '/^(-[0-9])|^(--)/'], ['_', '__'], $str);
1167 1167
 
1168 1168
         return \trim($str, '-');
1169 1169
     }
@@ -1179,7 +1179,7 @@  discard block
 block discarded – undo
1179 1179
      */
1180 1180
     public static function css_stripe_media_queries(string $str): string
1181 1181
     {
1182
-        return (string) \preg_replace(
1182
+        return (string)\preg_replace(
1183 1183
             '#@media\\s+(?:only\\s)?(?:[\\s{(]|screen|all)\\s?[^{]+{.*}\\s*}\\s*#isumU',
1184 1184
             '',
1185 1185
             $str
@@ -1218,7 +1218,7 @@  discard block
 block discarded – undo
1218 1218
      */
1219 1219
     public static function decimal_to_chr($int): string
1220 1220
     {
1221
-        return self::html_entity_decode('&#' . $int . ';', \ENT_QUOTES | \ENT_HTML5);
1221
+        return self::html_entity_decode('&#'.$int.';', \ENT_QUOTES | \ENT_HTML5);
1222 1222
     }
1223 1223
 
1224 1224
     /**
@@ -1268,7 +1268,7 @@  discard block
 block discarded – undo
1268 1268
         $flagOffset = 0x1F1E6;
1269 1269
         $asciiOffset = 0x41;
1270 1270
 
1271
-        return (self::chr((self::ord($country_code_iso_3166_1[0]) - $asciiOffset + $flagOffset)) ?? '') .
1271
+        return (self::chr((self::ord($country_code_iso_3166_1[0]) - $asciiOffset + $flagOffset)) ?? '').
1272 1272
                (self::chr((self::ord($country_code_iso_3166_1[1]) - $asciiOffset + $flagOffset)) ?? '');
1273 1273
     }
1274 1274
 
@@ -1302,16 +1302,16 @@  discard block
 block discarded – undo
1302 1302
         }
1303 1303
 
1304 1304
         if ($use_reversible_string_mappings) {
1305
-            return (string) \str_replace(
1306
-                (array) self::$EMOJI_KEYS_REVERSIBLE_CACHE,
1307
-                (array) self::$EMOJI_VALUES_CACHE,
1305
+            return (string)\str_replace(
1306
+                (array)self::$EMOJI_KEYS_REVERSIBLE_CACHE,
1307
+                (array)self::$EMOJI_VALUES_CACHE,
1308 1308
                 $str
1309 1309
             );
1310 1310
         }
1311 1311
 
1312
-        return (string) \str_replace(
1313
-            (array) self::$EMOJI_KEYS_CACHE,
1314
-            (array) self::$EMOJI_VALUES_CACHE,
1312
+        return (string)\str_replace(
1313
+            (array)self::$EMOJI_KEYS_CACHE,
1314
+            (array)self::$EMOJI_VALUES_CACHE,
1315 1315
             $str
1316 1316
         );
1317 1317
     }
@@ -1346,16 +1346,16 @@  discard block
 block discarded – undo
1346 1346
         }
1347 1347
 
1348 1348
         if ($use_reversible_string_mappings) {
1349
-            return (string) \str_replace(
1350
-                (array) self::$EMOJI_VALUES_CACHE,
1351
-                (array) self::$EMOJI_KEYS_REVERSIBLE_CACHE,
1349
+            return (string)\str_replace(
1350
+                (array)self::$EMOJI_VALUES_CACHE,
1351
+                (array)self::$EMOJI_KEYS_REVERSIBLE_CACHE,
1352 1352
                 $str
1353 1353
             );
1354 1354
         }
1355 1355
 
1356
-        return (string) \str_replace(
1357
-            (array) self::$EMOJI_VALUES_CACHE,
1358
-            (array) self::$EMOJI_KEYS_CACHE,
1356
+        return (string)\str_replace(
1357
+            (array)self::$EMOJI_VALUES_CACHE,
1358
+            (array)self::$EMOJI_KEYS_CACHE,
1359 1359
             $str
1360 1360
         );
1361 1361
     }
@@ -1421,7 +1421,7 @@  discard block
 block discarded – undo
1421 1421
         if ($to_encoding === 'JSON') {
1422 1422
             $return = self::json_encode($str);
1423 1423
             if ($return === false) {
1424
-                throw new \InvalidArgumentException('The input string [' . $str . '] can not be used for json_encode().');
1424
+                throw new \InvalidArgumentException('The input string ['.$str.'] can not be used for json_encode().');
1425 1425
             }
1426 1426
 
1427 1427
             return $return;
@@ -1512,7 +1512,7 @@  discard block
 block discarded – undo
1512 1512
             /**
1513 1513
              * @psalm-suppress ImpureFunctionCall - is is only a warning
1514 1514
              */
1515
-            \trigger_error('UTF8::encode() without mbstring cannot handle "' . $to_encoding . '" encoding', \E_USER_WARNING);
1515
+            \trigger_error('UTF8::encode() without mbstring cannot handle "'.$to_encoding.'" encoding', \E_USER_WARNING);
1516 1516
         }
1517 1517
 
1518 1518
         if (self::$SUPPORT['mbstring'] === true) {
@@ -1613,31 +1613,31 @@  discard block
 block discarded – undo
1613 1613
         $trim_chars = "\t\r\n -_()!~?=+/*\\,.:;\"'[]{}`&";
1614 1614
 
1615 1615
         if ($length === null) {
1616
-            $length = (int) \round((int) self::strlen($str, $encoding) / 2);
1616
+            $length = (int)\round((int)self::strlen($str, $encoding) / 2);
1617 1617
         }
1618 1618
 
1619 1619
         if ($search === '') {
1620 1620
             if ($encoding === 'UTF-8') {
1621 1621
                 if ($length > 0) {
1622
-                    $string_length = (int) \mb_strlen($str);
1622
+                    $string_length = (int)\mb_strlen($str);
1623 1623
                     $end = ($length - 1) > $string_length ? $string_length : ($length - 1);
1624 1624
                 } else {
1625 1625
                     $end = 0;
1626 1626
                 }
1627 1627
 
1628
-                $pos = (int) \min(
1628
+                $pos = (int)\min(
1629 1629
                     \mb_strpos($str, ' ', $end),
1630 1630
                     \mb_strpos($str, '.', $end)
1631 1631
                 );
1632 1632
             } else {
1633 1633
                 if ($length > 0) {
1634
-                    $string_length = (int) self::strlen($str, $encoding);
1634
+                    $string_length = (int)self::strlen($str, $encoding);
1635 1635
                     $end = ($length - 1) > $string_length ? $string_length : ($length - 1);
1636 1636
                 } else {
1637 1637
                     $end = 0;
1638 1638
                 }
1639 1639
 
1640
-                $pos = (int) \min(
1640
+                $pos = (int)\min(
1641 1641
                     self::strpos($str, ' ', $end, $encoding),
1642 1642
                     self::strpos($str, '.', $end, $encoding)
1643 1643
                 );
@@ -1654,18 +1654,18 @@  discard block
 block discarded – undo
1654 1654
                     return '';
1655 1655
                 }
1656 1656
 
1657
-                return \rtrim($str_sub, $trim_chars) . $replacer_for_skipped_text;
1657
+                return \rtrim($str_sub, $trim_chars).$replacer_for_skipped_text;
1658 1658
             }
1659 1659
 
1660 1660
             return $str;
1661 1661
         }
1662 1662
 
1663 1663
         if ($encoding === 'UTF-8') {
1664
-            $word_position = (int) \mb_stripos($str, $search);
1665
-            $half_side = (int) ($word_position - $length / 2 + (int) \mb_strlen($search) / 2);
1664
+            $word_position = (int)\mb_stripos($str, $search);
1665
+            $half_side = (int)($word_position - $length / 2 + (int)\mb_strlen($search) / 2);
1666 1666
         } else {
1667
-            $word_position = (int) self::stripos($str, $search, 0, $encoding);
1668
-            $half_side = (int) ($word_position - $length / 2 + (int) self::strlen($search, $encoding) / 2);
1667
+            $word_position = (int)self::stripos($str, $search, 0, $encoding);
1668
+            $half_side = (int)($word_position - $length / 2 + (int)self::strlen($search, $encoding) / 2);
1669 1669
         }
1670 1670
 
1671 1671
         $pos_start = 0;
@@ -1677,12 +1677,12 @@  discard block
 block discarded – undo
1677 1677
             }
1678 1678
             if ($half_text !== false) {
1679 1679
                 if ($encoding === 'UTF-8') {
1680
-                    $pos_start = (int) \max(
1680
+                    $pos_start = (int)\max(
1681 1681
                         \mb_strrpos($half_text, ' '),
1682 1682
                         \mb_strrpos($half_text, '.')
1683 1683
                     );
1684 1684
                 } else {
1685
-                    $pos_start = (int) \max(
1685
+                    $pos_start = (int)\max(
1686 1686
                         self::strrpos($half_text, ' ', 0, $encoding),
1687 1687
                         self::strrpos($half_text, '.', 0, $encoding)
1688 1688
                     );
@@ -1692,19 +1692,19 @@  discard block
 block discarded – undo
1692 1692
 
1693 1693
         if ($word_position && $half_side > 0) {
1694 1694
             $offset = $pos_start + $length - 1;
1695
-            $real_length = (int) self::strlen($str, $encoding);
1695
+            $real_length = (int)self::strlen($str, $encoding);
1696 1696
 
1697 1697
             if ($offset > $real_length) {
1698 1698
                 $offset = $real_length;
1699 1699
             }
1700 1700
 
1701 1701
             if ($encoding === 'UTF-8') {
1702
-                $pos_end = (int) \min(
1702
+                $pos_end = (int)\min(
1703 1703
                     \mb_strpos($str, ' ', $offset),
1704 1704
                     \mb_strpos($str, '.', $offset)
1705 1705
                 ) - $pos_start;
1706 1706
             } else {
1707
-                $pos_end = (int) \min(
1707
+                $pos_end = (int)\min(
1708 1708
                     self::strpos($str, ' ', $offset, $encoding),
1709 1709
                     self::strpos($str, '.', $offset, $encoding)
1710 1710
                 ) - $pos_start;
@@ -1712,12 +1712,12 @@  discard block
 block discarded – undo
1712 1712
 
1713 1713
             if (!$pos_end || $pos_end <= 0) {
1714 1714
                 if ($encoding === 'UTF-8') {
1715
-                    $str_sub = \mb_substr($str, $pos_start, (int) \mb_strlen($str));
1715
+                    $str_sub = \mb_substr($str, $pos_start, (int)\mb_strlen($str));
1716 1716
                 } else {
1717
-                    $str_sub = self::substr($str, $pos_start, (int) self::strlen($str, $encoding), $encoding);
1717
+                    $str_sub = self::substr($str, $pos_start, (int)self::strlen($str, $encoding), $encoding);
1718 1718
                 }
1719 1719
                 if ($str_sub !== false) {
1720
-                    $extract = $replacer_for_skipped_text . \ltrim($str_sub, $trim_chars);
1720
+                    $extract = $replacer_for_skipped_text.\ltrim($str_sub, $trim_chars);
1721 1721
                 } else {
1722 1722
                     $extract = '';
1723 1723
                 }
@@ -1728,26 +1728,26 @@  discard block
 block discarded – undo
1728 1728
                     $str_sub = self::substr($str, $pos_start, $pos_end, $encoding);
1729 1729
                 }
1730 1730
                 if ($str_sub !== false) {
1731
-                    $extract = $replacer_for_skipped_text . \trim($str_sub, $trim_chars) . $replacer_for_skipped_text;
1731
+                    $extract = $replacer_for_skipped_text.\trim($str_sub, $trim_chars).$replacer_for_skipped_text;
1732 1732
                 } else {
1733 1733
                     $extract = '';
1734 1734
                 }
1735 1735
             }
1736 1736
         } else {
1737 1737
             $offset = $length - 1;
1738
-            $true_length = (int) self::strlen($str, $encoding);
1738
+            $true_length = (int)self::strlen($str, $encoding);
1739 1739
 
1740 1740
             if ($offset > $true_length) {
1741 1741
                 $offset = $true_length;
1742 1742
             }
1743 1743
 
1744 1744
             if ($encoding === 'UTF-8') {
1745
-                $pos_end = (int) \min(
1745
+                $pos_end = (int)\min(
1746 1746
                     \mb_strpos($str, ' ', $offset),
1747 1747
                     \mb_strpos($str, '.', $offset)
1748 1748
                 );
1749 1749
             } else {
1750
-                $pos_end = (int) \min(
1750
+                $pos_end = (int)\min(
1751 1751
                     self::strpos($str, ' ', $offset, $encoding),
1752 1752
                     self::strpos($str, '.', $offset, $encoding)
1753 1753
                 );
@@ -1760,7 +1760,7 @@  discard block
 block discarded – undo
1760 1760
                     $str_sub = self::substr($str, 0, $pos_end, $encoding);
1761 1761
                 }
1762 1762
                 if ($str_sub !== false) {
1763
-                    $extract = \rtrim($str_sub, $trim_chars) . $replacer_for_skipped_text;
1763
+                    $extract = \rtrim($str_sub, $trim_chars).$replacer_for_skipped_text;
1764 1764
                 } else {
1765 1765
                     $extract = '';
1766 1766
                 }
@@ -1893,7 +1893,7 @@  discard block
 block discarded – undo
1893 1893
     {
1894 1894
         $file_content = \file_get_contents($file_path);
1895 1895
         if ($file_content === false) {
1896
-            throw new \RuntimeException('file_get_contents() returned false for:' . $file_path);
1896
+            throw new \RuntimeException('file_get_contents() returned false for:'.$file_path);
1897 1897
         }
1898 1898
 
1899 1899
         return self::string_has_bom($file_content);
@@ -1961,7 +1961,7 @@  discard block
 block discarded – undo
1961 1961
                     ) {
1962 1962
                         // Prevent leading combining chars
1963 1963
                         // for NFC-safe concatenations.
1964
-                        $var = $leading_combining . $var;
1964
+                        $var = $leading_combining.$var;
1965 1965
                     }
1966 1966
                 }
1967 1967
 
@@ -2282,10 +2282,10 @@  discard block
 block discarded – undo
2282 2282
         }
2283 2283
 
2284 2284
         if ($encoding === 'UTF-8') {
2285
-            return (string) \mb_substr($str, 0, $n);
2285
+            return (string)\mb_substr($str, 0, $n);
2286 2286
         }
2287 2287
 
2288
-        return (string) self::substr($str, 0, $n, $encoding);
2288
+        return (string)self::substr($str, 0, $n, $encoding);
2289 2289
     }
2290 2290
 
2291 2291
     /**
@@ -2303,7 +2303,7 @@  discard block
 block discarded – undo
2303 2303
      */
2304 2304
     public static function fits_inside(string $str, int $box_size): bool
2305 2305
     {
2306
-        return (int) self::strlen($str) <= $box_size;
2306
+        return (int)self::strlen($str) <= $box_size;
2307 2307
     }
2308 2308
 
2309 2309
     /**
@@ -2388,7 +2388,7 @@  discard block
 block discarded – undo
2388 2388
             return $str;
2389 2389
         }
2390 2390
 
2391
-        $str = (string) $str;
2391
+        $str = (string)$str;
2392 2392
         $last = '';
2393 2393
         while ($last !== $str) {
2394 2394
             $last = $str;
@@ -2597,7 +2597,7 @@  discard block
 block discarded – undo
2597 2597
             return $fallback;
2598 2598
         }
2599 2599
         /** @noinspection OffsetOperationsInspection */
2600
-        $type_code = (int) ($str_info['chars1'] . $str_info['chars2']);
2600
+        $type_code = (int)($str_info['chars1'].$str_info['chars2']);
2601 2601
 
2602 2602
         // DEBUG
2603 2603
         //var_dump($type_code);
@@ -2655,7 +2655,7 @@  discard block
 block discarded – undo
2655 2655
         //
2656 2656
 
2657 2657
         if ($encoding === 'UTF-8') {
2658
-            $max_length = (int) \mb_strlen($possible_chars);
2658
+            $max_length = (int)\mb_strlen($possible_chars);
2659 2659
             if ($max_length === 0) {
2660 2660
                 return '';
2661 2661
             }
@@ -2676,7 +2676,7 @@  discard block
 block discarded – undo
2676 2676
         } else {
2677 2677
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
2678 2678
 
2679
-            $max_length = (int) self::strlen($possible_chars, $encoding);
2679
+            $max_length = (int)self::strlen($possible_chars, $encoding);
2680 2680
             if ($max_length === 0) {
2681 2681
                 return '';
2682 2682
             }
@@ -2714,16 +2714,16 @@  discard block
 block discarded – undo
2714 2714
             $rand_int = \mt_rand(0, \mt_getrandmax());
2715 2715
         }
2716 2716
 
2717
-        $unique_helper = $rand_int .
2718
-                         \session_id() .
2719
-                         ($_SERVER['REMOTE_ADDR'] ?? '') .
2720
-                         ($_SERVER['SERVER_ADDR'] ?? '') .
2717
+        $unique_helper = $rand_int.
2718
+                         \session_id().
2719
+                         ($_SERVER['REMOTE_ADDR'] ?? '').
2720
+                         ($_SERVER['SERVER_ADDR'] ?? '').
2721 2721
                          $extra_entropy;
2722 2722
 
2723 2723
         $unique_string = \uniqid($unique_helper, true);
2724 2724
 
2725 2725
         if ($use_md5) {
2726
-            $unique_string = \md5($unique_string . $unique_helper);
2726
+            $unique_string = \md5($unique_string.$unique_helper);
2727 2727
         }
2728 2728
 
2729 2729
         return $unique_string;
@@ -2822,7 +2822,7 @@  discard block
 block discarded – undo
2822 2822
     public static function hex_to_chr(string $hexdec)
2823 2823
     {
2824 2824
         /** @noinspection PhpUsageOfSilenceOperatorInspection - Invalid characters passed for attempted conversion, these have been ignored */
2825
-        return self::decimal_to_chr((int) @\hexdec($hexdec));
2825
+        return self::decimal_to_chr((int)@\hexdec($hexdec));
2826 2826
     }
2827 2827
 
2828 2828
     /**
@@ -2842,7 +2842,7 @@  discard block
 block discarded – undo
2842 2842
     public static function hex_to_int($hexdec)
2843 2843
     {
2844 2844
         // init
2845
-        $hexdec = (string) $hexdec;
2845
+        $hexdec = (string)$hexdec;
2846 2846
 
2847 2847
         if ($hexdec === '') {
2848 2848
             return false;
@@ -2942,7 +2942,7 @@  discard block
 block discarded – undo
2942 2942
         return \implode(
2943 2943
             '',
2944 2944
             \array_map(
2945
-                static function (string $chr) use ($keep_ascii_chars, $encoding): string {
2945
+                static function(string $chr) use ($keep_ascii_chars, $encoding): string {
2946 2946
                     return self::single_chr_html_encode($chr, $keep_ascii_chars, $encoding);
2947 2947
                 },
2948 2948
                 self::str_split($str)
@@ -3057,7 +3057,7 @@  discard block
 block discarded – undo
3057 3057
             /**
3058 3058
              * @psalm-suppress ImpureFunctionCall - is is only a warning
3059 3059
              */
3060
-            \trigger_error('UTF8::html_entity_decode() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
3060
+            \trigger_error('UTF8::html_entity_decode() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
3061 3061
         }
3062 3062
 
3063 3063
         do {
@@ -3066,7 +3066,7 @@  discard block
 block discarded – undo
3066 3066
             if (\strpos($str, '&') !== false) {
3067 3067
                 if (\strpos($str, '&#') !== false) {
3068 3068
                     // decode also numeric & UTF16 two byte entities
3069
-                    $str = (string) \preg_replace(
3069
+                    $str = (string)\preg_replace(
3070 3070
                         '/(&#(?:x0*[0-9a-fA-F]{2,6}(?![0-9a-fA-F;])|(?:0*\d{2,6}(?![0-9;]))))/S',
3071 3071
                         '$1;',
3072 3072
                         $str
@@ -3116,7 +3116,7 @@  discard block
 block discarded – undo
3116 3116
      */
3117 3117
     public static function html_stripe_empty_tags(string $str): string
3118 3118
     {
3119
-        return (string) \preg_replace(
3119
+        return (string)\preg_replace(
3120 3120
             '/<[^\\/>]*?>\\s*?<\\/[^>]*?>/u',
3121 3121
             '',
3122 3122
             $str
@@ -3446,9 +3446,9 @@  discard block
 block discarded – undo
3446 3446
     {
3447 3447
         $hex = \dechex($int);
3448 3448
 
3449
-        $hex = (\strlen($hex) < 4 ? \substr('0000' . $hex, -4) : $hex);
3449
+        $hex = (\strlen($hex) < 4 ? \substr('0000'.$hex, -4) : $hex);
3450 3450
 
3451
-        return $prefix . $hex . '';
3451
+        return $prefix.$hex.'';
3452 3452
     }
3453 3453
 
3454 3454
     /**
@@ -3777,7 +3777,7 @@  discard block
 block discarded – undo
3777 3777
      */
3778 3778
     public static function is_binary($input, bool $strict = false): bool
3779 3779
     {
3780
-        $input = (string) $input;
3780
+        $input = (string)$input;
3781 3781
         if ($input === '') {
3782 3782
             return false;
3783 3783
         }
@@ -4137,7 +4137,7 @@  discard block
 block discarded – undo
4137 4137
     public static function is_utf16($str, bool $check_if_string_is_binary = true)
4138 4138
     {
4139 4139
         // init
4140
-        $str = (string) $str;
4140
+        $str = (string)$str;
4141 4141
         $str_chars = [];
4142 4142
 
4143 4143
         if (
@@ -4231,7 +4231,7 @@  discard block
 block discarded – undo
4231 4231
     public static function is_utf32($str, bool $check_if_string_is_binary = true)
4232 4232
     {
4233 4233
         // init
4234
-        $str = (string) $str;
4234
+        $str = (string)$str;
4235 4235
         $str_chars = [];
4236 4236
 
4237 4237
         if (
@@ -4329,7 +4329,7 @@  discard block
 block discarded – undo
4329 4329
             return true;
4330 4330
         }
4331 4331
 
4332
-        return self::is_utf8_string((string) $str, $strict);
4332
+        return self::is_utf8_string((string)$str, $strict);
4333 4333
     }
4334 4334
 
4335 4335
     /**
@@ -4487,15 +4487,15 @@  discard block
 block discarded – undo
4487 4487
         $use_mb_functions = ($lang === null && !$try_to_keep_the_string_length);
4488 4488
 
4489 4489
         if ($encoding === 'UTF-8') {
4490
-            $str_part_two = (string) \mb_substr($str, 1);
4490
+            $str_part_two = (string)\mb_substr($str, 1);
4491 4491
 
4492 4492
             if ($use_mb_functions) {
4493 4493
                 $str_part_one = \mb_strtolower(
4494
-                    (string) \mb_substr($str, 0, 1)
4494
+                    (string)\mb_substr($str, 0, 1)
4495 4495
                 );
4496 4496
             } else {
4497 4497
                 $str_part_one = self::strtolower(
4498
-                    (string) \mb_substr($str, 0, 1),
4498
+                    (string)\mb_substr($str, 0, 1),
4499 4499
                     $encoding,
4500 4500
                     false,
4501 4501
                     $lang,
@@ -4505,10 +4505,10 @@  discard block
 block discarded – undo
4505 4505
         } else {
4506 4506
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
4507 4507
 
4508
-            $str_part_two = (string) self::substr($str, 1, null, $encoding);
4508
+            $str_part_two = (string)self::substr($str, 1, null, $encoding);
4509 4509
 
4510 4510
             $str_part_one = self::strtolower(
4511
-                (string) self::substr($str, 0, 1, $encoding),
4511
+                (string)self::substr($str, 0, 1, $encoding),
4512 4512
                 $encoding,
4513 4513
                 false,
4514 4514
                 $lang,
@@ -4516,7 +4516,7 @@  discard block
 block discarded – undo
4516 4516
             );
4517 4517
         }
4518 4518
 
4519
-        return $str_part_one . $str_part_two;
4519
+        return $str_part_one.$str_part_two;
4520 4520
     }
4521 4521
 
4522 4522
     /**
@@ -4665,7 +4665,7 @@  discard block
 block discarded – undo
4665 4665
             }
4666 4666
 
4667 4667
             /** @noinspection PhpComposerExtensionStubsInspection */
4668
-            return (string) \mb_ereg_replace($pattern, '', $str);
4668
+            return (string)\mb_ereg_replace($pattern, '', $str);
4669 4669
         }
4670 4670
 
4671 4671
         if ($chars !== null) {
@@ -4702,7 +4702,7 @@  discard block
 block discarded – undo
4702 4702
 
4703 4703
         $codepoint_max = \max($codepoints);
4704 4704
 
4705
-        return self::chr((int) $codepoint_max);
4705
+        return self::chr((int)$codepoint_max);
4706 4706
     }
4707 4707
 
4708 4708
     /**
@@ -4722,7 +4722,7 @@  discard block
 block discarded – undo
4722 4722
     {
4723 4723
         $bytes = self::chr_size_list($str);
4724 4724
         if ($bytes !== []) {
4725
-            return (int) \max($bytes);
4725
+            return (int)\max($bytes);
4726 4726
         }
4727 4727
 
4728 4728
         return 0;
@@ -4768,7 +4768,7 @@  discard block
 block discarded – undo
4768 4768
 
4769 4769
         $codepoint_min = \min($codepoints);
4770 4770
 
4771
-        return self::chr((int) $codepoint_min);
4771
+        return self::chr((int)$codepoint_min);
4772 4772
     }
4773 4773
 
4774 4774
     /**
@@ -4816,7 +4816,7 @@  discard block
 block discarded – undo
4816 4816
         static $STATIC_NORMALIZE_ENCODING_CACHE = [];
4817 4817
 
4818 4818
         // init
4819
-        $encoding = (string) $encoding;
4819
+        $encoding = (string)$encoding;
4820 4820
 
4821 4821
         if (!$encoding) {
4822 4822
             return $fallback;
@@ -4878,7 +4878,7 @@  discard block
 block discarded – undo
4878 4878
 
4879 4879
         $encoding_original = $encoding;
4880 4880
         $encoding = \strtoupper($encoding);
4881
-        $encoding_upper_helper = (string) \preg_replace('/[^a-zA-Z0-9]/u', '', $encoding);
4881
+        $encoding_upper_helper = (string)\preg_replace('/[^a-zA-Z0-9]/u', '', $encoding);
4882 4882
 
4883 4883
         $equivalences = [
4884 4884
             'ISO8859'     => 'ISO-8859-1',
@@ -5045,13 +5045,13 @@  discard block
 block discarded – undo
5045 5045
         static $CHAR_CACHE = [];
5046 5046
 
5047 5047
         // init
5048
-        $chr = (string) $chr;
5048
+        $chr = (string)$chr;
5049 5049
 
5050 5050
         if ($encoding !== 'UTF-8' && $encoding !== 'CP850') {
5051 5051
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
5052 5052
         }
5053 5053
 
5054
-        $cache_key = $chr . '_' . $encoding;
5054
+        $cache_key = $chr.'_'.$encoding;
5055 5055
         if (isset($CHAR_CACHE[$cache_key])) {
5056 5056
             return $CHAR_CACHE[$cache_key];
5057 5057
         }
@@ -5086,7 +5086,7 @@  discard block
 block discarded – undo
5086 5086
         //
5087 5087
 
5088 5088
         /** @noinspection CallableParameterUseCaseInTypeContextInspection - FP */
5089
-        $chr = \unpack('C*', (string) \substr($chr, 0, 4));
5089
+        $chr = \unpack('C*', (string)\substr($chr, 0, 4));
5090 5090
         /** @noinspection PhpSillyAssignmentInspection - hack for phpstan */
5091 5091
         /** @var int[] $chr - "unpack": only false if the format string contains errors */
5092 5092
         $chr = $chr;
@@ -5163,7 +5163,7 @@  discard block
 block discarded – undo
5163 5163
     public static function pcre_utf8_support(): bool
5164 5164
     {
5165 5165
         /** @noinspection PhpUsageOfSilenceOperatorInspection */
5166
-        return (bool) @\preg_match('//u', '');
5166
+        return (bool)@\preg_match('//u', '');
5167 5167
     }
5168 5168
 
5169 5169
     /**
@@ -5204,14 +5204,14 @@  discard block
 block discarded – undo
5204 5204
              * @psalm-suppress DocblockTypeContradiction
5205 5205
              */
5206 5206
             if (!\is_numeric($step)) {
5207
-                throw new \InvalidArgumentException('$step need to be a number, type given: ' . \gettype($step));
5207
+                throw new \InvalidArgumentException('$step need to be a number, type given: '.\gettype($step));
5208 5208
             }
5209 5209
 
5210 5210
             /**
5211 5211
              * @psalm-suppress RedundantConditionGivenDocblockType - false-positive from psalm?
5212 5212
              */
5213 5213
             if ($step <= 0) {
5214
-                throw new \InvalidArgumentException('$step need to be a positive number, given: ' . $step);
5214
+                throw new \InvalidArgumentException('$step need to be a positive number, given: '.$step);
5215 5215
             }
5216 5216
         }
5217 5217
 
@@ -5223,16 +5223,16 @@  discard block
 block discarded – undo
5223 5223
         $is_xdigit = false;
5224 5224
 
5225 5225
         /** @noinspection PhpComposerExtensionStubsInspection */
5226
-        if ($use_ctype && \ctype_digit((string) $var1) && \ctype_digit((string) $var2)) {
5226
+        if ($use_ctype && \ctype_digit((string)$var1) && \ctype_digit((string)$var2)) {
5227 5227
             $is_digit = true;
5228
-            $start = (int) $var1;
5228
+            $start = (int)$var1;
5229 5229
         } /** @noinspection PhpComposerExtensionStubsInspection */ elseif ($use_ctype && \ctype_xdigit($var1) && \ctype_xdigit($var2)) {
5230 5230
             $is_xdigit = true;
5231
-            $start = (int) self::hex_to_int((string) $var1);
5231
+            $start = (int)self::hex_to_int((string)$var1);
5232 5232
         } elseif (!$use_ctype && \is_numeric($var1)) {
5233
-            $start = (int) $var1;
5233
+            $start = (int)$var1;
5234 5234
         } else {
5235
-            $start = self::ord((string) $var1);
5235
+            $start = self::ord((string)$var1);
5236 5236
         }
5237 5237
 
5238 5238
         if (!$start) {
@@ -5240,13 +5240,13 @@  discard block
 block discarded – undo
5240 5240
         }
5241 5241
 
5242 5242
         if ($is_digit) {
5243
-            $end = (int) $var2;
5243
+            $end = (int)$var2;
5244 5244
         } elseif ($is_xdigit) {
5245
-            $end = (int) self::hex_to_int((string) $var2);
5245
+            $end = (int)self::hex_to_int((string)$var2);
5246 5246
         } elseif (!$use_ctype && \is_numeric($var2)) {
5247
-            $end = (int) $var2;
5247
+            $end = (int)$var2;
5248 5248
         } else {
5249
-            $end = self::ord((string) $var2);
5249
+            $end = self::ord((string)$var2);
5250 5250
         }
5251 5251
 
5252 5252
         if (!$end) {
@@ -5255,7 +5255,7 @@  discard block
 block discarded – undo
5255 5255
 
5256 5256
         $array = [];
5257 5257
         foreach (\range($start, $end, $step) as $i) {
5258
-            $array[] = (string) self::chr((int) $i, $encoding);
5258
+            $array[] = (string)self::chr((int)$i, $encoding);
5259 5259
         }
5260 5260
 
5261 5261
         return $array;
@@ -5351,8 +5351,8 @@  discard block
 block discarded – undo
5351 5351
             $delimiter = '/';
5352 5352
         }
5353 5353
 
5354
-        return (string) \preg_replace(
5355
-            $delimiter . $pattern . $delimiter . 'u' . $options,
5354
+        return (string)\preg_replace(
5355
+            $delimiter.$pattern.$delimiter.'u'.$options,
5356 5356
             $replacement,
5357 5357
             $str
5358 5358
         );
@@ -5404,7 +5404,7 @@  discard block
 block discarded – undo
5404 5404
 
5405 5405
                 $str_length -= $bom_byte_length;
5406 5406
 
5407
-                $str = (string) $str_tmp;
5407
+                $str = (string)$str_tmp;
5408 5408
             }
5409 5409
         }
5410 5410
 
@@ -5435,7 +5435,7 @@  discard block
 block discarded – undo
5435 5435
          */
5436 5436
         if (\is_array($what)) {
5437 5437
             foreach ($what as $item) {
5438
-                $str = (string) \preg_replace('/(' . \preg_quote($item, '/') . ')+/u', $item, $str);
5438
+                $str = (string)\preg_replace('/('.\preg_quote($item, '/').')+/u', $item, $str);
5439 5439
             }
5440 5440
         }
5441 5441
 
@@ -5473,7 +5473,7 @@  discard block
 block discarded – undo
5473 5473
      */
5474 5474
     public static function remove_html_breaks(string $str, string $replacement = ''): string
5475 5475
     {
5476
-        return (string) \preg_replace("#/\r\n|\r|\n|<br.*/?>#isU", $replacement, $str);
5476
+        return (string)\preg_replace("#/\r\n|\r|\n|<br.*/?>#isU", $replacement, $str);
5477 5477
     }
5478 5478
 
5479 5479
     /**
@@ -5537,17 +5537,17 @@  discard block
 block discarded – undo
5537 5537
             \strpos($str, $substring) === 0
5538 5538
         ) {
5539 5539
             if ($encoding === 'UTF-8') {
5540
-                return (string) \mb_substr(
5540
+                return (string)\mb_substr(
5541 5541
                     $str,
5542
-                    (int) \mb_strlen($substring)
5542
+                    (int)\mb_strlen($substring)
5543 5543
                 );
5544 5544
             }
5545 5545
 
5546 5546
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
5547 5547
 
5548
-            return (string) self::substr(
5548
+            return (string)self::substr(
5549 5549
                 $str,
5550
-                (int) self::strlen($substring, $encoding),
5550
+                (int)self::strlen($substring, $encoding),
5551 5551
                 null,
5552 5552
                 $encoding
5553 5553
             );
@@ -5575,19 +5575,19 @@  discard block
 block discarded – undo
5575 5575
     ): string {
5576 5576
         if ($substring && \substr($str, -\strlen($substring)) === $substring) {
5577 5577
             if ($encoding === 'UTF-8') {
5578
-                return (string) \mb_substr(
5578
+                return (string)\mb_substr(
5579 5579
                     $str,
5580 5580
                     0,
5581
-                    (int) \mb_strlen($str) - (int) \mb_strlen($substring)
5581
+                    (int)\mb_strlen($str) - (int)\mb_strlen($substring)
5582 5582
                 );
5583 5583
             }
5584 5584
 
5585 5585
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
5586 5586
 
5587
-            return (string) self::substr(
5587
+            return (string)self::substr(
5588 5588
                 $str,
5589 5589
                 0,
5590
-                (int) self::strlen($str, $encoding) - (int) self::strlen($substring, $encoding),
5590
+                (int)self::strlen($str, $encoding) - (int)self::strlen($substring, $encoding),
5591 5591
                 $encoding
5592 5592
             );
5593 5593
         }
@@ -5690,7 +5690,7 @@  discard block
 block discarded – undo
5690 5690
             /** @noinspection PhpUsageOfSilenceOperatorInspection - ignore "Unknown character" warnings, it's working anyway */
5691 5691
             @\mb_substitute_character($replacement_char_helper);
5692 5692
             // the polyfill maybe return false, so cast to string
5693
-            $str = (string) \mb_convert_encoding($str, 'UTF-8', 'UTF-8');
5693
+            $str = (string)\mb_convert_encoding($str, 'UTF-8', 'UTF-8');
5694 5694
             \mb_substitute_character($save);
5695 5695
         }
5696 5696
 
@@ -5736,7 +5736,7 @@  discard block
 block discarded – undo
5736 5736
             }
5737 5737
 
5738 5738
             /** @noinspection PhpComposerExtensionStubsInspection */
5739
-            return (string) \mb_ereg_replace($pattern, '', $str);
5739
+            return (string)\mb_ereg_replace($pattern, '', $str);
5740 5740
         }
5741 5741
 
5742 5742
         if ($chars !== null) {
@@ -5766,7 +5766,7 @@  discard block
 block discarded – undo
5766 5766
         $html .= '<pre>';
5767 5767
         /** @noinspection AlterInForeachInspection */
5768 5768
         foreach (self::$SUPPORT as $key => &$value) {
5769
-            $html .= $key . ' - ' . \print_r($value, true) . "\n<br>";
5769
+            $html .= $key.' - '.\print_r($value, true)."\n<br>";
5770 5770
         }
5771 5771
         $html .= '</pre>';
5772 5772
 
@@ -5808,7 +5808,7 @@  discard block
 block discarded – undo
5808 5808
             return $char;
5809 5809
         }
5810 5810
 
5811
-        return '&#' . self::ord($char, $encoding) . ';';
5811
+        return '&#'.self::ord($char, $encoding).';';
5812 5812
     }
5813 5813
 
5814 5814
     /**
@@ -5912,11 +5912,11 @@  discard block
 block discarded – undo
5912 5912
             $lang,
5913 5913
             $try_to_keep_the_string_length
5914 5914
         );
5915
-        $str = (string) \preg_replace('/^[-_]+/', '', $str);
5915
+        $str = (string)\preg_replace('/^[-_]+/', '', $str);
5916 5916
 
5917 5917
         $use_mb_functions = $lang === null && !$try_to_keep_the_string_length;
5918 5918
 
5919
-        $str = (string) \preg_replace_callback(
5919
+        $str = (string)\preg_replace_callback(
5920 5920
             '/[-_\\s]+(.)?/u',
5921 5921
             /**
5922 5922
              * @param array $match
@@ -5925,7 +5925,7 @@  discard block
 block discarded – undo
5925 5925
              *
5926 5926
              * @return string
5927 5927
              */
5928
-            static function (array $match) use ($use_mb_functions, $encoding, $lang, $try_to_keep_the_string_length): string {
5928
+            static function(array $match) use ($use_mb_functions, $encoding, $lang, $try_to_keep_the_string_length): string {
5929 5929
                 if (isset($match[1])) {
5930 5930
                     if ($use_mb_functions) {
5931 5931
                         if ($encoding === 'UTF-8') {
@@ -5943,7 +5943,7 @@  discard block
 block discarded – undo
5943 5943
             $str
5944 5944
         );
5945 5945
 
5946
-        return (string) \preg_replace_callback(
5946
+        return (string)\preg_replace_callback(
5947 5947
             '/[\\p{N}]+(.)?/u',
5948 5948
             /**
5949 5949
              * @param array $match
@@ -5952,7 +5952,7 @@  discard block
 block discarded – undo
5952 5952
              *
5953 5953
              * @return string
5954 5954
              */
5955
-            static function (array $match) use ($use_mb_functions, $encoding, $clean_utf8, $lang, $try_to_keep_the_string_length): string {
5955
+            static function(array $match) use ($use_mb_functions, $encoding, $clean_utf8, $lang, $try_to_keep_the_string_length): string {
5956 5956
                 if ($use_mb_functions) {
5957 5957
                     if ($encoding === 'UTF-8') {
5958 5958
                         return \mb_strtoupper($match[0]);
@@ -6151,7 +6151,7 @@  discard block
 block discarded – undo
6151 6151
     ): string {
6152 6152
         if (self::$SUPPORT['mbstring'] === true) {
6153 6153
             /** @noinspection PhpComposerExtensionStubsInspection */
6154
-            $str = (string) \mb_ereg_replace('\\B(\\p{Lu})', '-\1', \trim($str));
6154
+            $str = (string)\mb_ereg_replace('\\B(\\p{Lu})', '-\1', \trim($str));
6155 6155
 
6156 6156
             $use_mb_functions = $lang === null && !$try_to_keep_the_string_length;
6157 6157
             if ($use_mb_functions && $encoding === 'UTF-8') {
@@ -6161,10 +6161,10 @@  discard block
 block discarded – undo
6161 6161
             }
6162 6162
 
6163 6163
             /** @noinspection PhpComposerExtensionStubsInspection */
6164
-            return (string) \mb_ereg_replace('[\\-_\\s]+', $delimiter, $str);
6164
+            return (string)\mb_ereg_replace('[\\-_\\s]+', $delimiter, $str);
6165 6165
         }
6166 6166
 
6167
-        $str = (string) \preg_replace('/\\B(\\p{Lu})/u', '-\1', \trim($str));
6167
+        $str = (string)\preg_replace('/\\B(\\p{Lu})/u', '-\1', \trim($str));
6168 6168
 
6169 6169
         $use_mb_functions = $lang === null && !$try_to_keep_the_string_length;
6170 6170
         if ($use_mb_functions && $encoding === 'UTF-8') {
@@ -6173,7 +6173,7 @@  discard block
 block discarded – undo
6173 6173
             $str = self::strtolower($str, $encoding, $clean_utf8, $lang, $try_to_keep_the_string_length);
6174 6174
         }
6175 6175
 
6176
-        return (string) \preg_replace('/[\\-_\\s]+/u', $delimiter, $str);
6176
+        return (string)\preg_replace('/[\\-_\\s]+/u', $delimiter, $str);
6177 6177
     }
6178 6178
 
6179 6179
     /**
@@ -6197,7 +6197,7 @@  discard block
 block discarded – undo
6197 6197
     public static function str_detect_encoding($str)
6198 6198
     {
6199 6199
         // init
6200
-        $str = (string) $str;
6200
+        $str = (string)$str;
6201 6201
 
6202 6202
         //
6203 6203
         // 1.) check binary strings (010001001...) like UTF-16 / UTF-32 / PDF / Images / ...
@@ -6299,7 +6299,7 @@  discard block
 block discarded – undo
6299 6299
         foreach (self::$ENCODINGS as $encoding_tmp) {
6300 6300
             // INFO: //IGNORE but still throw notice
6301 6301
             /** @noinspection PhpUsageOfSilenceOperatorInspection */
6302
-            if ((string) @\iconv($encoding_tmp, $encoding_tmp . '//IGNORE', $str) === $str) {
6302
+            if ((string)@\iconv($encoding_tmp, $encoding_tmp.'//IGNORE', $str) === $str) {
6303 6303
                 return $encoding_tmp;
6304 6304
             }
6305 6305
         }
@@ -6407,7 +6407,7 @@  discard block
 block discarded – undo
6407 6407
             return $str;
6408 6408
         }
6409 6409
 
6410
-        return $substring . $str;
6410
+        return $substring.$str;
6411 6411
     }
6412 6412
 
6413 6413
     /**
@@ -6703,27 +6703,27 @@  discard block
 block discarded – undo
6703 6703
         string $encoding = 'UTF-8'
6704 6704
     ): string {
6705 6705
         if ($encoding === 'UTF-8') {
6706
-            $len = (int) \mb_strlen($str);
6706
+            $len = (int)\mb_strlen($str);
6707 6707
             if ($index > $len) {
6708 6708
                 return $str;
6709 6709
             }
6710 6710
 
6711 6711
             /** @noinspection UnnecessaryCastingInspection */
6712
-            return (string) \mb_substr($str, 0, $index) .
6713
-                   $substring .
6714
-                   (string) \mb_substr($str, $index, $len);
6712
+            return (string)\mb_substr($str, 0, $index).
6713
+                   $substring.
6714
+                   (string)\mb_substr($str, $index, $len);
6715 6715
         }
6716 6716
 
6717 6717
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
6718 6718
 
6719
-        $len = (int) self::strlen($str, $encoding);
6719
+        $len = (int)self::strlen($str, $encoding);
6720 6720
         if ($index > $len) {
6721 6721
             return $str;
6722 6722
         }
6723 6723
 
6724
-        return ((string) self::substr($str, 0, $index, $encoding)) .
6725
-               $substring .
6726
-               ((string) self::substr($str, $index, $len, $encoding));
6724
+        return ((string)self::substr($str, 0, $index, $encoding)).
6725
+               $substring.
6726
+               ((string)self::substr($str, $index, $len, $encoding));
6727 6727
     }
6728 6728
 
6729 6729
     /**
@@ -6763,15 +6763,15 @@  discard block
 block discarded – undo
6763 6763
      */
6764 6764
     public static function str_ireplace($search, $replacement, $subject, &$count = null)
6765 6765
     {
6766
-        $search = (array) $search;
6766
+        $search = (array)$search;
6767 6767
 
6768 6768
         /** @noinspection AlterInForeachInspection */
6769 6769
         foreach ($search as &$s) {
6770
-            $s = (string) $s;
6770
+            $s = (string)$s;
6771 6771
             if ($s === '') {
6772 6772
                 $s = '/^(?<=.)$/';
6773 6773
             } else {
6774
-                $s = '/' . \preg_quote($s, '/') . '/ui';
6774
+                $s = '/'.\preg_quote($s, '/').'/ui';
6775 6775
             }
6776 6776
         }
6777 6777
 
@@ -6819,12 +6819,12 @@  discard block
 block discarded – undo
6819 6819
         }
6820 6820
 
6821 6821
         if ($search === '') {
6822
-            return $str . $replacement;
6822
+            return $str.$replacement;
6823 6823
         }
6824 6824
 
6825 6825
         $searchLength = \strlen($search);
6826 6826
         if (\strncasecmp($str, $search, $searchLength) === 0) {
6827
-            return $replacement . \substr($str, $searchLength);
6827
+            return $replacement.\substr($str, $searchLength);
6828 6828
         }
6829 6829
 
6830 6830
         return $str;
@@ -6855,11 +6855,11 @@  discard block
 block discarded – undo
6855 6855
         }
6856 6856
 
6857 6857
         if ($search === '') {
6858
-            return $str . $replacement;
6858
+            return $str.$replacement;
6859 6859
         }
6860 6860
 
6861 6861
         if (\stripos($str, $search, \strlen($str) - \strlen($search)) !== false) {
6862
-            $str = \substr($str, 0, -\strlen($search)) . $replacement;
6862
+            $str = \substr($str, 0, -\strlen($search)).$replacement;
6863 6863
         }
6864 6864
 
6865 6865
         return $str;
@@ -6951,15 +6951,15 @@  discard block
 block discarded – undo
6951 6951
         }
6952 6952
 
6953 6953
         if ($encoding === 'UTF-8') {
6954
-            return (string) \mb_substr(
6954
+            return (string)\mb_substr(
6955 6955
                 $str,
6956
-                $offset + (int) \mb_strlen($separator)
6956
+                $offset + (int)\mb_strlen($separator)
6957 6957
             );
6958 6958
         }
6959 6959
 
6960
-        return (string) self::substr(
6960
+        return (string)self::substr(
6961 6961
             $str,
6962
-            $offset + (int) self::strlen($separator, $encoding),
6962
+            $offset + (int)self::strlen($separator, $encoding),
6963 6963
             null,
6964 6964
             $encoding
6965 6965
         );
@@ -6991,15 +6991,15 @@  discard block
 block discarded – undo
6991 6991
         }
6992 6992
 
6993 6993
         if ($encoding === 'UTF-8') {
6994
-            return (string) \mb_substr(
6994
+            return (string)\mb_substr(
6995 6995
                 $str,
6996
-                $offset + (int) self::strlen($separator)
6996
+                $offset + (int)self::strlen($separator)
6997 6997
             );
6998 6998
         }
6999 6999
 
7000
-        return (string) self::substr(
7000
+        return (string)self::substr(
7001 7001
             $str,
7002
-            $offset + (int) self::strlen($separator, $encoding),
7002
+            $offset + (int)self::strlen($separator, $encoding),
7003 7003
             null,
7004 7004
             $encoding
7005 7005
         );
@@ -7031,10 +7031,10 @@  discard block
 block discarded – undo
7031 7031
         }
7032 7032
 
7033 7033
         if ($encoding === 'UTF-8') {
7034
-            return (string) \mb_substr($str, 0, $offset);
7034
+            return (string)\mb_substr($str, 0, $offset);
7035 7035
         }
7036 7036
 
7037
-        return (string) self::substr($str, 0, $offset, $encoding);
7037
+        return (string)self::substr($str, 0, $offset, $encoding);
7038 7038
     }
7039 7039
 
7040 7040
     /**
@@ -7063,7 +7063,7 @@  discard block
 block discarded – undo
7063 7063
                 return '';
7064 7064
             }
7065 7065
 
7066
-            return (string) \mb_substr($str, 0, $offset);
7066
+            return (string)\mb_substr($str, 0, $offset);
7067 7067
         }
7068 7068
 
7069 7069
         $offset = self::strripos($str, $separator, 0, $encoding);
@@ -7071,7 +7071,7 @@  discard block
 block discarded – undo
7071 7071
             return '';
7072 7072
         }
7073 7073
 
7074
-        return (string) self::substr($str, 0, $offset, $encoding);
7074
+        return (string)self::substr($str, 0, $offset, $encoding);
7075 7075
     }
7076 7076
 
7077 7077
     /**
@@ -7173,12 +7173,12 @@  discard block
 block discarded – undo
7173 7173
         }
7174 7174
 
7175 7175
         if ($encoding === 'UTF-8') {
7176
-            return (string) \mb_substr($str, -$n);
7176
+            return (string)\mb_substr($str, -$n);
7177 7177
         }
7178 7178
 
7179 7179
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
7180 7180
 
7181
-        return (string) self::substr($str, -$n, null, $encoding);
7181
+        return (string)self::substr($str, -$n, null, $encoding);
7182 7182
     }
7183 7183
 
7184 7184
     /**
@@ -7204,21 +7204,21 @@  discard block
 block discarded – undo
7204 7204
         }
7205 7205
 
7206 7206
         if ($encoding === 'UTF-8') {
7207
-            if ((int) \mb_strlen($str) <= $length) {
7207
+            if ((int)\mb_strlen($str) <= $length) {
7208 7208
                 return $str;
7209 7209
             }
7210 7210
 
7211 7211
             /** @noinspection UnnecessaryCastingInspection */
7212
-            return (string) \mb_substr($str, 0, $length - (int) self::strlen($str_add_on)) . $str_add_on;
7212
+            return (string)\mb_substr($str, 0, $length - (int)self::strlen($str_add_on)).$str_add_on;
7213 7213
         }
7214 7214
 
7215 7215
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
7216 7216
 
7217
-        if ((int) self::strlen($str, $encoding) <= $length) {
7217
+        if ((int)self::strlen($str, $encoding) <= $length) {
7218 7218
             return $str;
7219 7219
         }
7220 7220
 
7221
-        return ((string) self::substr($str, 0, $length - (int) self::strlen($str_add_on), $encoding)) . $str_add_on;
7221
+        return ((string)self::substr($str, 0, $length - (int)self::strlen($str_add_on), $encoding)).$str_add_on;
7222 7222
     }
7223 7223
 
7224 7224
     /**
@@ -7247,12 +7247,12 @@  discard block
 block discarded – undo
7247 7247
 
7248 7248
         if ($encoding === 'UTF-8') {
7249 7249
             /** @noinspection UnnecessaryCastingInspection */
7250
-            if ((int) \mb_strlen($str) <= $length) {
7250
+            if ((int)\mb_strlen($str) <= $length) {
7251 7251
                 return $str;
7252 7252
             }
7253 7253
 
7254 7254
             if (\mb_substr($str, $length - 1, 1) === ' ') {
7255
-                return ((string) \mb_substr($str, 0, $length - 1)) . $str_add_on;
7255
+                return ((string)\mb_substr($str, 0, $length - 1)).$str_add_on;
7256 7256
             }
7257 7257
 
7258 7258
             $str = \mb_substr($str, 0, $length);
@@ -7261,33 +7261,33 @@  discard block
 block discarded – undo
7261 7261
             $new_str = \implode(' ', $array);
7262 7262
 
7263 7263
             if ($new_str === '') {
7264
-                return ((string) \mb_substr($str, 0, $length - 1)) . $str_add_on;
7264
+                return ((string)\mb_substr($str, 0, $length - 1)).$str_add_on;
7265 7265
             }
7266 7266
         } else {
7267
-            if ((int) self::strlen($str, $encoding) <= $length) {
7267
+            if ((int)self::strlen($str, $encoding) <= $length) {
7268 7268
                 return $str;
7269 7269
             }
7270 7270
 
7271 7271
             if (self::substr($str, $length - 1, 1, $encoding) === ' ') {
7272
-                return ((string) self::substr($str, 0, $length - 1, $encoding)) . $str_add_on;
7272
+                return ((string)self::substr($str, 0, $length - 1, $encoding)).$str_add_on;
7273 7273
             }
7274 7274
 
7275 7275
             /** @noinspection CallableParameterUseCaseInTypeContextInspection - FP */
7276 7276
             $str = self::substr($str, 0, $length, $encoding);
7277 7277
             /** @noinspection CallableParameterUseCaseInTypeContextInspection - FP */
7278 7278
             if ($str === false) {
7279
-                return '' . $str_add_on;
7279
+                return ''.$str_add_on;
7280 7280
             }
7281 7281
 
7282 7282
             $array = \explode(' ', $str, -1);
7283 7283
             $new_str = \implode(' ', $array);
7284 7284
 
7285 7285
             if ($new_str === '') {
7286
-                return ((string) self::substr($str, 0, $length - 1, $encoding)) . $str_add_on;
7286
+                return ((string)self::substr($str, 0, $length - 1, $encoding)).$str_add_on;
7287 7287
             }
7288 7288
         }
7289 7289
 
7290
-        return $new_str . $str_add_on;
7290
+        return $new_str.$str_add_on;
7291 7291
     }
7292 7292
 
7293 7293
     /**
@@ -7310,7 +7310,7 @@  discard block
 block discarded – undo
7310 7310
         $longest_common_prefix = '';
7311 7311
 
7312 7312
         if ($encoding === 'UTF-8') {
7313
-            $max_length = (int) \min(
7313
+            $max_length = (int)\min(
7314 7314
                 \mb_strlen($str1),
7315 7315
                 \mb_strlen($str2)
7316 7316
             );
@@ -7331,7 +7331,7 @@  discard block
 block discarded – undo
7331 7331
         } else {
7332 7332
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
7333 7333
 
7334
-            $max_length = (int) \min(
7334
+            $max_length = (int)\min(
7335 7335
                 self::strlen($str1, $encoding),
7336 7336
                 self::strlen($str2, $encoding)
7337 7337
             );
@@ -7380,13 +7380,13 @@  discard block
 block discarded – undo
7380 7380
         // http://en.wikipedia.org/wiki/Longest_common_substring_problem
7381 7381
 
7382 7382
         if ($encoding === 'UTF-8') {
7383
-            $str_length = (int) \mb_strlen($str1);
7384
-            $other_length = (int) \mb_strlen($str2);
7383
+            $str_length = (int)\mb_strlen($str1);
7384
+            $other_length = (int)\mb_strlen($str2);
7385 7385
         } else {
7386 7386
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
7387 7387
 
7388
-            $str_length = (int) self::strlen($str1, $encoding);
7389
-            $other_length = (int) self::strlen($str2, $encoding);
7388
+            $str_length = (int)self::strlen($str1, $encoding);
7389
+            $other_length = (int)self::strlen($str2, $encoding);
7390 7390
         }
7391 7391
 
7392 7392
         // Return if either string is empty
@@ -7439,10 +7439,10 @@  discard block
 block discarded – undo
7439 7439
         }
7440 7440
 
7441 7441
         if ($encoding === 'UTF-8') {
7442
-            return (string) \mb_substr($str1, $end - $len, $len);
7442
+            return (string)\mb_substr($str1, $end - $len, $len);
7443 7443
         }
7444 7444
 
7445
-        return (string) self::substr($str1, $end - $len, $len, $encoding);
7445
+        return (string)self::substr($str1, $end - $len, $len, $encoding);
7446 7446
     }
7447 7447
 
7448 7448
     /**
@@ -7466,7 +7466,7 @@  discard block
 block discarded – undo
7466 7466
         }
7467 7467
 
7468 7468
         if ($encoding === 'UTF-8') {
7469
-            $max_length = (int) \min(
7469
+            $max_length = (int)\min(
7470 7470
                 \mb_strlen($str1, $encoding),
7471 7471
                 \mb_strlen($str2, $encoding)
7472 7472
             );
@@ -7480,7 +7480,7 @@  discard block
 block discarded – undo
7480 7480
                     &&
7481 7481
                     $char === \mb_substr($str2, -$i, 1)
7482 7482
                 ) {
7483
-                    $longest_common_suffix = $char . $longest_common_suffix;
7483
+                    $longest_common_suffix = $char.$longest_common_suffix;
7484 7484
                 } else {
7485 7485
                     break;
7486 7486
                 }
@@ -7488,7 +7488,7 @@  discard block
 block discarded – undo
7488 7488
         } else {
7489 7489
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
7490 7490
 
7491
-            $max_length = (int) \min(
7491
+            $max_length = (int)\min(
7492 7492
                 self::strlen($str1, $encoding),
7493 7493
                 self::strlen($str2, $encoding)
7494 7494
             );
@@ -7502,7 +7502,7 @@  discard block
 block discarded – undo
7502 7502
                     &&
7503 7503
                     $char === self::substr($str2, -$i, 1, $encoding)
7504 7504
                 ) {
7505
-                    $longest_common_suffix = $char . $longest_common_suffix;
7505
+                    $longest_common_suffix = $char.$longest_common_suffix;
7506 7506
                 } else {
7507 7507
                     break;
7508 7508
                 }
@@ -7525,7 +7525,7 @@  discard block
 block discarded – undo
7525 7525
      */
7526 7526
     public static function str_matches_pattern(string $str, string $pattern): bool
7527 7527
     {
7528
-        return (bool) \preg_match('/' . $pattern . '/u', $str);
7528
+        return (bool)\preg_match('/'.$pattern.'/u', $str);
7529 7529
     }
7530 7530
 
7531 7531
     /**
@@ -7545,7 +7545,7 @@  discard block
 block discarded – undo
7545 7545
     public static function str_offset_exists(string $str, int $offset, string $encoding = 'UTF-8'): bool
7546 7546
     {
7547 7547
         // init
7548
-        $length = (int) self::strlen($str, $encoding);
7548
+        $length = (int)self::strlen($str, $encoding);
7549 7549
 
7550 7550
         if ($offset >= 0) {
7551 7551
             return $length > $offset;
@@ -7574,7 +7574,7 @@  discard block
 block discarded – undo
7574 7574
     public static function str_offset_get(string $str, int $index, string $encoding = 'UTF-8'): string
7575 7575
     {
7576 7576
         // init
7577
-        $length = (int) self::strlen($str);
7577
+        $length = (int)self::strlen($str);
7578 7578
 
7579 7579
         if (
7580 7580
             ($index >= 0 && $length <= $index)
@@ -7618,7 +7618,7 @@  discard block
 block discarded – undo
7618 7618
             return $str;
7619 7619
         }
7620 7620
 
7621
-        if ($pad_type !== (int) $pad_type) {
7621
+        if ($pad_type !== (int)$pad_type) {
7622 7622
             if ($pad_type === 'left') {
7623 7623
                 $pad_type = \STR_PAD_LEFT;
7624 7624
             } elseif ($pad_type === 'right') {
@@ -7627,23 +7627,23 @@  discard block
 block discarded – undo
7627 7627
                 $pad_type = \STR_PAD_BOTH;
7628 7628
             } else {
7629 7629
                 throw new \InvalidArgumentException(
7630
-                    'Pad expects $pad_type to be "STR_PAD_*" or ' . "to be one of 'left', 'right' or 'both'"
7630
+                    'Pad expects $pad_type to be "STR_PAD_*" or '."to be one of 'left', 'right' or 'both'"
7631 7631
                 );
7632 7632
             }
7633 7633
         }
7634 7634
 
7635 7635
         if ($encoding === 'UTF-8') {
7636
-            $str_length = (int) \mb_strlen($str);
7636
+            $str_length = (int)\mb_strlen($str);
7637 7637
 
7638 7638
             if ($pad_length >= $str_length) {
7639 7639
                 switch ($pad_type) {
7640 7640
                     case \STR_PAD_LEFT:
7641
-                        $ps_length = (int) \mb_strlen($pad_string);
7641
+                        $ps_length = (int)\mb_strlen($pad_string);
7642 7642
 
7643 7643
                         $diff = ($pad_length - $str_length);
7644 7644
 
7645
-                        $pre = (string) \mb_substr(
7646
-                            \str_repeat($pad_string, (int) \ceil($diff / $ps_length)),
7645
+                        $pre = (string)\mb_substr(
7646
+                            \str_repeat($pad_string, (int)\ceil($diff / $ps_length)),
7647 7647
                             0,
7648 7648
                             $diff
7649 7649
                         );
@@ -7654,16 +7654,16 @@  discard block
 block discarded – undo
7654 7654
                     case \STR_PAD_BOTH:
7655 7655
                         $diff = ($pad_length - $str_length);
7656 7656
 
7657
-                        $ps_length_left = (int) \floor($diff / 2);
7657
+                        $ps_length_left = (int)\floor($diff / 2);
7658 7658
 
7659
-                        $ps_length_right = (int) \ceil($diff / 2);
7659
+                        $ps_length_right = (int)\ceil($diff / 2);
7660 7660
 
7661
-                        $pre = (string) \mb_substr(
7661
+                        $pre = (string)\mb_substr(
7662 7662
                             \str_repeat($pad_string, $ps_length_left),
7663 7663
                             0,
7664 7664
                             $ps_length_left
7665 7665
                         );
7666
-                        $post = (string) \mb_substr(
7666
+                        $post = (string)\mb_substr(
7667 7667
                             \str_repeat($pad_string, $ps_length_right),
7668 7668
                             0,
7669 7669
                             $ps_length_right
@@ -7673,19 +7673,19 @@  discard block
 block discarded – undo
7673 7673
 
7674 7674
                     case \STR_PAD_RIGHT:
7675 7675
                     default:
7676
-                        $ps_length = (int) \mb_strlen($pad_string);
7676
+                        $ps_length = (int)\mb_strlen($pad_string);
7677 7677
 
7678 7678
                         $diff = ($pad_length - $str_length);
7679 7679
 
7680
-                        $post = (string) \mb_substr(
7681
-                            \str_repeat($pad_string, (int) \ceil($diff / $ps_length)),
7680
+                        $post = (string)\mb_substr(
7681
+                            \str_repeat($pad_string, (int)\ceil($diff / $ps_length)),
7682 7682
                             0,
7683 7683
                             $diff
7684 7684
                         );
7685 7685
                         $pre = '';
7686 7686
                 }
7687 7687
 
7688
-                return $pre . $str . $post;
7688
+                return $pre.$str.$post;
7689 7689
             }
7690 7690
 
7691 7691
             return $str;
@@ -7693,17 +7693,17 @@  discard block
 block discarded – undo
7693 7693
 
7694 7694
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
7695 7695
 
7696
-        $str_length = (int) self::strlen($str, $encoding);
7696
+        $str_length = (int)self::strlen($str, $encoding);
7697 7697
 
7698 7698
         if ($pad_length >= $str_length) {
7699 7699
             switch ($pad_type) {
7700 7700
                 case \STR_PAD_LEFT:
7701
-                    $ps_length = (int) self::strlen($pad_string, $encoding);
7701
+                    $ps_length = (int)self::strlen($pad_string, $encoding);
7702 7702
 
7703 7703
                     $diff = ($pad_length - $str_length);
7704 7704
 
7705
-                    $pre = (string) self::substr(
7706
-                        \str_repeat($pad_string, (int) \ceil($diff / $ps_length)),
7705
+                    $pre = (string)self::substr(
7706
+                        \str_repeat($pad_string, (int)\ceil($diff / $ps_length)),
7707 7707
                         0,
7708 7708
                         $diff,
7709 7709
                         $encoding
@@ -7715,17 +7715,17 @@  discard block
 block discarded – undo
7715 7715
                 case \STR_PAD_BOTH:
7716 7716
                     $diff = ($pad_length - $str_length);
7717 7717
 
7718
-                    $ps_length_left = (int) \floor($diff / 2);
7718
+                    $ps_length_left = (int)\floor($diff / 2);
7719 7719
 
7720
-                    $ps_length_right = (int) \ceil($diff / 2);
7720
+                    $ps_length_right = (int)\ceil($diff / 2);
7721 7721
 
7722
-                    $pre = (string) self::substr(
7722
+                    $pre = (string)self::substr(
7723 7723
                         \str_repeat($pad_string, $ps_length_left),
7724 7724
                         0,
7725 7725
                         $ps_length_left,
7726 7726
                         $encoding
7727 7727
                     );
7728
-                    $post = (string) self::substr(
7728
+                    $post = (string)self::substr(
7729 7729
                         \str_repeat($pad_string, $ps_length_right),
7730 7730
                         0,
7731 7731
                         $ps_length_right,
@@ -7736,12 +7736,12 @@  discard block
 block discarded – undo
7736 7736
 
7737 7737
                 case \STR_PAD_RIGHT:
7738 7738
                 default:
7739
-                    $ps_length = (int) self::strlen($pad_string, $encoding);
7739
+                    $ps_length = (int)self::strlen($pad_string, $encoding);
7740 7740
 
7741 7741
                     $diff = ($pad_length - $str_length);
7742 7742
 
7743
-                    $post = (string) self::substr(
7744
-                        \str_repeat($pad_string, (int) \ceil($diff / $ps_length)),
7743
+                    $post = (string)self::substr(
7744
+                        \str_repeat($pad_string, (int)\ceil($diff / $ps_length)),
7745 7745
                         0,
7746 7746
                         $diff,
7747 7747
                         $encoding
@@ -7749,7 +7749,7 @@  discard block
 block discarded – undo
7749 7749
                     $pre = '';
7750 7750
             }
7751 7751
 
7752
-            return $pre . $str . $post;
7752
+            return $pre.$str.$post;
7753 7753
         }
7754 7754
 
7755 7755
         return $str;
@@ -7960,12 +7960,12 @@  discard block
 block discarded – undo
7960 7960
         }
7961 7961
 
7962 7962
         if ($search === '') {
7963
-            return $str . $replacement;
7963
+            return $str.$replacement;
7964 7964
         }
7965 7965
 
7966 7966
         $searchLength = \strlen($search);
7967 7967
         if (\strncmp($str, $search, $searchLength) === 0) {
7968
-            return $replacement . \substr($str, $searchLength);
7968
+            return $replacement.\substr($str, $searchLength);
7969 7969
         }
7970 7970
 
7971 7971
         return $str;
@@ -7999,11 +7999,11 @@  discard block
 block discarded – undo
7999 7999
         }
8000 8000
 
8001 8001
         if ($search === '') {
8002
-            return $str . $replacement;
8002
+            return $str.$replacement;
8003 8003
         }
8004 8004
 
8005 8005
         if (\strpos($str, $search, \strlen($str) - \strlen($search)) !== false) {
8006
-            $str = \substr($str, 0, -\strlen($search)) . $replacement;
8006
+            $str = \substr($str, 0, -\strlen($search)).$replacement;
8007 8007
         }
8008 8008
 
8009 8009
         return $str;
@@ -8037,7 +8037,7 @@  discard block
 block discarded – undo
8037 8037
                 $subject,
8038 8038
                 $replace,
8039 8039
                 $pos,
8040
-                (int) self::strlen($search)
8040
+                (int)self::strlen($search)
8041 8041
             );
8042 8042
         }
8043 8043
 
@@ -8071,7 +8071,7 @@  discard block
 block discarded – undo
8071 8071
                 $subject,
8072 8072
                 $replace,
8073 8073
                 $pos,
8074
-                (int) self::strlen($search)
8074
+                (int)self::strlen($search)
8075 8075
             );
8076 8076
         }
8077 8077
 
@@ -8094,7 +8094,7 @@  discard block
 block discarded – undo
8094 8094
     public static function str_shuffle(string $str, string $encoding = 'UTF-8'): string
8095 8095
     {
8096 8096
         if ($encoding === 'UTF-8') {
8097
-            $indexes = \range(0, (int) \mb_strlen($str) - 1);
8097
+            $indexes = \range(0, (int)\mb_strlen($str) - 1);
8098 8098
             /** @noinspection NonSecureShuffleUsageInspection */
8099 8099
             \shuffle($indexes);
8100 8100
 
@@ -8110,7 +8110,7 @@  discard block
 block discarded – undo
8110 8110
         } else {
8111 8111
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
8112 8112
 
8113
-            $indexes = \range(0, (int) self::strlen($str, $encoding) - 1);
8113
+            $indexes = \range(0, (int)self::strlen($str, $encoding) - 1);
8114 8114
             /** @noinspection NonSecureShuffleUsageInspection */
8115 8115
             \shuffle($indexes);
8116 8116
 
@@ -8153,11 +8153,11 @@  discard block
 block discarded – undo
8153 8153
     ) {
8154 8154
         if ($encoding === 'UTF-8') {
8155 8155
             if ($end === null) {
8156
-                $length = (int) \mb_strlen($str);
8156
+                $length = (int)\mb_strlen($str);
8157 8157
             } elseif ($end >= 0 && $end <= $start) {
8158 8158
                 return '';
8159 8159
             } elseif ($end < 0) {
8160
-                $length = (int) \mb_strlen($str) + $end - $start;
8160
+                $length = (int)\mb_strlen($str) + $end - $start;
8161 8161
             } else {
8162 8162
                 $length = $end - $start;
8163 8163
             }
@@ -8168,11 +8168,11 @@  discard block
 block discarded – undo
8168 8168
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
8169 8169
 
8170 8170
         if ($end === null) {
8171
-            $length = (int) self::strlen($str, $encoding);
8171
+            $length = (int)self::strlen($str, $encoding);
8172 8172
         } elseif ($end >= 0 && $end <= $start) {
8173 8173
             return '';
8174 8174
         } elseif ($end < 0) {
8175
-            $length = (int) self::strlen($str, $encoding) + $end - $start;
8175
+            $length = (int)self::strlen($str, $encoding) + $end - $start;
8176 8176
         } else {
8177 8177
             $length = $end - $start;
8178 8178
         }
@@ -8207,7 +8207,7 @@  discard block
 block discarded – undo
8207 8207
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
8208 8208
         }
8209 8209
 
8210
-        $str = (string) \preg_replace_callback(
8210
+        $str = (string)\preg_replace_callback(
8211 8211
             '/([\\p{N}|\\p{Lu}])/u',
8212 8212
             /**
8213 8213
              * @param string[] $matches
@@ -8216,28 +8216,28 @@  discard block
 block discarded – undo
8216 8216
              *
8217 8217
              * @return string
8218 8218
              */
8219
-            static function (array $matches) use ($encoding): string {
8219
+            static function(array $matches) use ($encoding): string {
8220 8220
                 $match = $matches[1];
8221
-                $match_int = (int) $match;
8221
+                $match_int = (int)$match;
8222 8222
 
8223
-                if ((string) $match_int === $match) {
8224
-                    return '_' . $match . '_';
8223
+                if ((string)$match_int === $match) {
8224
+                    return '_'.$match.'_';
8225 8225
                 }
8226 8226
 
8227 8227
                 if ($encoding === 'UTF-8') {
8228
-                    return '_' . \mb_strtolower($match);
8228
+                    return '_'.\mb_strtolower($match);
8229 8229
                 }
8230 8230
 
8231
-                return '_' . self::strtolower($match, $encoding);
8231
+                return '_'.self::strtolower($match, $encoding);
8232 8232
             },
8233 8233
             $str
8234 8234
         );
8235 8235
 
8236
-        $str = (string) \preg_replace(
8236
+        $str = (string)\preg_replace(
8237 8237
             [
8238
-                '/\\s+/u',           // convert spaces to "_"
8238
+                '/\\s+/u', // convert spaces to "_"
8239 8239
                 '/^\\s+|\\s+$/u', // trim leading & trailing spaces
8240
-                '/_+/',                 // remove double "_"
8240
+                '/_+/', // remove double "_"
8241 8241
             ],
8242 8242
             [
8243 8243
                 '_',
@@ -8367,7 +8367,7 @@  discard block
 block discarded – undo
8367 8367
         }
8368 8368
 
8369 8369
         // init
8370
-        $input = (string) $input;
8370
+        $input = (string)$input;
8371 8371
 
8372 8372
         if ($input === '') {
8373 8373
             return [];
@@ -8424,7 +8424,7 @@  discard block
 block discarded – undo
8424 8424
                     ($input[$i] & "\xE0") === "\xC0"
8425 8425
                 ) {
8426 8426
                     if (($input[$i + 1] & "\xC0") === "\x80") {
8427
-                        $ret[] = $input[$i] . $input[$i + 1];
8427
+                        $ret[] = $input[$i].$input[$i + 1];
8428 8428
 
8429 8429
                         ++$i;
8430 8430
                     }
@@ -8438,7 +8438,7 @@  discard block
 block discarded – undo
8438 8438
                         &&
8439 8439
                         ($input[$i + 2] & "\xC0") === "\x80"
8440 8440
                     ) {
8441
-                        $ret[] = $input[$i] . $input[$i + 1] . $input[$i + 2];
8441
+                        $ret[] = $input[$i].$input[$i + 1].$input[$i + 2];
8442 8442
 
8443 8443
                         $i += 2;
8444 8444
                     }
@@ -8454,7 +8454,7 @@  discard block
 block discarded – undo
8454 8454
                         &&
8455 8455
                         ($input[$i + 3] & "\xC0") === "\x80"
8456 8456
                     ) {
8457
-                        $ret[] = $input[$i] . $input[$i + 1] . $input[$i + 2] . $input[$i + 3];
8457
+                        $ret[] = $input[$i].$input[$i + 1].$input[$i + 2].$input[$i + 3];
8458 8458
 
8459 8459
                         $i += 3;
8460 8460
                     }
@@ -8464,7 +8464,7 @@  discard block
 block discarded – undo
8464 8464
 
8465 8465
         if ($length > 1) {
8466 8466
             return \array_map(
8467
-                static function (array $item): string {
8467
+                static function(array $item): string {
8468 8468
                     return \implode('', $item);
8469 8469
                 },
8470 8470
                 \array_chunk($ret, $length)
@@ -8538,7 +8538,7 @@  discard block
 block discarded – undo
8538 8538
             $limit = -1;
8539 8539
         }
8540 8540
 
8541
-        $array = \preg_split('/' . \preg_quote($pattern, '/') . '/u', $str, $limit);
8541
+        $array = \preg_split('/'.\preg_quote($pattern, '/').'/u', $str, $limit);
8542 8542
         if ($array === false) {
8543 8543
             return [];
8544 8544
         }
@@ -8638,9 +8638,9 @@  discard block
 block discarded – undo
8638 8638
                 return '';
8639 8639
             }
8640 8640
 
8641
-            return (string) \mb_substr(
8641
+            return (string)\mb_substr(
8642 8642
                 $str,
8643
-                $offset + (int) \mb_strlen($separator)
8643
+                $offset + (int)\mb_strlen($separator)
8644 8644
             );
8645 8645
         }
8646 8646
 
@@ -8649,9 +8649,9 @@  discard block
 block discarded – undo
8649 8649
             return '';
8650 8650
         }
8651 8651
 
8652
-        return (string) \mb_substr(
8652
+        return (string)\mb_substr(
8653 8653
             $str,
8654
-            $offset + (int) self::strlen($separator, $encoding),
8654
+            $offset + (int)self::strlen($separator, $encoding),
8655 8655
             null,
8656 8656
             $encoding
8657 8657
         );
@@ -8683,9 +8683,9 @@  discard block
 block discarded – undo
8683 8683
                 return '';
8684 8684
             }
8685 8685
 
8686
-            return (string) \mb_substr(
8686
+            return (string)\mb_substr(
8687 8687
                 $str,
8688
-                $offset + (int) \mb_strlen($separator)
8688
+                $offset + (int)\mb_strlen($separator)
8689 8689
             );
8690 8690
         }
8691 8691
 
@@ -8694,9 +8694,9 @@  discard block
 block discarded – undo
8694 8694
             return '';
8695 8695
         }
8696 8696
 
8697
-        return (string) self::substr(
8697
+        return (string)self::substr(
8698 8698
             $str,
8699
-            $offset + (int) self::strlen($separator, $encoding),
8699
+            $offset + (int)self::strlen($separator, $encoding),
8700 8700
             null,
8701 8701
             $encoding
8702 8702
         );
@@ -8728,7 +8728,7 @@  discard block
 block discarded – undo
8728 8728
                 return '';
8729 8729
             }
8730 8730
 
8731
-            return (string) \mb_substr(
8731
+            return (string)\mb_substr(
8732 8732
                 $str,
8733 8733
                 0,
8734 8734
                 $offset
@@ -8740,7 +8740,7 @@  discard block
 block discarded – undo
8740 8740
             return '';
8741 8741
         }
8742 8742
 
8743
-        return (string) self::substr(
8743
+        return (string)self::substr(
8744 8744
             $str,
8745 8745
             0,
8746 8746
             $offset,
@@ -8771,7 +8771,7 @@  discard block
 block discarded – undo
8771 8771
                 return '';
8772 8772
             }
8773 8773
 
8774
-            return (string) \mb_substr(
8774
+            return (string)\mb_substr(
8775 8775
                 $str,
8776 8776
                 0,
8777 8777
                 $offset
@@ -8785,7 +8785,7 @@  discard block
 block discarded – undo
8785 8785
 
8786 8786
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
8787 8787
 
8788
-        return (string) self::substr(
8788
+        return (string)self::substr(
8789 8789
             $str,
8790 8790
             0,
8791 8791
             $offset,
@@ -8900,7 +8900,7 @@  discard block
 block discarded – undo
8900 8900
      */
8901 8901
     public static function str_surround(string $str, string $substring): string
8902 8902
     {
8903
-        return $substring . $str . $substring;
8903
+        return $substring.$str.$substring;
8904 8904
     }
8905 8905
 
8906 8906
     /**
@@ -8964,9 +8964,9 @@  discard block
 block discarded – undo
8964 8964
             $word_define_chars = '';
8965 8965
         }
8966 8966
 
8967
-        $str = (string) \preg_replace_callback(
8968
-            '/([^\\s' . $word_define_chars . ']+)/u',
8969
-            static function (array $match) use ($try_to_keep_the_string_length, $lang, $ignore, $use_mb_functions, $encoding): string {
8967
+        $str = (string)\preg_replace_callback(
8968
+            '/([^\\s'.$word_define_chars.']+)/u',
8969
+            static function(array $match) use ($try_to_keep_the_string_length, $lang, $ignore, $use_mb_functions, $encoding): string {
8970 8970
                 if ($ignore !== null && \in_array($match[0], $ignore, true)) {
8971 8971
                     return $match[0];
8972 8972
                 }
@@ -9133,16 +9133,16 @@  discard block
 block discarded – undo
9133 9133
 
9134 9134
         // the main substitutions
9135 9135
         /** @noinspection RegExpDuplicateAlternationBranch - false-positive - https://youtrack.jetbrains.com/issue/WI-51002 */
9136
-        $str = (string) \preg_replace_callback(
9136
+        $str = (string)\preg_replace_callback(
9137 9137
             '~\\b (_*) (?:                                                           # 1. Leading underscore and
9138 9138
                         ( (?<=[ ][/\\\\]) [[:alpha:]]+ [-_[:alpha:]/\\\\]+ |                # 2. file path or 
9139
-                          [-_[:alpha:]]+ [@.:] [-_[:alpha:]@.:/]+ ' . $apostrophe_rx . ' )  #    URL, domain, or email
9139
+                          [-_[:alpha:]]+ [@.:] [-_[:alpha:]@.:/]+ ' . $apostrophe_rx.' )  #    URL, domain, or email
9140 9140
                         |
9141
-                        ( (?i: ' . $small_words_rx . ' ) ' . $apostrophe_rx . ' )           # 3. or small word (case-insensitive)
9141
+                        ( (?i: ' . $small_words_rx.' ) '.$apostrophe_rx.' )           # 3. or small word (case-insensitive)
9142 9142
                         |
9143
-                        ( [[:alpha:]] [[:lower:]\'’()\[\]{}]* ' . $apostrophe_rx . ' )     # 4. or word w/o internal caps
9143
+                        ( [[:alpha:]] [[:lower:]\'’()\[\]{}]* ' . $apostrophe_rx.' )     # 4. or word w/o internal caps
9144 9144
                         |
9145
-                        ( [[:alpha:]] [[:alpha:]\'’()\[\]{}]* ' . $apostrophe_rx . ' )     # 5. or some other word
9145
+                        ( [[:alpha:]] [[:alpha:]\'’()\[\]{}]* ' . $apostrophe_rx.' )     # 5. or some other word
9146 9146
                       ) (_*) \\b                                                          # 6. With trailing underscore
9147 9147
                     ~ux',
9148 9148
             /**
@@ -9152,7 +9152,7 @@  discard block
 block discarded – undo
9152 9152
              *
9153 9153
              * @return string
9154 9154
              */
9155
-            static function (array $matches) use ($encoding): string {
9155
+            static function(array $matches) use ($encoding): string {
9156 9156
                 // preserve leading underscore
9157 9157
                 $str = $matches[1];
9158 9158
                 if ($matches[2]) {
@@ -9177,11 +9177,11 @@  discard block
 block discarded – undo
9177 9177
         );
9178 9178
 
9179 9179
         // Exceptions for small words: capitalize at start of title...
9180
-        $str = (string) \preg_replace_callback(
9180
+        $str = (string)\preg_replace_callback(
9181 9181
             '~(  \\A [[:punct:]]*            # start of title...
9182 9182
                       |  [:.;?!][ ]+                # or of subsentence...
9183 9183
                       |  [ ][\'"“‘(\[][ ]* )        # or of inserted subphrase...
9184
-                      ( ' . $small_words_rx . ' ) \\b # ...followed by small word
9184
+                      ( ' . $small_words_rx.' ) \\b # ...followed by small word
9185 9185
                      ~uxi',
9186 9186
             /**
9187 9187
              * @param string[] $matches
@@ -9190,15 +9190,15 @@  discard block
 block discarded – undo
9190 9190
              *
9191 9191
              * @return string
9192 9192
              */
9193
-            static function (array $matches) use ($encoding): string {
9194
-                return $matches[1] . static::ucfirst($matches[2], $encoding);
9193
+            static function(array $matches) use ($encoding): string {
9194
+                return $matches[1].static::ucfirst($matches[2], $encoding);
9195 9195
             },
9196 9196
             $str
9197 9197
         );
9198 9198
 
9199 9199
         // ...and end of title
9200
-        $str = (string) \preg_replace_callback(
9201
-            '~\\b ( ' . $small_words_rx . ' ) # small word...
9200
+        $str = (string)\preg_replace_callback(
9201
+            '~\\b ( '.$small_words_rx.' ) # small word...
9202 9202
                       (?= [[:punct:]]* \Z          # ...at the end of the title...
9203 9203
                       |   [\'"’”)\]] [ ] )         # ...or of an inserted subphrase?
9204 9204
                      ~uxi',
@@ -9209,7 +9209,7 @@  discard block
 block discarded – undo
9209 9209
              *
9210 9210
              * @return string
9211 9211
              */
9212
-            static function (array $matches) use ($encoding): string {
9212
+            static function(array $matches) use ($encoding): string {
9213 9213
                 return static::ucfirst($matches[1], $encoding);
9214 9214
             },
9215 9215
             $str
@@ -9217,10 +9217,10 @@  discard block
 block discarded – undo
9217 9217
 
9218 9218
         // Exceptions for small words in hyphenated compound words.
9219 9219
         // e.g. "in-flight" -> In-Flight
9220
-        $str = (string) \preg_replace_callback(
9220
+        $str = (string)\preg_replace_callback(
9221 9221
             '~\\b
9222 9222
                         (?<! -)                   # Negative lookbehind for a hyphen; we do not want to match man-in-the-middle but do want (in-flight)
9223
-                        ( ' . $small_words_rx . ' )
9223
+                        ( ' . $small_words_rx.' )
9224 9224
                         (?= -[[:alpha:]]+)        # lookahead for "-someword"
9225 9225
                        ~uxi',
9226 9226
             /**
@@ -9230,18 +9230,18 @@  discard block
 block discarded – undo
9230 9230
              *
9231 9231
              * @return string
9232 9232
              */
9233
-            static function (array $matches) use ($encoding): string {
9233
+            static function(array $matches) use ($encoding): string {
9234 9234
                 return static::ucfirst($matches[1], $encoding);
9235 9235
             },
9236 9236
             $str
9237 9237
         );
9238 9238
 
9239 9239
         // e.g. "Stand-in" -> "Stand-In" (Stand is already capped at this point)
9240
-        $str = (string) \preg_replace_callback(
9240
+        $str = (string)\preg_replace_callback(
9241 9241
             '~\\b
9242 9242
                       (?<!…)                    # Negative lookbehind for a hyphen; we do not want to match man-in-the-middle but do want (stand-in)
9243 9243
                       ( [[:alpha:]]+- )         # $1 = first word and hyphen, should already be properly capped
9244
-                      ( ' . $small_words_rx . ' ) # ...followed by small word
9244
+                      ( ' . $small_words_rx.' ) # ...followed by small word
9245 9245
                       (?!	- )                 # Negative lookahead for another -
9246 9246
                      ~uxi',
9247 9247
             /**
@@ -9251,8 +9251,8 @@  discard block
 block discarded – undo
9251 9251
              *
9252 9252
              * @return string
9253 9253
              */
9254
-            static function (array $matches) use ($encoding): string {
9255
-                return $matches[1] . static::ucfirst($matches[2], $encoding);
9254
+            static function(array $matches) use ($encoding): string {
9255
+                return $matches[1].static::ucfirst($matches[2], $encoding);
9256 9256
             },
9257 9257
             $str
9258 9258
         );
@@ -9371,7 +9371,7 @@  discard block
 block discarded – undo
9371 9371
         );
9372 9372
 
9373 9373
         foreach ($tmp_return as &$item) {
9374
-            $item = (string) $item;
9374
+            $item = (string)$item;
9375 9375
         }
9376 9376
 
9377 9377
         return $tmp_return;
@@ -9425,39 +9425,39 @@  discard block
 block discarded – undo
9425 9425
         }
9426 9426
 
9427 9427
         if ($encoding === 'UTF-8') {
9428
-            if ($length >= (int) \mb_strlen($str)) {
9428
+            if ($length >= (int)\mb_strlen($str)) {
9429 9429
                 return $str;
9430 9430
             }
9431 9431
 
9432 9432
             if ($substring !== '') {
9433
-                $length -= (int) \mb_strlen($substring);
9433
+                $length -= (int)\mb_strlen($substring);
9434 9434
 
9435 9435
                 /** @noinspection UnnecessaryCastingInspection */
9436
-                return (string) \mb_substr($str, 0, $length) . $substring;
9436
+                return (string)\mb_substr($str, 0, $length).$substring;
9437 9437
             }
9438 9438
 
9439 9439
             /** @noinspection UnnecessaryCastingInspection */
9440
-            return (string) \mb_substr($str, 0, $length);
9440
+            return (string)\mb_substr($str, 0, $length);
9441 9441
         }
9442 9442
 
9443 9443
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
9444 9444
 
9445
-        if ($length >= (int) self::strlen($str, $encoding)) {
9445
+        if ($length >= (int)self::strlen($str, $encoding)) {
9446 9446
             return $str;
9447 9447
         }
9448 9448
 
9449 9449
         if ($substring !== '') {
9450
-            $length -= (int) self::strlen($substring, $encoding);
9450
+            $length -= (int)self::strlen($substring, $encoding);
9451 9451
         }
9452 9452
 
9453 9453
         return (
9454
-               (string) self::substr(
9454
+               (string)self::substr(
9455 9455
                    $str,
9456 9456
                    0,
9457 9457
                    $length,
9458 9458
                    $encoding
9459 9459
                )
9460
-               ) . $substring;
9460
+               ).$substring;
9461 9461
     }
9462 9462
 
9463 9463
     /**
@@ -9491,12 +9491,12 @@  discard block
 block discarded – undo
9491 9491
         }
9492 9492
 
9493 9493
         if ($encoding === 'UTF-8') {
9494
-            if ($length >= (int) \mb_strlen($str)) {
9494
+            if ($length >= (int)\mb_strlen($str)) {
9495 9495
                 return $str;
9496 9496
             }
9497 9497
 
9498 9498
             // need to further trim the string so we can append the substring
9499
-            $length -= (int) \mb_strlen($substring);
9499
+            $length -= (int)\mb_strlen($substring);
9500 9500
             if ($length <= 0) {
9501 9501
                 return $substring;
9502 9502
             }
@@ -9522,18 +9522,18 @@  discard block
 block discarded – undo
9522 9522
                         !$ignore_do_not_split_words_for_one_word
9523 9523
                     )
9524 9524
                 ) {
9525
-                    $truncated = (string) \mb_substr($truncated, 0, (int) $last_position);
9525
+                    $truncated = (string)\mb_substr($truncated, 0, (int)$last_position);
9526 9526
                 }
9527 9527
             }
9528 9528
         } else {
9529 9529
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
9530 9530
 
9531
-            if ($length >= (int) self::strlen($str, $encoding)) {
9531
+            if ($length >= (int)self::strlen($str, $encoding)) {
9532 9532
                 return $str;
9533 9533
             }
9534 9534
 
9535 9535
             // need to further trim the string so we can append the substring
9536
-            $length -= (int) self::strlen($substring, $encoding);
9536
+            $length -= (int)self::strlen($substring, $encoding);
9537 9537
             if ($length <= 0) {
9538 9538
                 return $substring;
9539 9539
             }
@@ -9559,12 +9559,12 @@  discard block
 block discarded – undo
9559 9559
                         !$ignore_do_not_split_words_for_one_word
9560 9560
                     )
9561 9561
                 ) {
9562
-                    $truncated = (string) self::substr($truncated, 0, (int) $last_position, $encoding);
9562
+                    $truncated = (string)self::substr($truncated, 0, (int)$last_position, $encoding);
9563 9563
                 }
9564 9564
             }
9565 9565
         }
9566 9566
 
9567
-        return $truncated . $substring;
9567
+        return $truncated.$substring;
9568 9568
     }
9569 9569
 
9570 9570
     /**
@@ -9691,13 +9691,13 @@  discard block
 block discarded – undo
9691 9691
             }
9692 9692
         } elseif ($format === 2) {
9693 9693
             $number_of_words = [];
9694
-            $offset = (int) self::strlen($str_parts[0]);
9694
+            $offset = (int)self::strlen($str_parts[0]);
9695 9695
             for ($i = 1; $i < $len; $i += 2) {
9696 9696
                 $number_of_words[$offset] = $str_parts[$i];
9697
-                $offset += (int) self::strlen($str_parts[$i]) + (int) self::strlen($str_parts[$i + 1]);
9697
+                $offset += (int)self::strlen($str_parts[$i]) + (int)self::strlen($str_parts[$i + 1]);
9698 9698
             }
9699 9699
         } else {
9700
-            $number_of_words = (int) (($len - 1) / 2);
9700
+            $number_of_words = (int)(($len - 1) / 2);
9701 9701
         }
9702 9702
 
9703 9703
         return $number_of_words;
@@ -9832,7 +9832,7 @@  discard block
 block discarded – undo
9832 9832
         }
9833 9833
 
9834 9834
         if ($char_list === '') {
9835
-            return (int) self::strlen($str, $encoding);
9835
+            return (int)self::strlen($str, $encoding);
9836 9836
         }
9837 9837
 
9838 9838
         if ($offset || $length !== null) {
@@ -9859,7 +9859,7 @@  discard block
 block discarded – undo
9859 9859
         }
9860 9860
 
9861 9861
         $matches = [];
9862
-        if (\preg_match('/^(.*?)' . self::rxClass($char_list) . '/us', $str, $matches)) {
9862
+        if (\preg_match('/^(.*?)'.self::rxClass($char_list).'/us', $str, $matches)) {
9863 9863
             $return = self::strlen($matches[1], $encoding);
9864 9864
             if ($return === false) {
9865 9865
                 return 0;
@@ -9868,7 +9868,7 @@  discard block
 block discarded – undo
9868 9868
             return $return;
9869 9869
         }
9870 9870
 
9871
-        return (int) self::strlen($str, $encoding);
9871
+        return (int)self::strlen($str, $encoding);
9872 9872
     }
9873 9873
 
9874 9874
     /**
@@ -9931,7 +9931,7 @@  discard block
 block discarded – undo
9931 9931
 
9932 9932
         $str = '';
9933 9933
         foreach ($intOrHex as $strPart) {
9934
-            $str .= '&#' . (int) $strPart . ';';
9934
+            $str .= '&#'.(int)$strPart.';';
9935 9935
         }
9936 9936
 
9937 9937
         return self::html_entity_decode($str, \ENT_QUOTES | \ENT_HTML5);
@@ -10028,7 +10028,7 @@  discard block
 block discarded – undo
10028 10028
             return '';
10029 10029
         }
10030 10030
 
10031
-        return (string) \preg_replace('/[[:space:]]+/u', '', $str);
10031
+        return (string)\preg_replace('/[[:space:]]+/u', '', $str);
10032 10032
     }
10033 10033
 
10034 10034
     /**
@@ -10107,7 +10107,7 @@  discard block
 block discarded – undo
10107 10107
         // fallback for ascii only
10108 10108
         //
10109 10109
 
10110
-        if (ASCII::is_ascii($haystack . $needle)) {
10110
+        if (ASCII::is_ascii($haystack.$needle)) {
10111 10111
             return \stripos($haystack, $needle, $offset);
10112 10112
         }
10113 10113
 
@@ -10196,7 +10196,7 @@  discard block
 block discarded – undo
10196 10196
             /**
10197 10197
              * @psalm-suppress ImpureFunctionCall - is is only a warning
10198 10198
              */
10199
-            \trigger_error('UTF8::stristr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
10199
+            \trigger_error('UTF8::stristr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
10200 10200
         }
10201 10201
 
10202 10202
         if (
@@ -10210,11 +10210,11 @@  discard block
 block discarded – undo
10210 10210
             }
10211 10211
         }
10212 10212
 
10213
-        if (ASCII::is_ascii($needle . $haystack)) {
10213
+        if (ASCII::is_ascii($needle.$haystack)) {
10214 10214
             return \stristr($haystack, $needle, $before_needle);
10215 10215
         }
10216 10216
 
10217
-        \preg_match('/^(.*?)' . \preg_quote($needle, '/') . '/usi', $haystack, $match);
10217
+        \preg_match('/^(.*?)'.\preg_quote($needle, '/').'/usi', $haystack, $match);
10218 10218
 
10219 10219
         if (!isset($match[1])) {
10220 10220
             return false;
@@ -10224,7 +10224,7 @@  discard block
 block discarded – undo
10224 10224
             return $match[1];
10225 10225
         }
10226 10226
 
10227
-        return self::substr($haystack, (int) self::strlen($match[1], $encoding), null, $encoding);
10227
+        return self::substr($haystack, (int)self::strlen($match[1], $encoding), null, $encoding);
10228 10228
     }
10229 10229
 
10230 10230
     /**
@@ -10307,7 +10307,7 @@  discard block
 block discarded – undo
10307 10307
             /**
10308 10308
              * @psalm-suppress ImpureFunctionCall - is is only a warning
10309 10309
              */
10310
-            \trigger_error('UTF8::strlen() without mbstring / iconv cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
10310
+            \trigger_error('UTF8::strlen() without mbstring / iconv cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
10311 10311
         }
10312 10312
 
10313 10313
         //
@@ -10445,8 +10445,8 @@  discard block
 block discarded – undo
10445 10445
         }
10446 10446
 
10447 10447
         return \strnatcmp(
10448
-            (string) self::strtonatfold($str1),
10449
-            (string) self::strtonatfold($str2)
10448
+            (string)self::strtonatfold($str1),
10449
+            (string)self::strtonatfold($str2)
10450 10450
         );
10451 10451
     }
10452 10452
 
@@ -10516,11 +10516,11 @@  discard block
 block discarded – undo
10516 10516
         }
10517 10517
 
10518 10518
         if ($encoding === 'UTF-8') {
10519
-            $str1 = (string) \mb_substr($str1, 0, $len);
10520
-            $str2 = (string) \mb_substr($str2, 0, $len);
10519
+            $str1 = (string)\mb_substr($str1, 0, $len);
10520
+            $str2 = (string)\mb_substr($str2, 0, $len);
10521 10521
         } else {
10522
-            $str1 = (string) self::substr($str1, 0, $len, $encoding);
10523
-            $str2 = (string) self::substr($str2, 0, $len, $encoding);
10522
+            $str1 = (string)self::substr($str1, 0, $len, $encoding);
10523
+            $str2 = (string)self::substr($str2, 0, $len, $encoding);
10524 10524
         }
10525 10525
 
10526 10526
         return self::strcmp($str1, $str2);
@@ -10547,8 +10547,8 @@  discard block
 block discarded – undo
10547 10547
             return false;
10548 10548
         }
10549 10549
 
10550
-        if (\preg_match('/' . self::rxClass($char_list) . '/us', $haystack, $m)) {
10551
-            return \substr($haystack, (int) \strpos($haystack, $m[0]));
10550
+        if (\preg_match('/'.self::rxClass($char_list).'/us', $haystack, $m)) {
10551
+            return \substr($haystack, (int)\strpos($haystack, $m[0]));
10552 10552
         }
10553 10553
 
10554 10554
         return false;
@@ -10593,10 +10593,10 @@  discard block
 block discarded – undo
10593 10593
         }
10594 10594
 
10595 10595
         // iconv and mbstring do not support integer $needle
10596
-        if ((int) $needle === $needle) {
10597
-            $needle = (string) self::chr($needle);
10596
+        if ((int)$needle === $needle) {
10597
+            $needle = (string)self::chr($needle);
10598 10598
         }
10599
-        $needle = (string) $needle;
10599
+        $needle = (string)$needle;
10600 10600
 
10601 10601
         if ($haystack === '') {
10602 10602
             if (\PHP_VERSION_ID >= 80000 && $needle === '') {
@@ -10656,7 +10656,7 @@  discard block
 block discarded – undo
10656 10656
             /**
10657 10657
              * @psalm-suppress ImpureFunctionCall - is is only a warning
10658 10658
              */
10659
-            \trigger_error('UTF8::strpos() without mbstring / iconv cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
10659
+            \trigger_error('UTF8::strpos() without mbstring / iconv cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
10660 10660
         }
10661 10661
 
10662 10662
         //
@@ -10697,7 +10697,7 @@  discard block
 block discarded – undo
10697 10697
         // fallback for ascii only
10698 10698
         //
10699 10699
 
10700
-        if (ASCII::is_ascii($haystack . $needle)) {
10700
+        if (ASCII::is_ascii($haystack.$needle)) {
10701 10701
             /** @noinspection PhpUsageOfSilenceOperatorInspection - Offset not contained in string */
10702 10702
             return @\strpos($haystack, $needle, $offset);
10703 10703
         }
@@ -10710,7 +10710,7 @@  discard block
 block discarded – undo
10710 10710
         if ($haystack_tmp === false) {
10711 10711
             $haystack_tmp = '';
10712 10712
         }
10713
-        $haystack = (string) $haystack_tmp;
10713
+        $haystack = (string)$haystack_tmp;
10714 10714
 
10715 10715
         if ($offset < 0) {
10716 10716
             $offset = 0;
@@ -10722,7 +10722,7 @@  discard block
 block discarded – undo
10722 10722
         }
10723 10723
 
10724 10724
         if ($pos) {
10725
-            return $offset + (int) self::strlen(\substr($haystack, 0, $pos), $encoding);
10725
+            return $offset + (int)self::strlen(\substr($haystack, 0, $pos), $encoding);
10726 10726
         }
10727 10727
 
10728 10728
         return $offset + 0;
@@ -10877,7 +10877,7 @@  discard block
 block discarded – undo
10877 10877
             /**
10878 10878
              * @psalm-suppress ImpureFunctionCall - is is only a warning
10879 10879
              */
10880
-            \trigger_error('UTF8::strrchr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
10880
+            \trigger_error('UTF8::strrchr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
10881 10881
         }
10882 10882
 
10883 10883
         //
@@ -10952,7 +10952,7 @@  discard block
 block discarded – undo
10952 10952
         if ($encoding === 'UTF-8') {
10953 10953
             if (self::$SUPPORT['intl'] === true) {
10954 10954
                 // try "grapheme" first: https://stackoverflow.com/questions/17496493/strrev-dosent-support-utf-8
10955
-                $i = (int) \grapheme_strlen($str);
10955
+                $i = (int)\grapheme_strlen($str);
10956 10956
                 while ($i--) {
10957 10957
                     $reversed_tmp = \grapheme_substr($str, $i, 1);
10958 10958
                     if ($reversed_tmp !== false) {
@@ -10960,7 +10960,7 @@  discard block
 block discarded – undo
10960 10960
                     }
10961 10961
                 }
10962 10962
             } else {
10963
-                $i = (int) \mb_strlen($str);
10963
+                $i = (int)\mb_strlen($str);
10964 10964
                 while ($i--) {
10965 10965
                     $reversed_tmp = \mb_substr($str, $i, 1);
10966 10966
                     if ($reversed_tmp !== false) {
@@ -10971,7 +10971,7 @@  discard block
 block discarded – undo
10971 10971
         } else {
10972 10972
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
10973 10973
 
10974
-            $i = (int) self::strlen($str, $encoding);
10974
+            $i = (int)self::strlen($str, $encoding);
10975 10975
             while ($i--) {
10976 10976
                 $reversed_tmp = self::substr($str, $i, 1, $encoding);
10977 10977
                 if ($reversed_tmp !== false) {
@@ -11099,10 +11099,10 @@  discard block
 block discarded – undo
11099 11099
         }
11100 11100
 
11101 11101
         // iconv and mbstring do not support integer $needle
11102
-        if ((int) $needle === $needle && $needle >= 0) {
11103
-            $needle = (string) self::chr($needle);
11102
+        if ((int)$needle === $needle && $needle >= 0) {
11103
+            $needle = (string)self::chr($needle);
11104 11104
         }
11105
-        $needle = (string) $needle;
11105
+        $needle = (string)$needle;
11106 11106
 
11107 11107
         if ($haystack === '') {
11108 11108
             if (\PHP_VERSION_ID >= 80000 && $needle === '') {
@@ -11158,7 +11158,7 @@  discard block
 block discarded – undo
11158 11158
             /**
11159 11159
              * @psalm-suppress ImpureFunctionCall - is is only a warning
11160 11160
              */
11161
-            \trigger_error('UTF8::strripos() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
11161
+            \trigger_error('UTF8::strripos() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
11162 11162
         }
11163 11163
 
11164 11164
         //
@@ -11182,7 +11182,7 @@  discard block
 block discarded – undo
11182 11182
         // fallback for ascii only
11183 11183
         //
11184 11184
 
11185
-        if (ASCII::is_ascii($haystack . $needle)) {
11185
+        if (ASCII::is_ascii($haystack.$needle)) {
11186 11186
             return \strripos($haystack, $needle, $offset);
11187 11187
         }
11188 11188
 
@@ -11271,10 +11271,10 @@  discard block
 block discarded – undo
11271 11271
         }
11272 11272
 
11273 11273
         // iconv and mbstring do not support integer $needle
11274
-        if ((int) $needle === $needle && $needle >= 0) {
11275
-            $needle = (string) self::chr($needle);
11274
+        if ((int)$needle === $needle && $needle >= 0) {
11275
+            $needle = (string)self::chr($needle);
11276 11276
         }
11277
-        $needle = (string) $needle;
11277
+        $needle = (string)$needle;
11278 11278
 
11279 11279
         if ($haystack === '') {
11280 11280
             if (\PHP_VERSION_ID >= 80000 && $needle === '') {
@@ -11330,7 +11330,7 @@  discard block
 block discarded – undo
11330 11330
             /**
11331 11331
              * @psalm-suppress ImpureFunctionCall - is is only a warning
11332 11332
              */
11333
-            \trigger_error('UTF8::strrpos() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
11333
+            \trigger_error('UTF8::strrpos() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
11334 11334
         }
11335 11335
 
11336 11336
         //
@@ -11354,7 +11354,7 @@  discard block
 block discarded – undo
11354 11354
         // fallback for ascii only
11355 11355
         //
11356 11356
 
11357
-        if (ASCII::is_ascii($haystack . $needle)) {
11357
+        if (ASCII::is_ascii($haystack.$needle)) {
11358 11358
             return \strrpos($haystack, $needle, $offset);
11359 11359
         }
11360 11360
 
@@ -11374,7 +11374,7 @@  discard block
 block discarded – undo
11374 11374
             if ($haystack_tmp === false) {
11375 11375
                 $haystack_tmp = '';
11376 11376
             }
11377
-            $haystack = (string) $haystack_tmp;
11377
+            $haystack = (string)$haystack_tmp;
11378 11378
         }
11379 11379
 
11380 11380
         $pos = \strrpos($haystack, $needle);
@@ -11388,7 +11388,7 @@  discard block
 block discarded – undo
11388 11388
             return false;
11389 11389
         }
11390 11390
 
11391
-        return $offset + (int) self::strlen($str_tmp);
11391
+        return $offset + (int)self::strlen($str_tmp);
11392 11392
     }
11393 11393
 
11394 11394
     /**
@@ -11456,12 +11456,12 @@  discard block
 block discarded – undo
11456 11456
         if ($offset || $length !== null) {
11457 11457
             if ($encoding === 'UTF-8') {
11458 11458
                 if ($length === null) {
11459
-                    $str = (string) \mb_substr($str, $offset);
11459
+                    $str = (string)\mb_substr($str, $offset);
11460 11460
                 } else {
11461
-                    $str = (string) \mb_substr($str, $offset, $length);
11461
+                    $str = (string)\mb_substr($str, $offset, $length);
11462 11462
                 }
11463 11463
             } else {
11464
-                $str = (string) self::substr($str, $offset, $length, $encoding);
11464
+                $str = (string)self::substr($str, $offset, $length, $encoding);
11465 11465
             }
11466 11466
         }
11467 11467
 
@@ -11471,7 +11471,7 @@  discard block
 block discarded – undo
11471 11471
 
11472 11472
         $matches = [];
11473 11473
 
11474
-        return \preg_match('/^' . self::rxClass($mask) . '+/u', $str, $matches) ? (int) self::strlen($matches[0], $encoding) : 0;
11474
+        return \preg_match('/^'.self::rxClass($mask).'+/u', $str, $matches) ? (int)self::strlen($matches[0], $encoding) : 0;
11475 11475
     }
11476 11476
 
11477 11477
     /**
@@ -11565,7 +11565,7 @@  discard block
 block discarded – undo
11565 11565
             /**
11566 11566
              * @psalm-suppress ImpureFunctionCall - is is only a warning
11567 11567
              */
11568
-            \trigger_error('UTF8::strstr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
11568
+            \trigger_error('UTF8::strstr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
11569 11569
         }
11570 11570
 
11571 11571
         //
@@ -11587,7 +11587,7 @@  discard block
 block discarded – undo
11587 11587
         // fallback for ascii only
11588 11588
         //
11589 11589
 
11590
-        if (ASCII::is_ascii($haystack . $needle)) {
11590
+        if (ASCII::is_ascii($haystack.$needle)) {
11591 11591
             return \strstr($haystack, $needle, $before_needle);
11592 11592
         }
11593 11593
 
@@ -11595,7 +11595,7 @@  discard block
 block discarded – undo
11595 11595
         // fallback via vanilla php
11596 11596
         //
11597 11597
 
11598
-        \preg_match('/^(.*?)' . \preg_quote($needle, '/') . '/us', $haystack, $match);
11598
+        \preg_match('/^(.*?)'.\preg_quote($needle, '/').'/us', $haystack, $match);
11599 11599
 
11600 11600
         if (!isset($match[1])) {
11601 11601
             return false;
@@ -11605,7 +11605,7 @@  discard block
 block discarded – undo
11605 11605
             return $match[1];
11606 11606
         }
11607 11607
 
11608
-        return self::substr($haystack, (int) self::strlen($match[1]));
11608
+        return self::substr($haystack, (int)self::strlen($match[1]));
11609 11609
     }
11610 11610
 
11611 11611
     /**
@@ -11735,7 +11735,7 @@  discard block
 block discarded – undo
11735 11735
         bool $try_to_keep_the_string_length = false
11736 11736
     ): string {
11737 11737
         // init
11738
-        $str = (string) $str;
11738
+        $str = (string)$str;
11739 11739
 
11740 11740
         if ($str === '') {
11741 11741
             return '';
@@ -11764,25 +11764,25 @@  discard block
 block discarded – undo
11764 11764
                     self::$INTL_TRANSLITERATOR_LIST = self::getData('transliterator_list');
11765 11765
                 }
11766 11766
 
11767
-                $language_code = $lang . '-Lower';
11767
+                $language_code = $lang.'-Lower';
11768 11768
                 if (!\in_array($language_code, self::$INTL_TRANSLITERATOR_LIST, true)) {
11769 11769
                     /**
11770 11770
                      * @psalm-suppress ImpureFunctionCall - is is only a warning
11771 11771
                      */
11772
-                    \trigger_error('UTF8::strtolower() cannot handle special language: ' . $lang . ' | supported: ' . \print_r(self::$INTL_TRANSLITERATOR_LIST, true), \E_USER_WARNING);
11772
+                    \trigger_error('UTF8::strtolower() cannot handle special language: '.$lang.' | supported: '.\print_r(self::$INTL_TRANSLITERATOR_LIST, true), \E_USER_WARNING);
11773 11773
 
11774 11774
                     $language_code = 'Any-Lower';
11775 11775
                 }
11776 11776
 
11777 11777
                 /** @noinspection PhpComposerExtensionStubsInspection */
11778 11778
                 /** @noinspection UnnecessaryCastingInspection */
11779
-                return (string) \transliterator_transliterate($language_code, $str);
11779
+                return (string)\transliterator_transliterate($language_code, $str);
11780 11780
             }
11781 11781
 
11782 11782
             /**
11783 11783
              * @psalm-suppress ImpureFunctionCall - is is only a warning
11784 11784
              */
11785
-            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang" parameter: ' . $lang, \E_USER_WARNING);
11785
+            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang" parameter: '.$lang, \E_USER_WARNING);
11786 11786
         }
11787 11787
 
11788 11788
         // always fallback via symfony polyfill
@@ -11817,7 +11817,7 @@  discard block
 block discarded – undo
11817 11817
         bool $try_to_keep_the_string_length = false
11818 11818
     ): string {
11819 11819
         // init
11820
-        $str = (string) $str;
11820
+        $str = (string)$str;
11821 11821
 
11822 11822
         if ($str === '') {
11823 11823
             return '';
@@ -11846,25 +11846,25 @@  discard block
 block discarded – undo
11846 11846
                     self::$INTL_TRANSLITERATOR_LIST = self::getData('transliterator_list');
11847 11847
                 }
11848 11848
 
11849
-                $language_code = $lang . '-Upper';
11849
+                $language_code = $lang.'-Upper';
11850 11850
                 if (!\in_array($language_code, self::$INTL_TRANSLITERATOR_LIST, true)) {
11851 11851
                     /**
11852 11852
                      * @psalm-suppress ImpureFunctionCall - is is only a warning
11853 11853
                      */
11854
-                    \trigger_error('UTF8::strtoupper() without intl for special language: ' . $lang, \E_USER_WARNING);
11854
+                    \trigger_error('UTF8::strtoupper() without intl for special language: '.$lang, \E_USER_WARNING);
11855 11855
 
11856 11856
                     $language_code = 'Any-Upper';
11857 11857
                 }
11858 11858
 
11859 11859
                 /** @noinspection PhpComposerExtensionStubsInspection */
11860 11860
                 /** @noinspection UnnecessaryCastingInspection */
11861
-                return (string) \transliterator_transliterate($language_code, $str);
11861
+                return (string)\transliterator_transliterate($language_code, $str);
11862 11862
             }
11863 11863
 
11864 11864
             /**
11865 11865
              * @psalm-suppress ImpureFunctionCall - is is only a warning
11866 11866
              */
11867
-            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang"-parameter: ' . $lang, \E_USER_WARNING);
11867
+            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang"-parameter: '.$lang, \E_USER_WARNING);
11868 11868
         }
11869 11869
 
11870 11870
         // always fallback via symfony polyfill
@@ -11928,7 +11928,7 @@  discard block
 block discarded – undo
11928 11928
             $from = \array_combine($from, $to);
11929 11929
             /** @noinspection CallableParameterUseCaseInTypeContextInspection - FP */
11930 11930
             if ($from === false) {
11931
-                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) . ')');
11931
+                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).')');
11932 11932
             }
11933 11933
         }
11934 11934
 
@@ -11994,9 +11994,9 @@  discard block
 block discarded – undo
11994 11994
         }
11995 11995
 
11996 11996
         $wide = 0;
11997
-        $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);
11997
+        $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);
11998 11998
 
11999
-        return ($wide << 1) + (int) self::strlen($str);
11999
+        return ($wide << 1) + (int)self::strlen($str);
12000 12000
     }
12001 12001
 
12002 12002
     /**
@@ -12105,7 +12105,7 @@  discard block
 block discarded – undo
12105 12105
             /**
12106 12106
              * @psalm-suppress ImpureFunctionCall - is is only a warning
12107 12107
              */
12108
-            \trigger_error('UTF8::substr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
12108
+            \trigger_error('UTF8::substr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
12109 12109
         }
12110 12110
 
12111 12111
         //
@@ -12200,16 +12200,16 @@  discard block
 block discarded – undo
12200 12200
         ) {
12201 12201
             if ($encoding === 'UTF-8') {
12202 12202
                 if ($length === null) {
12203
-                    $str1 = (string) \mb_substr($str1, $offset);
12203
+                    $str1 = (string)\mb_substr($str1, $offset);
12204 12204
                 } else {
12205
-                    $str1 = (string) \mb_substr($str1, $offset, $length);
12205
+                    $str1 = (string)\mb_substr($str1, $offset, $length);
12206 12206
                 }
12207
-                $str2 = (string) \mb_substr($str2, 0, (int) self::strlen($str1));
12207
+                $str2 = (string)\mb_substr($str2, 0, (int)self::strlen($str1));
12208 12208
             } else {
12209 12209
                 $encoding = self::normalize_encoding($encoding, 'UTF-8');
12210 12210
 
12211
-                $str1 = (string) self::substr($str1, $offset, $length, $encoding);
12212
-                $str2 = (string) self::substr($str2, 0, (int) self::strlen($str1), $encoding);
12211
+                $str1 = (string)self::substr($str1, $offset, $length, $encoding);
12212
+                $str2 = (string)self::substr($str2, 0, (int)self::strlen($str1), $encoding);
12213 12213
             }
12214 12214
         }
12215 12215
 
@@ -12288,9 +12288,9 @@  discard block
 block discarded – undo
12288 12288
             }
12289 12289
 
12290 12290
             if ($encoding === 'UTF-8') {
12291
-                $haystack = (string) \mb_substr($haystack, $offset, $length);
12291
+                $haystack = (string)\mb_substr($haystack, $offset, $length);
12292 12292
             } else {
12293
-                $haystack = (string) \mb_substr($haystack, $offset, $length, $encoding);
12293
+                $haystack = (string)\mb_substr($haystack, $offset, $length, $encoding);
12294 12294
             }
12295 12295
         }
12296 12296
 
@@ -12302,7 +12302,7 @@  discard block
 block discarded – undo
12302 12302
             /**
12303 12303
              * @psalm-suppress ImpureFunctionCall - is is only a warning
12304 12304
              */
12305
-            \trigger_error('UTF8::substr_count() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
12305
+            \trigger_error('UTF8::substr_count() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
12306 12306
         }
12307 12307
 
12308 12308
         if (self::$SUPPORT['mbstring'] === true) {
@@ -12313,7 +12313,7 @@  discard block
 block discarded – undo
12313 12313
             return \mb_substr_count($haystack, $needle, $encoding);
12314 12314
         }
12315 12315
 
12316
-        \preg_match_all('/' . \preg_quote($needle, '/') . '/us', $haystack, $matches, \PREG_SET_ORDER);
12316
+        \preg_match_all('/'.\preg_quote($needle, '/').'/us', $haystack, $matches, \PREG_SET_ORDER);
12317 12317
 
12318 12318
         return \count($matches);
12319 12319
     }
@@ -12385,7 +12385,7 @@  discard block
 block discarded – undo
12385 12385
             if ($haystack_tmp === false) {
12386 12386
                 $haystack_tmp = '';
12387 12387
             }
12388
-            $haystack = (string) $haystack_tmp;
12388
+            $haystack = (string)$haystack_tmp;
12389 12389
         }
12390 12390
 
12391 12391
         if (self::$SUPPORT['mbstring_func_overload'] === true) {
@@ -12426,10 +12426,10 @@  discard block
 block discarded – undo
12426 12426
 
12427 12427
         if ($encoding === 'UTF-8') {
12428 12428
             if ($case_sensitive) {
12429
-                return (int) \mb_substr_count($str, $substring);
12429
+                return (int)\mb_substr_count($str, $substring);
12430 12430
             }
12431 12431
 
12432
-            return (int) \mb_substr_count(
12432
+            return (int)\mb_substr_count(
12433 12433
                 \mb_strtoupper($str),
12434 12434
                 \mb_strtoupper($substring)
12435 12435
             );
@@ -12438,10 +12438,10 @@  discard block
 block discarded – undo
12438 12438
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
12439 12439
 
12440 12440
         if ($case_sensitive) {
12441
-            return (int) \mb_substr_count($str, $substring, $encoding);
12441
+            return (int)\mb_substr_count($str, $substring, $encoding);
12442 12442
         }
12443 12443
 
12444
-        return (int) \mb_substr_count(
12444
+        return (int)\mb_substr_count(
12445 12445
             self::strtocasefold($str, true, false, $encoding, null, false),
12446 12446
             self::strtocasefold($substring, true, false, $encoding, null, false),
12447 12447
             $encoding
@@ -12475,7 +12475,7 @@  discard block
 block discarded – undo
12475 12475
         }
12476 12476
 
12477 12477
         if (self::str_istarts_with($haystack, $needle)) {
12478
-            $haystack = (string) \mb_substr($haystack, (int) self::strlen($needle));
12478
+            $haystack = (string)\mb_substr($haystack, (int)self::strlen($needle));
12479 12479
         }
12480 12480
 
12481 12481
         return $haystack;
@@ -12542,7 +12542,7 @@  discard block
 block discarded – undo
12542 12542
         }
12543 12543
 
12544 12544
         if (self::str_iends_with($haystack, $needle)) {
12545
-            $haystack = (string) \mb_substr($haystack, 0, (int) self::strlen($haystack) - (int) self::strlen($needle));
12545
+            $haystack = (string)\mb_substr($haystack, 0, (int)self::strlen($haystack) - (int)self::strlen($needle));
12546 12546
         }
12547 12547
 
12548 12548
         return $haystack;
@@ -12575,7 +12575,7 @@  discard block
 block discarded – undo
12575 12575
         }
12576 12576
 
12577 12577
         if (self::str_starts_with($haystack, $needle)) {
12578
-            $haystack = (string) \mb_substr($haystack, (int) self::strlen($needle));
12578
+            $haystack = (string)\mb_substr($haystack, (int)self::strlen($needle));
12579 12579
         }
12580 12580
 
12581 12581
         return $haystack;
@@ -12636,7 +12636,7 @@  discard block
 block discarded – undo
12636 12636
             if (\is_array($offset)) {
12637 12637
                 $offset = \array_slice($offset, 0, $num);
12638 12638
                 foreach ($offset as &$value_tmp) {
12639
-                    $value_tmp = (int) $value_tmp === $value_tmp ? $value_tmp : 0;
12639
+                    $value_tmp = (int)$value_tmp === $value_tmp ? $value_tmp : 0;
12640 12640
                 }
12641 12641
                 unset($value_tmp);
12642 12642
             } else {
@@ -12649,7 +12649,7 @@  discard block
 block discarded – undo
12649 12649
             } elseif (\is_array($length)) {
12650 12650
                 $length = \array_slice($length, 0, $num);
12651 12651
                 foreach ($length as &$value_tmp_V2) {
12652
-                    $value_tmp_V2 = (int) $value_tmp_V2 === $value_tmp_V2 ? $value_tmp_V2 : $num;
12652
+                    $value_tmp_V2 = (int)$value_tmp_V2 === $value_tmp_V2 ? $value_tmp_V2 : $num;
12653 12653
                 }
12654 12654
                 unset($value_tmp_V2);
12655 12655
             } else {
@@ -12670,8 +12670,8 @@  discard block
 block discarded – undo
12670 12670
         }
12671 12671
 
12672 12672
         // init
12673
-        $str = (string) $str;
12674
-        $replacement = (string) $replacement;
12673
+        $str = (string)$str;
12674
+        $replacement = (string)$replacement;
12675 12675
 
12676 12676
         if (\is_array($length)) {
12677 12677
             throw new \InvalidArgumentException('Parameter "$length" can only be an array, if "$str" is also an array.');
@@ -12686,16 +12686,16 @@  discard block
 block discarded – undo
12686 12686
         }
12687 12687
 
12688 12688
         if (self::$SUPPORT['mbstring'] === true) {
12689
-            $string_length = (int) self::strlen($str, $encoding);
12689
+            $string_length = (int)self::strlen($str, $encoding);
12690 12690
 
12691 12691
             if ($offset < 0) {
12692
-                $offset = (int) \max(0, $string_length + $offset);
12692
+                $offset = (int)\max(0, $string_length + $offset);
12693 12693
             } elseif ($offset > $string_length) {
12694 12694
                 $offset = $string_length;
12695 12695
             }
12696 12696
 
12697 12697
             if ($length !== null && $length < 0) {
12698
-                $length = (int) \max(0, $string_length - $offset + $length);
12698
+                $length = (int)\max(0, $string_length - $offset + $length);
12699 12699
             } elseif ($length === null || $length > $string_length) {
12700 12700
                 $length = $string_length;
12701 12701
             }
@@ -12706,9 +12706,9 @@  discard block
 block discarded – undo
12706 12706
             }
12707 12707
 
12708 12708
             /** @noinspection AdditionOperationOnArraysInspection */
12709
-            return ((string) \mb_substr($str, 0, $offset, $encoding)) .
12710
-                   $replacement .
12711
-                   ((string) \mb_substr($str, $offset + $length, $string_length - $offset - $length, $encoding));
12709
+            return ((string)\mb_substr($str, 0, $offset, $encoding)).
12710
+                   $replacement.
12711
+                   ((string)\mb_substr($str, $offset + $length, $string_length - $offset - $length, $encoding));
12712 12712
         }
12713 12713
 
12714 12714
         //
@@ -12717,8 +12717,7 @@  discard block
 block discarded – undo
12717 12717
 
12718 12718
         if (ASCII::is_ascii($str)) {
12719 12719
             return ($length === null) ?
12720
-                \substr_replace($str, $replacement, $offset) :
12721
-                \substr_replace($str, $replacement, $offset, $length);
12720
+                \substr_replace($str, $replacement, $offset) : \substr_replace($str, $replacement, $offset, $length);
12722 12721
         }
12723 12722
 
12724 12723
         //
@@ -12777,14 +12776,14 @@  discard block
 block discarded – undo
12777 12776
             &&
12778 12777
             \substr($haystack, -\strlen($needle)) === $needle
12779 12778
         ) {
12780
-            return (string) \mb_substr($haystack, 0, (int) \mb_strlen($haystack) - (int) \mb_strlen($needle));
12779
+            return (string)\mb_substr($haystack, 0, (int)\mb_strlen($haystack) - (int)\mb_strlen($needle));
12781 12780
         }
12782 12781
 
12783 12782
         if (\substr($haystack, -\strlen($needle)) === $needle) {
12784
-            return (string) self::substr(
12783
+            return (string)self::substr(
12785 12784
                 $haystack,
12786 12785
                 0,
12787
-                (int) self::strlen($haystack, $encoding) - (int) self::strlen($needle, $encoding),
12786
+                (int)self::strlen($haystack, $encoding) - (int)self::strlen($needle, $encoding),
12788 12787
                 $encoding
12789 12788
             );
12790 12789
         }
@@ -12819,10 +12818,10 @@  discard block
 block discarded – undo
12819 12818
         }
12820 12819
 
12821 12820
         if ($encoding === 'UTF-8') {
12822
-            return (string) (\mb_strtolower($str) ^ \mb_strtoupper($str) ^ $str);
12821
+            return (string)(\mb_strtolower($str) ^ \mb_strtoupper($str) ^ $str);
12823 12822
         }
12824 12823
 
12825
-        return (string) (self::strtolower($str, $encoding) ^ self::strtoupper($str, $encoding) ^ $str);
12824
+        return (string)(self::strtolower($str, $encoding) ^ self::strtoupper($str, $encoding) ^ $str);
12826 12825
     }
12827 12826
 
12828 12827
     /**
@@ -13034,7 +13033,7 @@  discard block
 block discarded – undo
13034 13033
     public static function to_boolean($str): bool
13035 13034
     {
13036 13035
         // init
13037
-        $str = (string) $str;
13036
+        $str = (string)$str;
13038 13037
 
13039 13038
         if ($str === '') {
13040 13039
             return false;
@@ -13062,10 +13061,10 @@  discard block
 block discarded – undo
13062 13061
         }
13063 13062
 
13064 13063
         if (\is_numeric($str)) {
13065
-            return ((float) $str) > 0;
13064
+            return ((float)$str) > 0;
13066 13065
         }
13067 13066
 
13068
-        return (bool) \trim($str);
13067
+        return (bool)\trim($str);
13069 13068
     }
13070 13069
 
13071 13070
     /**
@@ -13117,7 +13116,7 @@  discard block
 block discarded – undo
13117 13116
             return $str;
13118 13117
         }
13119 13118
 
13120
-        $str = (string) $str;
13119
+        $str = (string)$str;
13121 13120
         if ($str === '') {
13122 13121
             return '';
13123 13122
         }
@@ -13226,7 +13225,7 @@  discard block
 block discarded – undo
13226 13225
                     $c2 = $i + 1 >= $max ? "\x00" : $str[$i + 1];
13227 13226
 
13228 13227
                     if ($c2 >= "\x80" && $c2 <= "\xBF") { // yeah, almost sure it's UTF8 already
13229
-                        $buf .= $c1 . $c2;
13228
+                        $buf .= $c1.$c2;
13230 13229
                         ++$i;
13231 13230
                     } else { // not valid UTF8 - convert it
13232 13231
                         $buf .= self::to_utf8_convert_helper($c1);
@@ -13237,7 +13236,7 @@  discard block
 block discarded – undo
13237 13236
                     $c3 = $i + 2 >= $max ? "\x00" : $str[$i + 2];
13238 13237
 
13239 13238
                     if ($c2 >= "\x80" && $c2 <= "\xBF" && $c3 >= "\x80" && $c3 <= "\xBF") { // yeah, almost sure it's UTF8 already
13240
-                        $buf .= $c1 . $c2 . $c3;
13239
+                        $buf .= $c1.$c2.$c3;
13241 13240
                         $i += 2;
13242 13241
                     } else { // not valid UTF8 - convert it
13243 13242
                         $buf .= self::to_utf8_convert_helper($c1);
@@ -13249,7 +13248,7 @@  discard block
 block discarded – undo
13249 13248
                     $c4 = $i + 3 >= $max ? "\x00" : $str[$i + 3];
13250 13249
 
13251 13250
                     if ($c2 >= "\x80" && $c2 <= "\xBF" && $c3 >= "\x80" && $c3 <= "\xBF" && $c4 >= "\x80" && $c4 <= "\xBF") { // yeah, almost sure it's UTF8 already
13252
-                        $buf .= $c1 . $c2 . $c3 . $c4;
13251
+                        $buf .= $c1.$c2.$c3.$c4;
13253 13252
                         $i += 3;
13254 13253
                     } else { // not valid UTF8 - convert it
13255 13254
                         $buf .= self::to_utf8_convert_helper($c1);
@@ -13277,13 +13276,13 @@  discard block
 block discarded – undo
13277 13276
              *
13278 13277
              * @return string
13279 13278
              */
13280
-            static function (array $matches): string {
13279
+            static function(array $matches): string {
13281 13280
                 if (isset($matches[3])) {
13282
-                    $cp = (int) \hexdec($matches[3]);
13281
+                    $cp = (int)\hexdec($matches[3]);
13283 13282
                 } else {
13284 13283
                     // http://unicode.org/faq/utf_bom.html#utf16-4
13285
-                    $cp = ((int) \hexdec($matches[1]) << 10)
13286
-                          + (int) \hexdec($matches[2])
13284
+                    $cp = ((int)\hexdec($matches[1]) << 10)
13285
+                          + (int)\hexdec($matches[2])
13287 13286
                           + 0x10000
13288 13287
                           - (0xD800 << 10)
13289 13288
                           - 0xDC00;
@@ -13294,12 +13293,12 @@  discard block
 block discarded – undo
13294 13293
                 // php_utf32_utf8(unsigned char *buf, unsigned k)
13295 13294
 
13296 13295
                 if ($cp < 0x80) {
13297
-                    return (string) self::chr($cp);
13296
+                    return (string)self::chr($cp);
13298 13297
                 }
13299 13298
 
13300 13299
                 if ($cp < 0xA0) {
13301 13300
                     /** @noinspection UnnecessaryCastingInspection */
13302
-                    return (string) self::chr(0xC0 | $cp >> 6) . (string) self::chr(0x80 | $cp & 0x3F);
13301
+                    return (string)self::chr(0xC0 | $cp >> 6).(string)self::chr(0x80 | $cp & 0x3F);
13303 13302
                 }
13304 13303
 
13305 13304
                 return self::decimal_to_chr($cp);
@@ -13332,7 +13331,7 @@  discard block
 block discarded – undo
13332 13331
     public static function to_int(string $str)
13333 13332
     {
13334 13333
         if (\is_numeric($str)) {
13335
-            return (int) $str;
13334
+            return (int)$str;
13336 13335
         }
13337 13336
 
13338 13337
         return null;
@@ -13367,7 +13366,7 @@  discard block
 block discarded – undo
13367 13366
             ||
13368 13367
             $input_type === 'double'
13369 13368
         ) {
13370
-            return (string) $input;
13369
+            return (string)$input;
13371 13370
         }
13372 13371
 
13373 13372
         if ($input_type === 'object') {
@@ -13377,7 +13376,7 @@  discard block
 block discarded – undo
13377 13376
             /** @noinspection NestedPositiveIfStatementsInspection */
13378 13377
             /** @noinspection MissingOrEmptyGroupStatementInspection */
13379 13378
             if (\method_exists($input, '__toString')) {
13380
-                return (string) $input;
13379
+                return (string)$input;
13381 13380
             }
13382 13381
         }
13383 13382
 
@@ -13418,7 +13417,7 @@  discard block
 block discarded – undo
13418 13417
             }
13419 13418
 
13420 13419
             /** @noinspection PhpComposerExtensionStubsInspection */
13421
-            return (string) \mb_ereg_replace($pattern, '', $str);
13420
+            return (string)\mb_ereg_replace($pattern, '', $str);
13422 13421
         }
13423 13422
 
13424 13423
         if ($chars !== null) {
@@ -13469,15 +13468,15 @@  discard block
 block discarded – undo
13469 13468
         $use_mb_functions = $lang === null && !$try_to_keep_the_string_length;
13470 13469
 
13471 13470
         if ($encoding === 'UTF-8') {
13472
-            $str_part_two = (string) \mb_substr($str, 1);
13471
+            $str_part_two = (string)\mb_substr($str, 1);
13473 13472
 
13474 13473
             if ($use_mb_functions) {
13475 13474
                 $str_part_one = \mb_strtoupper(
13476
-                    (string) \mb_substr($str, 0, 1)
13475
+                    (string)\mb_substr($str, 0, 1)
13477 13476
                 );
13478 13477
             } else {
13479 13478
                 $str_part_one = self::strtoupper(
13480
-                    (string) \mb_substr($str, 0, 1),
13479
+                    (string)\mb_substr($str, 0, 1),
13481 13480
                     $encoding,
13482 13481
                     false,
13483 13482
                     $lang,
@@ -13487,16 +13486,16 @@  discard block
 block discarded – undo
13487 13486
         } else {
13488 13487
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
13489 13488
 
13490
-            $str_part_two = (string) self::substr($str, 1, null, $encoding);
13489
+            $str_part_two = (string)self::substr($str, 1, null, $encoding);
13491 13490
 
13492 13491
             if ($use_mb_functions) {
13493 13492
                 $str_part_one = \mb_strtoupper(
13494
-                    (string) \mb_substr($str, 0, 1, $encoding),
13493
+                    (string)\mb_substr($str, 0, 1, $encoding),
13495 13494
                     $encoding
13496 13495
                 );
13497 13496
             } else {
13498 13497
                 $str_part_one = self::strtoupper(
13499
-                    (string) self::substr($str, 0, 1, $encoding),
13498
+                    (string)self::substr($str, 0, 1, $encoding),
13500 13499
                     $encoding,
13501 13500
                     false,
13502 13501
                     $lang,
@@ -13505,7 +13504,7 @@  discard block
 block discarded – undo
13505 13504
             }
13506 13505
         }
13507 13506
 
13508
-        return $str_part_one . $str_part_two;
13507
+        return $str_part_one.$str_part_two;
13509 13508
     }
13510 13509
 
13511 13510
     /**
@@ -13566,7 +13565,7 @@  discard block
 block discarded – undo
13566 13565
             $str = self::clean($str);
13567 13566
         }
13568 13567
 
13569
-        $use_php_default_functions = !(bool) ($char_list . \implode('', $exceptions));
13568
+        $use_php_default_functions = !(bool)($char_list.\implode('', $exceptions));
13570 13569
 
13571 13570
         if (
13572 13571
             $use_php_default_functions
@@ -13967,7 +13966,7 @@  discard block
 block discarded – undo
13967 13966
         if (
13968 13967
             $keep_utf8_chars
13969 13968
             &&
13970
-            (int) self::strlen($return) >= (int) self::strlen($str_backup)
13969
+            (int)self::strlen($return) >= (int)self::strlen($str_backup)
13971 13970
         ) {
13972 13971
             return $str_backup;
13973 13972
         }
@@ -14058,17 +14057,17 @@  discard block
 block discarded – undo
14058 14057
             return '';
14059 14058
         }
14060 14059
 
14061
-        \preg_match('/^\\s*+(?:[^\\s]++\\s*+){1,' . $limit . '}/u', $str, $matches);
14060
+        \preg_match('/^\\s*+(?:[^\\s]++\\s*+){1,'.$limit.'}/u', $str, $matches);
14062 14061
 
14063 14062
         if (
14064 14063
             !isset($matches[0])
14065 14064
             ||
14066
-            \mb_strlen($str) === (int) \mb_strlen($matches[0])
14065
+            \mb_strlen($str) === (int)\mb_strlen($matches[0])
14067 14066
         ) {
14068 14067
             return $str;
14069 14068
         }
14070 14069
 
14071
-        return \rtrim($matches[0]) . $str_add_on;
14070
+        return \rtrim($matches[0]).$str_add_on;
14072 14071
     }
14073 14072
 
14074 14073
     /**
@@ -14164,7 +14163,7 @@  discard block
 block discarded – undo
14164 14163
             }
14165 14164
         }
14166 14165
 
14167
-        return $str_return . \implode('', $charsArray);
14166
+        return $str_return.\implode('', $charsArray);
14168 14167
     }
14169 14168
 
14170 14169
     /**
@@ -14218,7 +14217,7 @@  discard block
 block discarded – undo
14218 14217
             $final_break = '';
14219 14218
         }
14220 14219
 
14221
-        return \implode($delimiter ?? "\n", $string_helper_array) . $final_break;
14220
+        return \implode($delimiter ?? "\n", $string_helper_array).$final_break;
14222 14221
     }
14223 14222
 
14224 14223
     /**
@@ -14460,7 +14459,7 @@  discard block
 block discarded – undo
14460 14459
         /** @noinspection PhpIncludeInspection */
14461 14460
         /** @noinspection UsingInclusionReturnValueInspection */
14462 14461
         /** @psalm-suppress UnresolvableInclude */
14463
-        return include __DIR__ . '/data/' . $file . '.php';
14462
+        return include __DIR__.'/data/'.$file.'.php';
14464 14463
     }
14465 14464
 
14466 14465
     /**
@@ -14480,7 +14479,7 @@  discard block
 block discarded – undo
14480 14479
              */
14481 14480
             \uksort(
14482 14481
                 self::$EMOJI,
14483
-                static function (string $a, string $b): int {
14482
+                static function(string $a, string $b): int {
14484 14483
                     return \strlen($b) <=> \strlen($a);
14485 14484
                 }
14486 14485
             );
@@ -14490,7 +14489,7 @@  discard block
 block discarded – undo
14490 14489
 
14491 14490
             foreach (self::$EMOJI_KEYS_CACHE as $key) {
14492 14491
                 $tmp_key = \crc32($key);
14493
-                self::$EMOJI_KEYS_REVERSIBLE_CACHE[] = '_-_PORTABLE_UTF8_-_' . $tmp_key . '_-_' . \strrev((string) $tmp_key) . '_-_8FTU_ELBATROP_-_';
14492
+                self::$EMOJI_KEYS_REVERSIBLE_CACHE[] = '_-_PORTABLE_UTF8_-_'.$tmp_key.'_-_'.\strrev((string)$tmp_key).'_-_8FTU_ELBATROP_-_';
14494 14493
             }
14495 14494
 
14496 14495
             return true;
@@ -14518,7 +14517,7 @@  discard block
 block discarded – undo
14518 14517
         /** @noinspection PhpUsageOfSilenceOperatorInspection */
14519 14518
         return \defined('MB_OVERLOAD_STRING')
14520 14519
                &&
14521
-               ((int) @\ini_get('mbstring.func_overload') & \MB_OVERLOAD_STRING);
14520
+               ((int)@\ini_get('mbstring.func_overload') & \MB_OVERLOAD_STRING);
14522 14521
     }
14523 14522
 
14524 14523
     /**
@@ -14584,7 +14583,7 @@  discard block
 block discarded – undo
14584 14583
          */
14585 14584
         static $RX_CLASS_CACHE = [];
14586 14585
 
14587
-        $cache_key = $s . '_' . $class;
14586
+        $cache_key = $s.'_'.$class;
14588 14587
 
14589 14588
         if (isset($RX_CLASS_CACHE[$cache_key])) {
14590 14589
             return $RX_CLASS_CACHE[$cache_key];
@@ -14596,7 +14595,7 @@  discard block
 block discarded – undo
14596 14595
         /** @noinspection AlterInForeachInspection */
14597 14596
         foreach (self::str_split($s) as &$s) {
14598 14597
             if ($s === '-') {
14599
-                $class_array[0] = '-' . $class_array[0];
14598
+                $class_array[0] = '-'.$class_array[0];
14600 14599
             } elseif (!isset($s[2])) {
14601 14600
                 $class_array[0] .= \preg_quote($s, '/');
14602 14601
             } elseif (self::strlen($s) === 1) {
@@ -14607,13 +14606,13 @@  discard block
 block discarded – undo
14607 14606
         }
14608 14607
 
14609 14608
         if ($class_array[0]) {
14610
-            $class_array[0] = '[' . $class_array[0] . ']';
14609
+            $class_array[0] = '['.$class_array[0].']';
14611 14610
         }
14612 14611
 
14613 14612
         if (\count($class_array) === 1) {
14614 14613
             $return = $class_array[0];
14615 14614
         } else {
14616
-            $return = '(?:' . \implode('|', $class_array) . ')';
14615
+            $return = '(?:'.\implode('|', $class_array).')';
14617 14616
         }
14618 14617
 
14619 14618
         $RX_CLASS_CACHE[$cache_key] = $return;
@@ -14694,7 +14693,7 @@  discard block
 block discarded – undo
14694 14693
 
14695 14694
             if ($delimiter === '-') {
14696 14695
                 /** @noinspection AlterInForeachInspection */
14697
-                foreach ((array) $special_cases['names'] as &$beginning) {
14696
+                foreach ((array)$special_cases['names'] as &$beginning) {
14698 14697
                     if (\strncmp($name, $beginning, \strlen($beginning)) === 0) {
14699 14698
                         $continue = true;
14700 14699
 
@@ -14704,7 +14703,7 @@  discard block
 block discarded – undo
14704 14703
             }
14705 14704
 
14706 14705
             /** @noinspection AlterInForeachInspection */
14707
-            foreach ((array) $special_cases['prefixes'] as &$beginning) {
14706
+            foreach ((array)$special_cases['prefixes'] as &$beginning) {
14708 14707
                 if (\strncmp($name, $beginning, \strlen($beginning)) === 0) {
14709 14708
                     $continue = true;
14710 14709
 
@@ -14779,8 +14778,8 @@  discard block
 block discarded – undo
14779 14778
         } else {
14780 14779
             /** @noinspection OffsetOperationsInspection */
14781 14780
             $cc1 = self::$CHR[$ordC1 / 64] | "\xC0";
14782
-            $cc2 = ((string) $input & "\x3F") | "\x80";
14783
-            $buf .= $cc1 . $cc2;
14781
+            $cc2 = ((string)$input & "\x3F") | "\x80";
14782
+            $buf .= $cc1.$cc2;
14784 14783
         }
14785 14784
 
14786 14785
         return $buf;
@@ -14803,7 +14802,7 @@  discard block
 block discarded – undo
14803 14802
 
14804 14803
         $pattern = '/%u([0-9a-fA-F]{3,4})/';
14805 14804
         if (\preg_match($pattern, $str)) {
14806
-            $str = (string) \preg_replace($pattern, '&#x\\1;', $str);
14805
+            $str = (string)\preg_replace($pattern, '&#x\\1;', $str);
14807 14806
         }
14808 14807
 
14809 14808
         return $str;
Please login to merge, or discard this patch.