voku / portable-utf8

src/voku/helper/UTF8.php

Spacing +468 added lines, -469 removed lines

@@ -260,10 +260,10 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            return (string) \mb_substr($str, $pos, 1);
+            return (string)\mb_substr($str, $pos, 1);
         }
 
-        return (string) self::substr($str, $pos, 1, $encoding);
+        return (string)self::substr($str, $pos, 1, $encoding);
     }
 
     /**
@@ -278,7 +278,7 @@ 
     public static function add_bom_to_string(string $str): string
     {
         if (self::string_has_bom($str) === false) {
-            $str = self::bom() . $str;
+            $str = self::bom().$str;
         }
 
         return $str;
@@ -307,8 +307,8 @@ 
         $return = [];
         foreach ($array as $key => &$value) {
             $key = $case === \CASE_LOWER
-                ? self::strtolower((string) $key, $encoding)
-                : self::strtoupper((string) $key, $encoding);
+                ? self::strtolower((string)$key, $encoding)
+                : self::strtoupper((string)$key, $encoding);
 
             $return[$key] = $value;
         }
@@ -342,7 +342,7 @@ 
                 return '';
             }
 
-            $substrIndex = $posStart + (int) \mb_strlen($start);
+            $substrIndex = $posStart + (int)\mb_strlen($start);
             $posEnd = \mb_strpos($str, $end, $substrIndex);
             if (
                 $posEnd === false
@@ -352,7 +352,7 @@ 
                 return '';
             }
 
-            return (string) \mb_substr($str, $substrIndex, $posEnd - $substrIndex);
+            return (string)\mb_substr($str, $substrIndex, $posEnd - $substrIndex);
         }
 
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
@@ -362,7 +362,7 @@ 
             return '';
         }
 
-        $substrIndex = $posStart + (int) self::strlen($start, $encoding);
+        $substrIndex = $posStart + (int)self::strlen($start, $encoding);
         $posEnd = self::strpos($str, $end, $substrIndex, $encoding);
         if (
             $posEnd === false
@@ -372,7 +372,7 @@ 
             return '';
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
             $substrIndex,
             $posEnd - $substrIndex,
@@ -440,10 +440,10 @@ 
     public static function char_at(string $str, int $index, string $encoding = 'UTF-8'): string
     {
         if ($encoding === 'UTF-8') {
-            return (string) \mb_substr($str, $index, 1);
+            return (string)\mb_substr($str, $index, 1);
         }
 
-        return (string) self::substr($str, $index, 1, $encoding);
+        return (string)self::substr($str, $index, 1, $encoding);
     }
 
     /**
@@ -542,10 +542,10 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::chr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::chr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
-        $cacheKey = $code_point . $encoding;
+        $cacheKey = $code_point.$encoding;
         if (isset($CHAR_CACHE[$cacheKey]) === true) {
             return $CHAR_CACHE[$cacheKey];
         }
@@ -553,7 +553,7 @@ 
         if ($code_point <= 127) { // use "simple"-char only until "\x80"
 
             if (self::$CHR === null) {
-                self::$CHR = (array) self::getData('chr');
+                self::$CHR = (array)self::getData('chr');
             }
 
             /**
@@ -588,10 +588,10 @@ 
         //
 
         if (self::$CHR === null) {
-            self::$CHR = (array) self::getData('chr');
+            self::$CHR = (array)self::getData('chr');
         }
 
-        $code_point = (int) $code_point;
+        $code_point = (int)$code_point;
         if ($code_point <= 0x7F) {
             /**
              * @psalm-suppress PossiblyNullArrayAccess
@@ -601,22 +601,22 @@ 
             /**
              * @psalm-suppress PossiblyNullArrayAccess
              */
-            $chr = self::$CHR[($code_point >> 6) + 0xC0] .
+            $chr = self::$CHR[($code_point >> 6) + 0xC0].
                    self::$CHR[($code_point & 0x3F) + 0x80];
         } elseif ($code_point <= 0xFFFF) {
             /**
              * @psalm-suppress PossiblyNullArrayAccess
              */
-            $chr = self::$CHR[($code_point >> 12) + 0xE0] .
-                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80] .
+            $chr = self::$CHR[($code_point >> 12) + 0xE0].
+                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80].
                    self::$CHR[($code_point & 0x3F) + 0x80];
         } else {
             /**
              * @psalm-suppress PossiblyNullArrayAccess
              */
-            $chr = self::$CHR[($code_point >> 18) + 0xF0] .
-                   self::$CHR[(($code_point >> 12) & 0x3F) + 0x80] .
-                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80] .
+            $chr = self::$CHR[($code_point >> 18) + 0xF0].
+                   self::$CHR[(($code_point >> 12) & 0x3F) + 0x80].
+                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80].
                    self::$CHR[($code_point & 0x3F) + 0x80];
         }
 
@@ -663,7 +663,7 @@ 
 
         if (self::$SUPPORT['mbstring_func_overload'] === true) {
             return \array_map(
-                static function (string $data): int {
+                static function(string $data): int {
                     // "mb_" is available if overload is used, so use it ...
                     return \mb_strlen($data, 'CP850'); // 8-BIT
                 },
@@ -731,7 +731,7 @@ 
             $char = '';
         }
 
-        return self::int_to_hex(self::ord((string) $char), $pfix);
+        return self::int_to_hex(self::ord((string)$char), $pfix);
     }
 
     /**
@@ -805,7 +805,7 @@ 
         | ( [\x80-\xBF] )                 # invalid byte in range 10000000 - 10111111
         | ( [\xC0-\xFF] )                 # invalid byte in range 11000000 - 11111111
         /x';
-        $str = (string) \preg_replace($regx, '$1', $str);
+        $str = (string)\preg_replace($regx, '$1', $str);
 
         if ($replace_diamond_question_mark === true) {
             $str = self::replace_diamond_question_mark($str, '');
@@ -840,7 +840,7 @@ 
     public static function cleanup($str): string
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return '';
@@ -923,7 +923,7 @@ 
     {
         if (self::$SUPPORT['mbstring'] === true) {
             /** @noinspection PhpComposerExtensionStubsInspection */
-            return \trim((string) \mb_ereg_replace('[[:space:]]+', ' ', $str));
+            return \trim((string)\mb_ereg_replace('[[:space:]]+', ' ', $str));
         }
 
         return \trim(self::regex_replace($str, '[[:space:]]+', ' '));
@@ -963,7 +963,7 @@ 
      */
     public static function css_stripe_media_queries(string $str): string
     {
-        return (string) \preg_replace(
+        return (string)\preg_replace(
             '#@media\\s+(?:only\\s)?(?:[\\s{\\(]|screen|all)\\s?[^{]+{.*}\\s*}\\s*#isumU',
             '',
             $str
@@ -990,7 +990,7 @@ 
      */
     public static function decimal_to_chr($int): string
     {
-        return self::html_entity_decode('&#' . $int . ';', \ENT_QUOTES | \ENT_HTML5);
+        return self::html_entity_decode('&#'.$int.';', \ENT_QUOTES | \ENT_HTML5);
     }
 
     /**
@@ -1069,7 +1069,7 @@ 
         if ($toEncoding === 'JSON') {
             $return = self::json_encode($str);
             if ($return === false) {
-                throw new \InvalidArgumentException('The input string [' . $str . '] can not be used for json_encode().');
+                throw new \InvalidArgumentException('The input string ['.$str.'] can not be used for json_encode().');
             }
 
             return $return;
@@ -1155,7 +1155,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::encode() without mbstring cannot handle "' . $toEncoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::encode() without mbstring cannot handle "'.$toEncoding.'" encoding', \E_USER_WARNING);
         }
 
         if (self::$SUPPORT['mbstring'] === true) {
@@ -1249,31 +1249,31 @@ 
         $trimChars = "\t\r\n -_()!~?=+/*\\,.:;\"'[]{}`&";
 
         if ($length === null) {
-            $length = (int) \round((int) self::strlen($str, $encoding) / 2, 0);
+            $length = (int)\round((int)self::strlen($str, $encoding) / 2, 0);
         }
 
         if ($search === '') {
             if ($encoding === 'UTF-8') {
                 if ($length > 0) {
-                    $stringLength = (int) \mb_strlen($str);
+                    $stringLength = (int)\mb_strlen($str);
                     $end = ($length - 1) > $stringLength ? $stringLength : ($length - 1);
                 } else {
                     $end = 0;
                 }
 
-                $pos = (int) \min(
+                $pos = (int)\min(
                     \mb_strpos($str, ' ', $end),
                     \mb_strpos($str, '.', $end)
                 );
             } else {
                 if ($length > 0) {
-                    $stringLength = (int) self::strlen($str, $encoding);
+                    $stringLength = (int)self::strlen($str, $encoding);
                     $end = ($length - 1) > $stringLength ? $stringLength : ($length - 1);
                 } else {
                     $end = 0;
                 }
 
-                $pos = (int) \min(
+                $pos = (int)\min(
                     self::strpos($str, ' ', $end, $encoding),
                     self::strpos($str, '.', $end, $encoding)
                 );
@@ -1290,18 +1290,18 @@ 
                     return '';
                 }
 
-                return \rtrim($strSub, $trimChars) . $replacerForSkippedText;
+                return \rtrim($strSub, $trimChars).$replacerForSkippedText;
             }
 
             return $str;
         }
 
         if ($encoding === 'UTF-8') {
-            $wordPos = (int) \mb_stripos($str, $search);
-            $halfSide = (int) ($wordPos - $length / 2 + (int) \mb_strlen($search) / 2);
+            $wordPos = (int)\mb_stripos($str, $search);
+            $halfSide = (int)($wordPos - $length / 2 + (int)\mb_strlen($search) / 2);
         } else {
-            $wordPos = (int) self::stripos($str, $search, 0, $encoding);
-            $halfSide = (int) ($wordPos - $length / 2 + (int) self::strlen($search, $encoding) / 2);
+            $wordPos = (int)self::stripos($str, $search, 0, $encoding);
+            $halfSide = (int)($wordPos - $length / 2 + (int)self::strlen($search, $encoding) / 2);
         }
 
         $pos_start = 0;
@@ -1313,12 +1313,12 @@ 
             }
             if ($halfText !== false) {
                 if ($encoding === 'UTF-8') {
-                    $pos_start = (int) \max(
+                    $pos_start = (int)\max(
                         \mb_strrpos($halfText, ' '),
                         \mb_strrpos($halfText, '.')
                     );
                 } else {
-                    $pos_start = (int) \max(
+                    $pos_start = (int)\max(
                         self::strrpos($halfText, ' ', 0, $encoding),
                         self::strrpos($halfText, '.', 0, $encoding)
                     );
@@ -1328,19 +1328,19 @@ 
 
         if ($wordPos && $halfSide > 0) {
             $offset = $pos_start + $length - 1;
-            $realLength = (int) self::strlen($str, $encoding);
+            $realLength = (int)self::strlen($str, $encoding);
 
             if ($offset > $realLength) {
                 $offset = $realLength;
             }
 
             if ($encoding === 'UTF-8') {
-                $pos_end = (int) \min(
+                $pos_end = (int)\min(
                     \mb_strpos($str, ' ', $offset),
                     \mb_strpos($str, '.', $offset)
                 ) - $pos_start;
             } else {
-                $pos_end = (int) \min(
+                $pos_end = (int)\min(
                     self::strpos($str, ' ', $offset, $encoding),
                     self::strpos($str, '.', $offset, $encoding)
                 ) - $pos_start;
@@ -1348,12 +1348,12 @@ 
 
             if (!$pos_end || $pos_end <= 0) {
                 if ($encoding === 'UTF-8') {
-                    $strSub = \mb_substr($str, $pos_start, (int) \mb_strlen($str));
+                    $strSub = \mb_substr($str, $pos_start, (int)\mb_strlen($str));
                 } else {
-                    $strSub = self::substr($str, $pos_start, (int) self::strlen($str, $encoding), $encoding);
+                    $strSub = self::substr($str, $pos_start, (int)self::strlen($str, $encoding), $encoding);
                 }
                 if ($strSub !== false) {
-                    $extract = $replacerForSkippedText . \ltrim($strSub, $trimChars);
+                    $extract = $replacerForSkippedText.\ltrim($strSub, $trimChars);
                 } else {
                     $extract = '';
                 }
@@ -1364,26 +1364,26 @@ 
                     $strSub = self::substr($str, $pos_start, $pos_end, $encoding);
                 }
                 if ($strSub !== false) {
-                    $extract = $replacerForSkippedText . \trim($strSub, $trimChars) . $replacerForSkippedText;
+                    $extract = $replacerForSkippedText.\trim($strSub, $trimChars).$replacerForSkippedText;
                 } else {
                     $extract = '';
                 }
             }
         } else {
             $offset = $length - 1;
-            $trueLength = (int) self::strlen($str, $encoding);
+            $trueLength = (int)self::strlen($str, $encoding);
 
             if ($offset > $trueLength) {
                 $offset = $trueLength;
             }
 
             if ($encoding === 'UTF-8') {
-                $pos_end = (int) \min(
+                $pos_end = (int)\min(
                     \mb_strpos($str, ' ', $offset),
                     \mb_strpos($str, '.', $offset)
                 );
             } else {
-                $pos_end = (int) \min(
+                $pos_end = (int)\min(
                     self::strpos($str, ' ', $offset, $encoding),
                     self::strpos($str, '.', $offset, $encoding)
                 );
@@ -1396,7 +1396,7 @@ 
                     $strSub = self::substr($str, 0, $pos_end, $encoding);
                 }
                 if ($strSub !== false) {
-                    $extract = \rtrim($strSub, $trimChars) . $replacerForSkippedText;
+                    $extract = \rtrim($strSub, $trimChars).$replacerForSkippedText;
                 } else {
                     $extract = '';
                 }
@@ -1520,7 +1520,7 @@ 
     {
         $file_content = \file_get_contents($file_path);
         if ($file_content === false) {
-            throw new \RuntimeException('file_get_contents() returned false for:' . $file_path);
+            throw new \RuntimeException('file_get_contents() returned false for:'.$file_path);
         }
 
         return self::string_has_bom($file_content);
@@ -1581,7 +1581,7 @@ 
                     ) {
                         // Prevent leading combining chars
                         // for NFC-safe concatenations.
-                        $var = $leading_combining . $var;
+                        $var = $leading_combining.$var;
                     }
                 }
 
@@ -1820,10 +1820,10 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            return (string) \mb_substr($str, 0, $n);
+            return (string)\mb_substr($str, 0, $n);
         }
 
-        return (string) self::substr($str, 0, $n, $encoding);
+        return (string)self::substr($str, 0, $n, $encoding);
     }
 
     /**
@@ -1898,7 +1898,7 @@ 
             return $str;
         }
 
-        $str = (string) $str;
+        $str = (string)$str;
         $last = '';
         while ($last !== $str) {
             $last = $str;
@@ -2086,7 +2086,7 @@ 
         if ($str_info === false) {
             return $fallback;
         }
-        $type_code = (int) ($str_info['chars1'] . $str_info['chars2']);
+        $type_code = (int)($str_info['chars1'].$str_info['chars2']);
 
         // DEBUG
         //var_dump($type_code);
@@ -2175,7 +2175,7 @@ 
         //
 
         if ($encoding === 'UTF-8') {
-            $maxlength = (int) \mb_strlen($possibleChars);
+            $maxlength = (int)\mb_strlen($possibleChars);
             if ($maxlength === 0) {
                 return '';
             }
@@ -2196,7 +2196,7 @@ 
         } else {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            $maxlength = (int) self::strlen($possibleChars, $encoding);
+            $maxlength = (int)self::strlen($possibleChars, $encoding);
             if ($maxlength === 0) {
                 return '';
             }
@@ -2227,16 +2227,16 @@ 
      */
     public static function get_unique_string($entropyExtra = '', bool $md5 = true): string
     {
-        $uniqueHelper = \random_int(0, \mt_getrandmax()) .
-                        \session_id() .
-                        ($_SERVER['REMOTE_ADDR'] ?? '') .
-                        ($_SERVER['SERVER_ADDR'] ?? '') .
+        $uniqueHelper = \random_int(0, \mt_getrandmax()).
+                        \session_id().
+                        ($_SERVER['REMOTE_ADDR'] ?? '').
+                        ($_SERVER['SERVER_ADDR'] ?? '').
                         $entropyExtra;
 
         $uniqueString = \uniqid($uniqueHelper, true);
 
         if ($md5) {
-            $uniqueString = \md5($uniqueString . $uniqueHelper);
+            $uniqueString = \md5($uniqueString.$uniqueHelper);
         }
 
         return $uniqueString;
@@ -2316,7 +2316,7 @@ 
     public static function hex_to_int($hexDec)
     {
         // init
-        $hexDec = (string) $hexDec;
+        $hexDec = (string)$hexDec;
 
         if ($hexDec === '') {
             return false;
@@ -2394,7 +2394,7 @@ 
         return \implode(
             '',
             \array_map(
-                static function (string $chr) use ($keepAsciiChars, $encoding): string {
+                static function(string $chr) use ($keepAsciiChars, $encoding): string {
                     return self::single_chr_html_encode($chr, $keepAsciiChars, $encoding);
                 },
                 self::str_split($str)
@@ -2498,7 +2498,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::html_entity_decode() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::html_entity_decode() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         do {
@@ -2519,14 +2519,14 @@ 
                     );
                 }
             } else {
-                $str = (string) \preg_replace_callback(
+                $str = (string)\preg_replace_callback(
                     "/&#\d{2,6};/",
                     /**
                      * @param string[] $matches
                      *
                      * @return string
                      */
-                    static function (array $matches) use ($encoding): string {
+                    static function(array $matches) use ($encoding): string {
                         $returnTmp = \mb_convert_encoding($matches[0], $encoding, 'HTML-ENTITIES');
                         if ($returnTmp !== '"' && $returnTmp !== "'") {
                             return $returnTmp;
@@ -2541,7 +2541,7 @@ 
             if (\strpos($str, '&') !== false) {
                 if (\strpos($str, '&#') !== false) {
                     // decode also numeric & UTF16 two byte entities
-                    $str = (string) \preg_replace(
+                    $str = (string)\preg_replace(
                         '/(&#(?:x0*[0-9a-fA-F]{2,6}(?![0-9a-fA-F;])|(?:0*\d{2,6}(?![0-9;]))))/S',
                         '$1;',
                         $str
@@ -2587,7 +2587,7 @@ 
      */
     public static function html_stripe_empty_tags(string $str): string
     {
-        return (string) \preg_replace(
+        return (string)\preg_replace(
             "/<[^\/>]*>(([\s]?)*|)<\/[^>]*>/u",
             '',
             $str
@@ -2886,9 +2886,9 @@ 
     {
         $hex = \dechex($int);
 
-        $hex = (\strlen($hex) < 4 ? \substr('0000' . $hex, -4) : $hex);
+        $hex = (\strlen($hex) < 4 ? \substr('0000'.$hex, -4) : $hex);
 
-        return $pfix . $hex . '';
+        return $pfix.$hex.'';
     }
 
     /**
@@ -3155,7 +3155,7 @@ 
      */
     public static function is_binary($input, bool $strict = false): bool
     {
-        $input = (string) $input;
+        $input = (string)$input;
         if ($input === '') {
             return false;
         }
@@ -3414,7 +3414,7 @@ 
     public static function is_utf16($str, $checkIfStringIsBinary = true)
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
         $strChars = [];
 
         if (
@@ -3492,7 +3492,7 @@ 
     public static function is_utf32($str, $checkIfStringIsBinary = true)
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
         $strChars = [];
 
         if (
@@ -3571,16 +3571,16 @@ 
         self::initEmojiData();
 
         if ($useReversibleStringMapping === true) {
-            return (string) \str_replace(
-                (array) self::$EMOJI_VALUES_CACHE,
-                (array) self::$EMOJI_KEYS_REVERSIBLE_CACHE,
+            return (string)\str_replace(
+                (array)self::$EMOJI_VALUES_CACHE,
+                (array)self::$EMOJI_KEYS_REVERSIBLE_CACHE,
                 $str
             );
         }
 
-        return (string) \str_replace(
-            (array) self::$EMOJI_VALUES_CACHE,
-            (array) self::$EMOJI_KEYS_CACHE,
+        return (string)\str_replace(
+            (array)self::$EMOJI_VALUES_CACHE,
+            (array)self::$EMOJI_KEYS_CACHE,
             $str
         );
     }
@@ -3600,16 +3600,16 @@ 
         self::initEmojiData();
 
         if ($useReversibleStringMapping === true) {
-            return (string) \str_replace(
-                (array) self::$EMOJI_KEYS_REVERSIBLE_CACHE,
-                (array) self::$EMOJI_VALUES_CACHE,
+            return (string)\str_replace(
+                (array)self::$EMOJI_KEYS_REVERSIBLE_CACHE,
+                (array)self::$EMOJI_VALUES_CACHE,
                 $str
             );
         }
 
-        return (string) \str_replace(
-            (array) self::$EMOJI_KEYS_CACHE,
-            (array) self::$EMOJI_VALUES_CACHE,
+        return (string)\str_replace(
+            (array)self::$EMOJI_KEYS_CACHE,
+            (array)self::$EMOJI_VALUES_CACHE,
             $str
         );
     }
@@ -3670,7 +3670,7 @@ 
             self::$ORD = self::getData('ord');
         }
 
-        $len = \strlen((string) $str);
+        $len = \strlen((string)$str);
         /** @noinspection ForeachInvariantsInspection */
         for ($i = 0; $i < $len; ++$i) {
             $in = self::$ORD[$str[$i]];
@@ -3907,15 +3907,15 @@ 
         $useMbFunction = $lang === null && $tryToKeepStringLength === false;
 
         if ($encoding === 'UTF-8') {
-            $strPartTwo = (string) \mb_substr($str, 1);
+            $strPartTwo = (string)\mb_substr($str, 1);
 
             if ($useMbFunction === true) {
                 $strPartOne = \mb_strtolower(
-                    (string) \mb_substr($str, 0, 1)
+                    (string)\mb_substr($str, 0, 1)
                 );
             } else {
                 $strPartOne = self::strtolower(
-                    (string) \mb_substr($str, 0, 1),
+                    (string)\mb_substr($str, 0, 1),
                     $encoding,
                     false,
                     $lang,
@@ -3925,10 +3925,10 @@ 
         } else {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            $strPartTwo = (string) self::substr($str, 1, null, $encoding);
+            $strPartTwo = (string)self::substr($str, 1, null, $encoding);
 
             $strPartOne = self::strtolower(
-                (string) self::substr($str, 0, 1, $encoding),
+                (string)self::substr($str, 0, 1, $encoding),
                 $encoding,
                 false,
                 $lang,
@@ -3936,7 +3936,7 @@ 
             );
         }
 
-        return $strPartOne . $strPartTwo;
+        return $strPartOne.$strPartTwo;
     }
 
     /**
@@ -4055,7 +4055,7 @@ 
 
         if (self::$SUPPORT['mbstring'] === true) {
             /** @noinspection PhpComposerExtensionStubsInspection */
-            return (string) \mb_ereg_replace($pattern, '', $str);
+            return (string)\mb_ereg_replace($pattern, '', $str);
         }
 
         return self::regex_replace($str, $pattern, '', '', '/');
@@ -4096,7 +4096,7 @@ 
     {
         $bytes = self::chr_size_list($str);
         if (\count($bytes) > 0) {
-            return (int) \max($bytes);
+            return (int)\max($bytes);
         }
 
         return 0;
@@ -4166,7 +4166,7 @@ 
         static $STATIC_NORMALIZE_ENCODING_CACHE = [];
 
         // init
-        $encoding = (string) $encoding;
+        $encoding = (string)$encoding;
 
         if (!$encoding) {
             return $fallback;
@@ -4220,7 +4220,7 @@ 
 
         $encodingOrig = $encoding;
         $encoding = \strtoupper($encoding);
-        $encodingUpperHelper = (string) \preg_replace('/[^a-zA-Z0-9\s]/u', '', $encoding);
+        $encodingUpperHelper = (string)\preg_replace('/[^a-zA-Z0-9\s]/u', '', $encoding);
 
         $equivalences = [
             'ISO8859'     => 'ISO-8859-1',
@@ -4378,7 +4378,7 @@ 
         }
 
         static $WHITESPACE_CACHE = [];
-        $cacheKey = (int) $keepNonBreakingSpace;
+        $cacheKey = (int)$keepNonBreakingSpace;
 
         if (!isset($WHITESPACE_CACHE[$cacheKey])) {
             $WHITESPACE_CACHE[$cacheKey] = self::$WHITESPACE_TABLE;
@@ -4420,13 +4420,13 @@ 
         static $CHAR_CACHE = [];
 
         // init
-        $chr = (string) $chr;
+        $chr = (string)$chr;
 
         if ($encoding !== 'UTF-8' && $encoding !== 'CP850') {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
         }
 
-        $cacheKey = $chr . $encoding;
+        $cacheKey = $chr.$encoding;
         if (isset($CHAR_CACHE[$cacheKey]) === true) {
             return $CHAR_CACHE[$cacheKey];
         }
@@ -4461,22 +4461,22 @@ 
         //
 
         /** @noinspection CallableParameterUseCaseInTypeContextInspection */
-        $chr = \unpack('C*', (string) \substr($chr, 0, 4));
+        $chr = \unpack('C*', (string)\substr($chr, 0, 4));
         $code = $chr ? $chr[1] : 0;
 
         if ($code >= 0xF0 && isset($chr[4])) {
             /** @noinspection UnnecessaryCastingInspection */
-            return $CHAR_CACHE[$cacheKey] = (int) ((($code - 0xF0) << 18) + (($chr[2] - 0x80) << 12) + (($chr[3] - 0x80) << 6) + $chr[4] - 0x80);
+            return $CHAR_CACHE[$cacheKey] = (int)((($code - 0xF0) << 18) + (($chr[2] - 0x80) << 12) + (($chr[3] - 0x80) << 6) + $chr[4] - 0x80);
         }
 
         if ($code >= 0xE0 && isset($chr[3])) {
             /** @noinspection UnnecessaryCastingInspection */
-            return $CHAR_CACHE[$cacheKey] = (int) ((($code - 0xE0) << 12) + (($chr[2] - 0x80) << 6) + $chr[3] - 0x80);
+            return $CHAR_CACHE[$cacheKey] = (int)((($code - 0xE0) << 12) + (($chr[2] - 0x80) << 6) + $chr[3] - 0x80);
         }
 
         if ($code >= 0xC0 && isset($chr[2])) {
             /** @noinspection UnnecessaryCastingInspection */
-            return $CHAR_CACHE[$cacheKey] = (int) ((($code - 0xC0) << 6) + $chr[2] - 0x80);
+            return $CHAR_CACHE[$cacheKey] = (int)((($code - 0xC0) << 6) + $chr[2] - 0x80);
         }
 
         return $CHAR_CACHE[$cacheKey] = $code;
@@ -4525,7 +4525,7 @@ 
     public static function pcre_utf8_support(): bool
     {
         /** @noinspection PhpUsageOfSilenceOperatorInspection */
-        return (bool) @\preg_match('//u', '');
+        return (bool)@\preg_match('//u', '');
     }
 
     /**
@@ -4547,10 +4547,10 @@ 
         }
 
         /** @noinspection PhpComposerExtensionStubsInspection */
-        if (\ctype_digit((string) $var1)) {
-            $start = (int) $var1;
+        if (\ctype_digit((string)$var1)) {
+            $start = (int)$var1;
         } /** @noinspection PhpComposerExtensionStubsInspection */ elseif (\ctype_xdigit($var1)) {
-            $start = (int) self::hex_to_int($var1);
+            $start = (int)self::hex_to_int($var1);
         } else {
             $start = self::ord($var1);
         }
@@ -4560,10 +4560,10 @@ 
         }
 
         /** @noinspection PhpComposerExtensionStubsInspection */
-        if (\ctype_digit((string) $var2)) {
-            $end = (int) $var2;
+        if (\ctype_digit((string)$var2)) {
+            $end = (int)$var2;
         } /** @noinspection PhpComposerExtensionStubsInspection */ elseif (\ctype_xdigit($var2)) {
-            $end = (int) self::hex_to_int($var2);
+            $end = (int)self::hex_to_int($var2);
         } else {
             $end = self::ord($var2);
         }
@@ -4573,8 +4573,8 @@ 
         }
 
         return \array_map(
-            static function (int $i): string {
-                return (string) self::chr($i);
+            static function(int $i): string {
+                return (string)self::chr($i);
             },
             \range($start, $end)
         );
@@ -4665,8 +4665,8 @@ 
             $delimiter = '/';
         }
 
-        return (string) \preg_replace(
-            $delimiter . $pattern . $delimiter . 'u' . $options,
+        return (string)\preg_replace(
+            $delimiter.$pattern.$delimiter.'u'.$options,
             $replacement,
             $str
         );
@@ -4709,9 +4709,9 @@ 
                     return '';
                 }
 
-                $strLength -= (int) $bomByteLength;
+                $strLength -= (int)$bomByteLength;
 
-                $str = (string) $strTmp;
+                $str = (string)$strTmp;
             }
         }
 
@@ -4735,7 +4735,7 @@ 
         if (\is_array($what) === true) {
             /** @noinspection ForeachSourceInspection */
             foreach ($what as $item) {
-                $str = (string) \preg_replace('/(' . \preg_quote($item, '/') . ')+/u', $item, $str);
+                $str = (string)\preg_replace('/('.\preg_quote($item, '/').')+/u', $item, $str);
             }
         }
 
@@ -4767,7 +4767,7 @@ 
      */
     public static function remove_html_breaks(string $str, string $replacement = ''): string
     {
-        return (string) \preg_replace("#/\r\n|\r|\n|<br.*/?>#isU", $replacement, $str);
+        return (string)\preg_replace("#/\r\n|\r|\n|<br.*/?>#isU", $replacement, $str);
     }
 
     /**
@@ -4798,7 +4798,7 @@ 
         $non_displayables[] = '/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]+/S'; // 00-08, 11, 12, 14-31, 127
 
         do {
-            $str = (string) \preg_replace($non_displayables, $replacement, $str, -1, $count);
+            $str = (string)\preg_replace($non_displayables, $replacement, $str, -1, $count);
         } while ($count !== 0);
 
         return $str;
@@ -4817,17 +4817,17 @@ 
     {
         if ($substring && \strpos($str, $substring) === 0) {
             if ($encoding === 'UTF-8') {
-                return (string) \mb_substr(
+                return (string)\mb_substr(
                     $str,
-                    (int) \mb_strlen($substring)
+                    (int)\mb_strlen($substring)
                 );
             }
 
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            return (string) self::substr(
+            return (string)self::substr(
                 $str,
-                (int) self::strlen($substring, $encoding),
+                (int)self::strlen($substring, $encoding),
                 null,
                 $encoding
             );
@@ -4849,19 +4849,19 @@ 
     {
         if ($substring && \substr($str, -\strlen($substring)) === $substring) {
             if ($encoding === 'UTF-8') {
-                return (string) \mb_substr(
+                return (string)\mb_substr(
                     $str,
                     0,
-                    (int) \mb_strlen($str) - (int) \mb_strlen($substring)
+                    (int)\mb_strlen($str) - (int)\mb_strlen($substring)
                 );
             }
 
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            return (string) self::substr(
+            return (string)self::substr(
                 $str,
                 0,
-                (int) self::strlen($str, $encoding) - (int) self::strlen($substring, $encoding),
+                (int)self::strlen($str, $encoding) - (int)self::strlen($substring, $encoding),
                 $encoding
             );
         }
@@ -4945,7 +4945,7 @@ 
             $save = \mb_substitute_character();
             \mb_substitute_character($replacementCharHelper);
             // the polyfill maybe return false, so cast to string
-            $str = (string) \mb_convert_encoding($str, 'UTF-8', 'UTF-8');
+            $str = (string)\mb_convert_encoding($str, 'UTF-8', 'UTF-8');
             \mb_substitute_character($save);
         }
 
@@ -4985,7 +4985,7 @@ 
 
         if (self::$SUPPORT['mbstring'] === true) {
             /** @noinspection PhpComposerExtensionStubsInspection */
-            return (string) \mb_ereg_replace($pattern, '', $str);
+            return (string)\mb_ereg_replace($pattern, '', $str);
         }
 
         return self::regex_replace($str, $pattern, '', '', '/');
@@ -5000,7 +5000,7 @@ 
     {
         echo '<pre>';
         foreach (self::$SUPPORT as $key => &$value) {
-            echo $key . ' - ' . \print_r($value, true) . "\n<br>";
+            echo $key.' - '.\print_r($value, true)."\n<br>";
         }
         unset($value);
         echo '</pre>';
@@ -5029,7 +5029,7 @@ 
             return $char;
         }
 
-        return '&#' . self::ord($char, $encoding) . ';';
+        return '&#'.self::ord($char, $encoding).';';
     }
 
     /**
@@ -5088,7 +5088,7 @@ 
         }
 
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return [];
@@ -5135,7 +5135,7 @@ 
                     ($str[$i] & "\xE0") === "\xC0"
                 ) {
                     if (($str[$i + 1] & "\xC0") === "\x80") {
-                        $ret[] = $str[$i] . $str[$i + 1];
+                        $ret[] = $str[$i].$str[$i + 1];
 
                         ++$i;
                     }
@@ -5149,7 +5149,7 @@ 
                         &&
                         ($str[$i + 2] & "\xC0") === "\x80"
                     ) {
-                        $ret[] = $str[$i] . $str[$i + 1] . $str[$i + 2];
+                        $ret[] = $str[$i].$str[$i + 1].$str[$i + 2];
 
                         $i += 2;
                     }
@@ -5165,7 +5165,7 @@ 
                         &&
                         ($str[$i + 3] & "\xC0") === "\x80"
                     ) {
-                        $ret[] = $str[$i] . $str[$i + 1] . $str[$i + 2] . $str[$i + 3];
+                        $ret[] = $str[$i].$str[$i + 1].$str[$i + 2].$str[$i + 3];
 
                         $i += 3;
                     }
@@ -5177,7 +5177,7 @@ 
             $ret = \array_chunk($ret, $length);
 
             return \array_map(
-                static function (array &$item): string {
+                static function(array &$item): string {
                     return \implode('', $item);
                 },
                 $ret
@@ -5226,18 +5226,18 @@ 
             $lang,
             $tryToKeepStringLength
         );
-        $str = (string) \preg_replace('/^[-_]+/', '', $str);
+        $str = (string)\preg_replace('/^[-_]+/', '', $str);
 
         $useMbFunction = $lang === null && $tryToKeepStringLength === false;
 
-        $str = (string) \preg_replace_callback(
+        $str = (string)\preg_replace_callback(
             '/[-_\s]+(.)?/u',
             /**
              * @param array $match
              *
              * @return string
              */
-            static function (array $match) use ($useMbFunction, $encoding, $lang, $tryToKeepStringLength): string {
+            static function(array $match) use ($useMbFunction, $encoding, $lang, $tryToKeepStringLength): string {
                 if (isset($match[1])) {
                     if ($useMbFunction === true) {
                         if ($encoding === 'UTF-8') {
@@ -5255,14 +5255,14 @@ 
             $str
         );
 
-        return (string) \preg_replace_callback(
+        return (string)\preg_replace_callback(
             '/[\d]+(.)?/u',
             /**
              * @param array $match
              *
              * @return string
              */
-            static function (array $match) use ($useMbFunction, $encoding, $cleanUtf8, $lang, $tryToKeepStringLength): string {
+            static function(array $match) use ($useMbFunction, $encoding, $cleanUtf8, $lang, $tryToKeepStringLength): string {
                 if ($useMbFunction === true) {
                     if ($encoding === 'UTF-8') {
                         return \mb_strtoupper($match[0]);
@@ -5434,7 +5434,7 @@ 
     ): string {
         if (self::$SUPPORT['mbstring'] === true) {
             /** @noinspection PhpComposerExtensionStubsInspection */
-            $str = (string) \mb_ereg_replace('\B(\p{Lu})', '-\1', \trim($str));
+            $str = (string)\mb_ereg_replace('\B(\p{Lu})', '-\1', \trim($str));
 
             $useMbFunction = $lang === null && $tryToKeepStringLength === false;
             if ($useMbFunction === true && $encoding === 'UTF-8') {
@@ -5444,10 +5444,10 @@ 
             }
 
             /** @noinspection PhpComposerExtensionStubsInspection */
-            return (string) \mb_ereg_replace('[-_\s]+', $delimiter, $str);
+            return (string)\mb_ereg_replace('[-_\s]+', $delimiter, $str);
         }
 
-        $str = (string) \preg_replace('/\B(\p{Lu})/u', '-\1', \trim($str));
+        $str = (string)\preg_replace('/\B(\p{Lu})/u', '-\1', \trim($str));
 
         $useMbFunction = $lang === null && $tryToKeepStringLength === false;
         if ($useMbFunction === true && $encoding === 'UTF-8') {
@@ -5456,7 +5456,7 @@ 
             $str = self::strtolower($str, $encoding, $cleanUtf8, $lang, $tryToKeepStringLength);
         }
 
-        return (string) \preg_replace('/[-_\s]+/u', $delimiter, $str);
+        return (string)\preg_replace('/[-_\s]+/u', $delimiter, $str);
     }
 
     /**
@@ -5471,7 +5471,7 @@ 
     public static function str_detect_encoding($str)
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         //
         // 1.) check binary strings (010001001...) like UTF-16 / UTF-32 / PDF / Images / ...
@@ -5573,7 +5573,7 @@ 
         foreach (self::$ENCODINGS as $encodingTmp) {
             // INFO: //IGNORE but still throw notice
             /** @noinspection PhpUsageOfSilenceOperatorInspection */
-            if ((string) @\iconv($encodingTmp, $encodingTmp . '//IGNORE', $str) === $str) {
+            if ((string)@\iconv($encodingTmp, $encodingTmp.'//IGNORE', $str) === $str) {
                 return $encodingTmp;
             }
         }
@@ -5638,7 +5638,7 @@ 
             return $str;
         }
 
-        return $substring . $str;
+        return $substring.$str;
     }
 
     /**
@@ -5858,27 +5858,27 @@ 
         string $encoding = 'UTF-8'
     ): string {
         if ($encoding === 'UTF-8') {
-            $len = (int) \mb_strlen($str);
+            $len = (int)\mb_strlen($str);
             if ($index > $len) {
                 return $str;
             }
 
             /** @noinspection UnnecessaryCastingInspection */
-            return (string) \mb_substr($str, 0, $index) .
-                   $substring .
-                   (string) \mb_substr($str, $index, $len);
+            return (string)\mb_substr($str, 0, $index).
+                   $substring.
+                   (string)\mb_substr($str, $index, $len);
         }
 
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-        $len = (int) self::strlen($str, $encoding);
+        $len = (int)self::strlen($str, $encoding);
         if ($index > $len) {
             return $str;
         }
 
-        return ((string) self::substr($str, 0, $index, $encoding)) .
-               $substring .
-               ((string) self::substr($str, $index, $len, $encoding));
+        return ((string)self::substr($str, 0, $index, $encoding)).
+               $substring.
+               ((string)self::substr($str, $index, $len, $encoding));
     }
 
     /**
@@ -5908,15 +5908,15 @@ 
      */
     public static function str_ireplace($search, $replace, $subject, &$count = null)
     {
-        $search = (array) $search;
+        $search = (array)$search;
 
         /** @noinspection AlterInForeachInspection */
         foreach ($search as &$s) {
-            $s = (string) $s;
+            $s = (string)$s;
             if ($s === '') {
                 $s = '/^(?<=.)$/';
             } else {
-                $s = '/' . \preg_quote($s, '/') . '/ui';
+                $s = '/'.\preg_quote($s, '/').'/ui';
             }
         }
 
@@ -5948,11 +5948,11 @@ 
         }
 
         if ($search === '') {
-            return $str . $replacement;
+            return $str.$replacement;
         }
 
         if (\stripos($str, $search) === 0) {
-            return $replacement . \substr($str, \strlen($search));
+            return $replacement.\substr($str, \strlen($search));
         }
 
         return $str;
@@ -5980,11 +5980,11 @@ 
         }
 
         if ($search === '') {
-            return $str . $replacement;
+            return $str.$replacement;
         }
 
         if (\stripos($str, $search, \strlen($str) - \strlen($search)) !== false) {
-            $str = \substr($str, 0, -\strlen($search)) . $replacement;
+            $str = \substr($str, 0, -\strlen($search)).$replacement;
         }
 
         return $str;
@@ -6057,15 +6057,15 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            return (string) \mb_substr(
+            return (string)\mb_substr(
                 $str,
-                $offset + (int) \mb_strlen($separator)
+                $offset + (int)\mb_strlen($separator)
             );
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
-            $offset + (int) self::strlen($separator, $encoding),
+            $offset + (int)self::strlen($separator, $encoding),
             null,
             $encoding
         );
@@ -6092,15 +6092,15 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            return (string) \mb_substr(
+            return (string)\mb_substr(
                 $str,
-                $offset + (int) self::strlen($separator)
+                $offset + (int)self::strlen($separator)
             );
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
-            $offset + (int) self::strlen($separator, $encoding),
+            $offset + (int)self::strlen($separator, $encoding),
             null,
             $encoding
         );
@@ -6127,10 +6127,10 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            return (string) \mb_substr($str, 0, $offset);
+            return (string)\mb_substr($str, 0, $offset);
         }
 
-        return (string) self::substr($str, 0, $offset, $encoding);
+        return (string)self::substr($str, 0, $offset, $encoding);
     }
 
     /**
@@ -6154,7 +6154,7 @@ 
                 return '';
             }
 
-            return (string) \mb_substr($str, 0, $offset);
+            return (string)\mb_substr($str, 0, $offset);
         }
 
         $offset = self::strripos($str, $separator, 0, $encoding);
@@ -6162,7 +6162,7 @@ 
             return '';
         }
 
-        return (string) self::substr($str, 0, $offset, $encoding);
+        return (string)self::substr($str, 0, $offset, $encoding);
     }
 
     /**
@@ -6250,12 +6250,12 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            return (string) \mb_substr($str, -$n);
+            return (string)\mb_substr($str, -$n);
         }
 
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-        return (string) self::substr($str, -$n, null, $encoding);
+        return (string)self::substr($str, -$n, null, $encoding);
     }
 
     /**
@@ -6279,21 +6279,21 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            if ((int) \mb_strlen($str) <= $length) {
+            if ((int)\mb_strlen($str) <= $length) {
                 return $str;
             }
 
             /** @noinspection UnnecessaryCastingInspection */
-            return (string) \mb_substr($str, 0, $length - (int) self::strlen($strAddOn)) . $strAddOn;
+            return (string)\mb_substr($str, 0, $length - (int)self::strlen($strAddOn)).$strAddOn;
         }
 
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-        if ((int) self::strlen($str, $encoding) <= $length) {
+        if ((int)self::strlen($str, $encoding) <= $length) {
             return $str;
         }
 
-        return ((string) self::substr($str, 0, $length - (int) self::strlen($strAddOn), $encoding)) . $strAddOn;
+        return ((string)self::substr($str, 0, $length - (int)self::strlen($strAddOn), $encoding)).$strAddOn;
     }
 
     /**
@@ -6318,12 +6318,12 @@ 
 
         if ($encoding === 'UTF-8') {
             /** @noinspection UnnecessaryCastingInspection */
-            if ((int) \mb_strlen($str) <= $length) {
+            if ((int)\mb_strlen($str) <= $length) {
                 return $str;
             }
 
             if (\mb_substr($str, $length - 1, 1) === ' ') {
-                return ((string) \mb_substr($str, 0, $length - 1)) . $strAddOn;
+                return ((string)\mb_substr($str, 0, $length - 1)).$strAddOn;
             }
 
             $str = \mb_substr($str, 0, $length);
@@ -6333,20 +6333,20 @@ 
             $new_str = \implode(' ', $array);
 
             if ($new_str === '') {
-                return ((string) \mb_substr($str, 0, $length - 1)) . $strAddOn;
+                return ((string)\mb_substr($str, 0, $length - 1)).$strAddOn;
             }
         } else {
-            if ((int) self::strlen($str, $encoding) <= $length) {
+            if ((int)self::strlen($str, $encoding) <= $length) {
                 return $str;
             }
 
             if (self::substr($str, $length - 1, 1, $encoding) === ' ') {
-                return ((string) self::substr($str, 0, $length - 1, $encoding)) . $strAddOn;
+                return ((string)self::substr($str, 0, $length - 1, $encoding)).$strAddOn;
             }
 
             $str = self::substr($str, 0, $length, $encoding);
             if ($str === false) {
-                return '' . $strAddOn;
+                return ''.$strAddOn;
             }
 
             $array = \explode(' ', $str);
@@ -6354,11 +6354,11 @@ 
             $new_str = \implode(' ', $array);
 
             if ($new_str === '') {
-                return ((string) self::substr($str, 0, $length - 1, $encoding)) . $strAddOn;
+                return ((string)self::substr($str, 0, $length - 1, $encoding)).$strAddOn;
             }
         }
 
-        return $new_str . $strAddOn;
+        return $new_str.$strAddOn;
     }
 
     /**
@@ -6376,7 +6376,7 @@ 
         $longestCommonPrefix = '';
 
         if ($encoding === 'UTF-8') {
-            $maxLength = (int) \min(
+            $maxLength = (int)\min(
                 \mb_strlen($str),
                 \mb_strlen($otherStr)
             );
@@ -6397,7 +6397,7 @@ 
         } else {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            $maxLength = (int) \min(
+            $maxLength = (int)\min(
                 self::strlen($str, $encoding),
                 self::strlen($otherStr, $encoding)
             );
@@ -6440,13 +6440,13 @@ 
         // http://en.wikipedia.org/wiki/Longest_common_substring_problem
 
         if ($encoding === 'UTF-8') {
-            $strLength = (int) \mb_strlen($str);
-            $otherLength = (int) \mb_strlen($otherStr);
+            $strLength = (int)\mb_strlen($str);
+            $otherLength = (int)\mb_strlen($otherStr);
         } else {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            $strLength = (int) self::strlen($str, $encoding);
-            $otherLength = (int) self::strlen($otherStr, $encoding);
+            $strLength = (int)self::strlen($str, $encoding);
+            $otherLength = (int)self::strlen($otherStr, $encoding);
         }
 
         // Return if either string is empty
@@ -6499,10 +6499,10 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            return (string) \mb_substr($str, $end - $len, $len);
+            return (string)\mb_substr($str, $end - $len, $len);
         }
 
-        return (string) self::substr($str, $end - $len, $len, $encoding);
+        return (string)self::substr($str, $end - $len, $len, $encoding);
     }
 
     /**
@@ -6521,7 +6521,7 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            $maxLength = (int) \min(
+            $maxLength = (int)\min(
                 \mb_strlen($str, $encoding),
                 \mb_strlen($otherStr, $encoding)
             );
@@ -6535,7 +6535,7 @@ 
                     &&
                     $char === \mb_substr($otherStr, -$i, 1)
                 ) {
-                    $longestCommonSuffix = $char . $longestCommonSuffix;
+                    $longestCommonSuffix = $char.$longestCommonSuffix;
                 } else {
                     break;
                 }
@@ -6543,7 +6543,7 @@ 
         } else {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            $maxLength = (int) \min(
+            $maxLength = (int)\min(
                 self::strlen($str, $encoding),
                 self::strlen($otherStr, $encoding)
             );
@@ -6557,7 +6557,7 @@ 
                     &&
                     $char === self::substr($otherStr, -$i, 1, $encoding)
                 ) {
-                    $longestCommonSuffix = $char . $longestCommonSuffix;
+                    $longestCommonSuffix = $char.$longestCommonSuffix;
                 } else {
                     break;
                 }
@@ -6577,7 +6577,7 @@ 
      */
     public static function str_matches_pattern(string $str, string $pattern): bool
     {
-        return (bool) \preg_match('/' . $pattern . '/u', $str);
+        return (bool)\preg_match('/'.$pattern.'/u', $str);
     }
 
     /**
@@ -6594,7 +6594,7 @@ 
     public static function str_offset_exists(string $str, int $offset, string $encoding = 'UTF-8'): bool
     {
         // init
-        $length = (int) self::strlen($str, $encoding);
+        $length = (int)self::strlen($str, $encoding);
 
         if ($offset >= 0) {
             return $length > $offset;
@@ -6620,7 +6620,7 @@ 
     public static function str_offset_get(string $str, int $index, string $encoding = 'UTF-8'): string
     {
         // init
-        $length = (int) self::strlen($str);
+        $length = (int)self::strlen($str);
 
         if (
             ($index >= 0 && $length <= $index)
@@ -6659,7 +6659,7 @@ 
             return $str;
         }
 
-        if ($pad_type !== (int) $pad_type) {
+        if ($pad_type !== (int)$pad_type) {
             if ($pad_type === 'left') {
                 $pad_type = \STR_PAD_LEFT;
             } elseif ($pad_type === 'right') {
@@ -6668,23 +6668,23 @@ 
                 $pad_type = \STR_PAD_BOTH;
             } else {
                 throw new \InvalidArgumentException(
-                    'Pad expects $padType to be "STR_PAD_*" or ' . "to be one of 'left', 'right' or 'both'"
+                    'Pad expects $padType to be "STR_PAD_*" or '."to be one of 'left', 'right' or 'both'"
                 );
             }
         }
 
         if ($encoding === 'UTF-8') {
-            $str_length = (int) \mb_strlen($str);
+            $str_length = (int)\mb_strlen($str);
 
             if ($pad_length >= $str_length) {
                 switch ($pad_type) {
                     case \STR_PAD_LEFT:
-                        $ps_length = (int) \mb_strlen($pad_string);
+                        $ps_length = (int)\mb_strlen($pad_string);
 
                         $diff = ($pad_length - $str_length);
 
-                        $pre = (string) \mb_substr(
-                            \str_repeat($pad_string, (int) \ceil($diff / $ps_length)),
+                        $pre = (string)\mb_substr(
+                            \str_repeat($pad_string, (int)\ceil($diff / $ps_length)),
                             0,
                             $diff
                         );
@@ -6695,16 +6695,16 @@ 
                     case \STR_PAD_BOTH:
                         $diff = ($pad_length - $str_length);
 
-                        $ps_length_left = (int) \floor($diff / 2);
+                        $ps_length_left = (int)\floor($diff / 2);
 
-                        $ps_length_right = (int) \ceil($diff / 2);
+                        $ps_length_right = (int)\ceil($diff / 2);
 
-                        $pre = (string) \mb_substr(
+                        $pre = (string)\mb_substr(
                             \str_repeat($pad_string, $ps_length_left),
                             0,
                             $ps_length_left
                         );
-                        $post = (string) \mb_substr(
+                        $post = (string)\mb_substr(
                             \str_repeat($pad_string, $ps_length_right),
                             0,
                             $ps_length_right
@@ -6714,19 +6714,19 @@ 
 
                     case \STR_PAD_RIGHT:
                     default:
-                        $ps_length = (int) \mb_strlen($pad_string);
+                        $ps_length = (int)\mb_strlen($pad_string);
 
                         $diff = ($pad_length - $str_length);
 
-                        $post = (string) \mb_substr(
-                            \str_repeat($pad_string, (int) \ceil($diff / $ps_length)),
+                        $post = (string)\mb_substr(
+                            \str_repeat($pad_string, (int)\ceil($diff / $ps_length)),
                             0,
                             $diff
                         );
                         $pre = '';
                 }
 
-                return $pre . $str . $post;
+                return $pre.$str.$post;
             }
 
             return $str;
@@ -6734,17 +6734,17 @@ 
 
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-        $str_length = (int) self::strlen($str, $encoding);
+        $str_length = (int)self::strlen($str, $encoding);
 
         if ($pad_length >= $str_length) {
             switch ($pad_type) {
                 case \STR_PAD_LEFT:
-                    $ps_length = (int) self::strlen($pad_string, $encoding);
+                    $ps_length = (int)self::strlen($pad_string, $encoding);
 
                     $diff = ($pad_length - $str_length);
 
-                    $pre = (string) self::substr(
-                        \str_repeat($pad_string, (int) \ceil($diff / $ps_length)),
+                    $pre = (string)self::substr(
+                        \str_repeat($pad_string, (int)\ceil($diff / $ps_length)),
                         0,
                         $diff,
                         $encoding
@@ -6756,17 +6756,17 @@ 
                 case \STR_PAD_BOTH:
                     $diff = ($pad_length - $str_length);
 
-                    $ps_length_left = (int) \floor($diff / 2);
+                    $ps_length_left = (int)\floor($diff / 2);
 
-                    $ps_length_right = (int) \ceil($diff / 2);
+                    $ps_length_right = (int)\ceil($diff / 2);
 
-                    $pre = (string) self::substr(
+                    $pre = (string)self::substr(
                         \str_repeat($pad_string, $ps_length_left),
                         0,
                         $ps_length_left,
                         $encoding
                     );
-                    $post = (string) self::substr(
+                    $post = (string)self::substr(
                         \str_repeat($pad_string, $ps_length_right),
                         0,
                         $ps_length_right,
@@ -6777,12 +6777,12 @@ 
 
                 case \STR_PAD_RIGHT:
                 default:
-                    $ps_length = (int) self::strlen($pad_string, $encoding);
+                    $ps_length = (int)self::strlen($pad_string, $encoding);
 
                     $diff = ($pad_length - $str_length);
 
-                    $post = (string) self::substr(
-                        \str_repeat($pad_string, (int) \ceil($diff / $ps_length)),
+                    $post = (string)self::substr(
+                        \str_repeat($pad_string, (int)\ceil($diff / $ps_length)),
                         0,
                         $diff,
                         $encoding
@@ -6790,7 +6790,7 @@ 
                     $pre = '';
             }
 
-            return $pre . $str . $post;
+            return $pre.$str.$post;
         }
 
         return $str;
@@ -6949,11 +6949,11 @@ 
         }
 
         if ($search === '') {
-            return $str . $replacement;
+            return $str.$replacement;
         }
 
         if (\strpos($str, $search) === 0) {
-            return $replacement . \substr($str, \strlen($search));
+            return $replacement.\substr($str, \strlen($search));
         }
 
         return $str;
@@ -6981,11 +6981,11 @@ 
         }
 
         if ($search === '') {
-            return $str . $replacement;
+            return $str.$replacement;
         }
 
         if (\strpos($str, $search, \strlen($str) - \strlen($search)) !== false) {
-            $str = \substr($str, 0, -\strlen($search)) . $replacement;
+            $str = \substr($str, 0, -\strlen($search)).$replacement;
         }
 
         return $str;
@@ -7014,7 +7014,7 @@ 
                 $subject,
                 $replace,
                 $pos,
-                (int) self::strlen($search)
+                (int)self::strlen($search)
             );
         }
 
@@ -7046,7 +7046,7 @@ 
                 $subject,
                 $replace,
                 $pos,
-                (int) self::strlen($search)
+                (int)self::strlen($search)
             );
         }
 
@@ -7066,7 +7066,7 @@ 
     public static function str_shuffle(string $str, string $encoding = 'UTF-8'): string
     {
         if ($encoding === 'UTF-8') {
-            $indexes = \range(0, (int) \mb_strlen($str) - 1);
+            $indexes = \range(0, (int)\mb_strlen($str) - 1);
             /** @noinspection NonSecureShuffleUsageInspection */
             \shuffle($indexes);
 
@@ -7082,7 +7082,7 @@ 
         } else {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            $indexes = \range(0, (int) self::strlen($str, $encoding) - 1);
+            $indexes = \range(0, (int)self::strlen($str, $encoding) - 1);
             /** @noinspection NonSecureShuffleUsageInspection */
             \shuffle($indexes);
 
@@ -7123,11 +7123,11 @@ 
     ) {
         if ($encoding === 'UTF-8') {
             if ($end === null) {
-                $length = (int) \mb_strlen($str);
+                $length = (int)\mb_strlen($str);
             } elseif ($end >= 0 && $end <= $start) {
                 return '';
             } elseif ($end < 0) {
-                $length = (int) \mb_strlen($str) + $end - $start;
+                $length = (int)\mb_strlen($str) + $end - $start;
             } else {
                 $length = $end - $start;
             }
@@ -7138,11 +7138,11 @@ 
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
         if ($end === null) {
-            $length = (int) self::strlen($str, $encoding);
+            $length = (int)self::strlen($str, $encoding);
         } elseif ($end >= 0 && $end <= $start) {
             return '';
         } elseif ($end < 0) {
-            $length = (int) self::strlen($str, $encoding) + $end - $start;
+            $length = (int)self::strlen($str, $encoding) + $end - $start;
         } else {
             $length = $end - $start;
         }
@@ -7174,35 +7174,35 @@ 
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
         }
 
-        $str = (string) \preg_replace_callback(
+        $str = (string)\preg_replace_callback(
             '/([\d|\p{Lu}])/u',
             /**
              * @param string[] $matches
              *
              * @return string
              */
-            static function (array $matches) use ($encoding): string {
+            static function(array $matches) use ($encoding): string {
                 $match = $matches[1];
-                $matchInt = (int) $match;
+                $matchInt = (int)$match;
 
-                if ((string) $matchInt === $match) {
-                    return '_' . $match . '_';
+                if ((string)$matchInt === $match) {
+                    return '_'.$match.'_';
                 }
 
                 if ($encoding === 'UTF-8') {
-                    return '_' . \mb_strtolower($match);
+                    return '_'.\mb_strtolower($match);
                 }
 
-                return '_' . self::strtolower($match, $encoding);
+                return '_'.self::strtolower($match, $encoding);
             },
             $str
         );
 
-        $str = (string) \preg_replace(
+        $str = (string)\preg_replace(
             [
-                '/\s+/u',        // convert spaces to "_"
-                '/^\s+|\s+$/u',  // trim leading & trailing spaces
-                '/_+/',         // remove double "_"
+                '/\s+/u', // convert spaces to "_"
+                '/^\s+|\s+$/u', // trim leading & trailing spaces
+                '/_+/', // remove double "_"
             ],
             [
                 '_',
@@ -7309,7 +7309,7 @@ 
             $limit = -1;
         }
 
-        $array = \preg_split('/' . \preg_quote($pattern, '/') . '/u', $str, $limit);
+        $array = \preg_split('/'.\preg_quote($pattern, '/').'/u', $str, $limit);
 
         if ($array === false) {
             return [];
@@ -7385,9 +7385,9 @@ 
                 return '';
             }
 
-            return (string) \mb_substr(
+            return (string)\mb_substr(
                 $str,
-                $offset + (int) \mb_strlen($separator)
+                $offset + (int)\mb_strlen($separator)
             );
         }
 
@@ -7396,9 +7396,9 @@ 
             return '';
         }
 
-        return (string) \mb_substr(
+        return (string)\mb_substr(
             $str,
-            $offset + (int) self::strlen($separator, $encoding),
+            $offset + (int)self::strlen($separator, $encoding),
             null,
             $encoding
         );
@@ -7425,9 +7425,9 @@ 
                 return '';
             }
 
-            return (string) \mb_substr(
+            return (string)\mb_substr(
                 $str,
-                $offset + (int) \mb_strlen($separator)
+                $offset + (int)\mb_strlen($separator)
             );
         }
 
@@ -7436,9 +7436,9 @@ 
             return '';
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
-            $offset + (int) self::strlen($separator, $encoding),
+            $offset + (int)self::strlen($separator, $encoding),
             null,
             $encoding
         );
@@ -7468,7 +7468,7 @@ 
                 return '';
             }
 
-            return (string) \mb_substr(
+            return (string)\mb_substr(
                 $str,
                 0,
                 $offset
@@ -7480,7 +7480,7 @@ 
             return '';
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
             0,
             $offset,
@@ -7509,7 +7509,7 @@ 
                 return '';
             }
 
-            return (string) \mb_substr(
+            return (string)\mb_substr(
                 $str,
                 0,
                 $offset
@@ -7523,7 +7523,7 @@ 
 
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
             0,
             $offset,
@@ -7631,7 +7631,7 @@ 
      */
     public static function str_surround(string $str, string $substring): string
     {
-        return $substring . $str . $substring;
+        return $substring.$str.$substring;
     }
 
     /**
@@ -7675,9 +7675,9 @@ 
 
         $useMbFunction = $lang === null && $tryToKeepStringLength === false;
 
-        return (string) \preg_replace_callback(
+        return (string)\preg_replace_callback(
             '/([\S]+)/u',
-            static function (array $match) use ($tryToKeepStringLength, $lang, $ignore, $useMbFunction, $encoding): string {
+            static function(array $match) use ($tryToKeepStringLength, $lang, $ignore, $useMbFunction, $encoding): string {
                 if ($ignore !== null && \in_array($match[0], $ignore, true)) {
                     return $match[0];
                 }
@@ -7763,16 +7763,16 @@ 
         }
 
         // the main substitutions
-        $str = (string) \preg_replace_callback(
+        $str = (string)\preg_replace_callback(
             '~\b (_*) (?:                                                              # 1. Leading underscore and
                         ( (?<=[ ][/\\\\]) [[:alpha:]]+ [-_[:alpha:]/\\\\]+ |              # 2. file path or 
-                          [-_[:alpha:]]+ [@.:] [-_[:alpha:]@.:/]+ ' . $apostropheRx . ' ) #    URL, domain, or email
+                          [-_[:alpha:]]+ [@.:] [-_[:alpha:]@.:/]+ ' . $apostropheRx.' ) #    URL, domain, or email
                         |
-                        ( (?i: ' . $smallWordsRx . ' ) ' . $apostropheRx . ' )            # 3. or small word (case-insensitive)
+                        ( (?i: ' . $smallWordsRx.' ) '.$apostropheRx.' )            # 3. or small word (case-insensitive)
                         |
-                        ( [[:alpha:]] [[:lower:]\'’()\[\]{}]* ' . $apostropheRx . ' )     # 4. or word w/o internal caps
+                        ( [[:alpha:]] [[:lower:]\'’()\[\]{}]* ' . $apostropheRx.' )     # 4. or word w/o internal caps
                         |
-                        ( [[:alpha:]] [[:alpha:]\'’()\[\]{}]* ' . $apostropheRx . ' )     # 5. or some other word
+                        ( [[:alpha:]] [[:alpha:]\'’()\[\]{}]* ' . $apostropheRx.' )     # 5. or some other word
                       ) (_*) \b                                                           # 6. With trailing underscore
                     ~ux',
             /**
@@ -7780,7 +7780,7 @@ 
              *
              * @return string
              */
-            static function (array $matches) use ($encoding): string {
+            static function(array $matches) use ($encoding): string {
                 // preserve leading underscore
                 $str = $matches[1];
                 if ($matches[2]) {
@@ -7805,26 +7805,26 @@ 
         );
 
         // Exceptions for small words: capitalize at start of title...
-        $str = (string) \preg_replace_callback(
+        $str = (string)\preg_replace_callback(
             '~(  \A [[:punct:]]*                # start of title...
                       |  [:.;?!][ ]+               # or of subsentence...
                       |  [ ][\'"“‘(\[][ ]* )       # or of inserted subphrase...
-                      ( ' . $smallWordsRx . ' ) \b # ...followed by small word
+                      ( ' . $smallWordsRx.' ) \b # ...followed by small word
                      ~uxi',
             /**
              * @param string[] $matches
              *
              * @return string
              */
-            static function (array $matches) use ($encoding): string {
-                return $matches[1] . static::str_upper_first($matches[2], $encoding);
+            static function(array $matches) use ($encoding): string {
+                return $matches[1].static::str_upper_first($matches[2], $encoding);
             },
             $str
         );
 
         // ...and end of title
-        $str = (string) \preg_replace_callback(
-            '~\b ( ' . $smallWordsRx . ' ) # small word...
+        $str = (string)\preg_replace_callback(
+            '~\b ( '.$smallWordsRx.' ) # small word...
                       (?= [[:punct:]]* \Z     # ...at the end of the title...
                       |   [\'"’”)\]] [ ] )    # ...or of an inserted subphrase?
                      ~uxi',
@@ -7833,7 +7833,7 @@ 
              *
              * @return string
              */
-            static function (array $matches) use ($encoding): string {
+            static function(array $matches) use ($encoding): string {
                 return static::str_upper_first($matches[1], $encoding);
             },
             $str
@@ -7841,10 +7841,10 @@ 
 
         // Exceptions for small words in hyphenated compound words.
         // e.g. "in-flight" -> In-Flight
-        $str = (string) \preg_replace_callback(
+        $str = (string)\preg_replace_callback(
             '~\b
                         (?<! -)                   # Negative lookbehind for a hyphen; we do not want to match man-in-the-middle but do want (in-flight)
-                        ( ' . $smallWordsRx . ' )
+                        ( ' . $smallWordsRx.' )
                         (?= -[[:alpha:]]+)        # lookahead for "-someword"
                        ~uxi',
             /**
@@ -7852,18 +7852,18 @@ 
              *
              * @return string
              */
-            static function (array $matches) use ($encoding): string {
+            static function(array $matches) use ($encoding): string {
                 return static::str_upper_first($matches[1], $encoding);
             },
             $str
         );
 
         // e.g. "Stand-in" -> "Stand-In" (Stand is already capped at this point)
-        $str = (string) \preg_replace_callback(
+        $str = (string)\preg_replace_callback(
             '~\b
                       (?<!…)                    # Negative lookbehind for a hyphen; we do not want to match man-in-the-middle but do want (stand-in)
                       ( [[:alpha:]]+- )         # $1 = first word and hyphen, should already be properly capped
-                      ( ' . $smallWordsRx . ' ) # ...followed by small word
+                      ( ' . $smallWordsRx.' ) # ...followed by small word
                       (?!	- )                   # Negative lookahead for another -
                      ~uxi',
             /**
@@ -7871,8 +7871,8 @@ 
              *
              * @return string
              */
-            static function (array $matches) use ($encoding): string {
-                return $matches[1] . static::str_upper_first($matches[2], $encoding);
+            static function(array $matches) use ($encoding): string {
+                return $matches[1].static::str_upper_first($matches[2], $encoding);
             },
             $str
         );
@@ -7975,7 +7975,7 @@ 
         );
 
         foreach ($tmpReturn as &$item) {
-            $item = (string) $item;
+            $item = (string)$item;
         }
 
         return $tmpReturn;
@@ -8020,39 +8020,39 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            if ($length >= (int) \mb_strlen($str)) {
+            if ($length >= (int)\mb_strlen($str)) {
                 return $str;
             }
 
             if ($substring !== '') {
-                $length -= (int) \mb_strlen($substring);
+                $length -= (int)\mb_strlen($substring);
 
                 /** @noinspection UnnecessaryCastingInspection */
-                return (string) \mb_substr($str, 0, $length) . $substring;
+                return (string)\mb_substr($str, 0, $length).$substring;
             }
 
             /** @noinspection UnnecessaryCastingInspection */
-            return (string) \mb_substr($str, 0, $length);
+            return (string)\mb_substr($str, 0, $length);
         }
 
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-        if ($length >= (int) self::strlen($str, $encoding)) {
+        if ($length >= (int)self::strlen($str, $encoding)) {
             return $str;
         }
 
         if ($substring !== '') {
-            $length -= (int) self::strlen($substring, $encoding);
+            $length -= (int)self::strlen($substring, $encoding);
         }
 
         return (
-            (string) self::substr(
+            (string)self::substr(
                 $str,
                 0,
                 $length,
                 $encoding
             )
-       ) . $substring;
+       ).$substring;
     }
 
     /**
@@ -8082,12 +8082,12 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            if ($length >= (int) \mb_strlen($str)) {
+            if ($length >= (int)\mb_strlen($str)) {
                 return $str;
             }
 
             // need to further trim the string so we can append the substring
-            $length -= (int) \mb_strlen($substring);
+            $length -= (int)\mb_strlen($substring);
             if ($length <= 0) {
                 return $substring;
             }
@@ -8109,18 +8109,18 @@ 
                     ||
                     ($strPosSpace !== false && $ignoreDoNotSplitWordsForOneWord === false)
                 ) {
-                    $truncated = (string) \mb_substr($truncated, 0, (int) $lastPos);
+                    $truncated = (string)\mb_substr($truncated, 0, (int)$lastPos);
                 }
             }
         } else {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            if ($length >= (int) self::strlen($str, $encoding)) {
+            if ($length >= (int)self::strlen($str, $encoding)) {
                 return $str;
             }
 
             // need to further trim the string so we can append the substring
-            $length -= (int) self::strlen($substring, $encoding);
+            $length -= (int)self::strlen($substring, $encoding);
             if ($length <= 0) {
                 return $substring;
             }
@@ -8142,12 +8142,12 @@ 
                     ||
                     ($strPosSpace !== false && $ignoreDoNotSplitWordsForOneWord === false)
                 ) {
-                    $truncated = (string) self::substr($truncated, 0, (int) $lastPos, $encoding);
+                    $truncated = (string)self::substr($truncated, 0, (int)$lastPos, $encoding);
                 }
             }
         }
 
-        return $truncated . $substring;
+        return $truncated.$substring;
     }
 
     /**
@@ -8237,13 +8237,13 @@ 
             }
         } elseif ($format === 2) {
             $numberOfWords = [];
-            $offset = (int) self::strlen($strParts[0]);
+            $offset = (int)self::strlen($strParts[0]);
             for ($i = 1; $i < $len; $i += 2) {
                 $numberOfWords[$offset] = $strParts[$i];
-                $offset += (int) self::strlen($strParts[$i]) + (int) self::strlen($strParts[$i + 1]);
+                $offset += (int)self::strlen($strParts[$i]) + (int)self::strlen($strParts[$i + 1]);
             }
         } else {
-            $numberOfWords = (int) (($len - 1) / 2);
+            $numberOfWords = (int)(($len - 1) / 2);
         }
 
         return $numberOfWords;
@@ -8307,7 +8307,7 @@ 
      */
     public static function strcmp(string $str1, string $str2): int
     {
-        return $str1 . '' === $str2 . '' ? 0 : \strcmp(
+        return $str1.'' === $str2.'' ? 0 : \strcmp(
             \Normalizer::normalize($str1, \Normalizer::NFD),
             \Normalizer::normalize($str2, \Normalizer::NFD)
         );
@@ -8336,21 +8336,21 @@ 
         }
 
         if ($charList === '') {
-            return (int) self::strlen($str, $encoding);
+            return (int)self::strlen($str, $encoding);
         }
 
         if ($offset !== null || $length !== null) {
             if ($encoding === 'UTF-8') {
                 if ($length === null) {
                     /** @noinspection UnnecessaryCastingInspection */
-                    $strTmp = \mb_substr($str, (int) $offset);
+                    $strTmp = \mb_substr($str, (int)$offset);
                 } else {
                     /** @noinspection UnnecessaryCastingInspection */
-                    $strTmp = \mb_substr($str, (int) $offset, $length);
+                    $strTmp = \mb_substr($str, (int)$offset, $length);
                 }
             } else {
                 /** @noinspection UnnecessaryCastingInspection */
-                $strTmp = self::substr($str, (int) $offset, $length, $encoding);
+                $strTmp = self::substr($str, (int)$offset, $length, $encoding);
             }
 
             if ($strTmp === false) {
@@ -8365,7 +8365,7 @@ 
         }
 
         $matches = [];
-        if (\preg_match('/^(.*?)' . self::rxClass($charList) . '/us', $str, $matches)) {
+        if (\preg_match('/^(.*?)'.self::rxClass($charList).'/us', $str, $matches)) {
             $return = self::strlen($matches[1], $encoding);
             if ($return === false) {
                 return 0;
@@ -8374,7 +8374,7 @@ 
             return $return;
         }
 
-        return (int) self::strlen($str, $encoding);
+        return (int)self::strlen($str, $encoding);
     }
 
     /**
@@ -8496,7 +8496,7 @@ 
             return '';
         }
 
-        return (string) \preg_replace('/[[:space:]]+/u', '', $str);
+        return (string)\preg_replace('/[[:space:]]+/u', '', $str);
     }
 
     /**
@@ -8561,7 +8561,7 @@ 
         // fallback for ascii only
         //
 
-        if (self::is_ascii($haystack . $needle)) {
+        if (self::is_ascii($haystack.$needle)) {
             return \stripos($haystack, $needle, $offset);
         }
 
@@ -8628,7 +8628,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::stristr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::stristr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         if (
@@ -8642,11 +8642,11 @@ 
             }
         }
 
-        if (self::is_ascii($needle . $haystack)) {
+        if (self::is_ascii($needle.$haystack)) {
             return \stristr($haystack, $needle, $before_needle);
         }
 
-        \preg_match('/^(.*?)' . \preg_quote($needle, '/') . '/usi', $haystack, $match);
+        \preg_match('/^(.*?)'.\preg_quote($needle, '/').'/usi', $haystack, $match);
 
         if (!isset($match[1])) {
             return false;
@@ -8656,7 +8656,7 @@ 
             return $match[1];
         }
 
-        return self::substr($haystack, (int) self::strlen($match[1], $encoding), null, $encoding);
+        return self::substr($haystack, (int)self::strlen($match[1], $encoding), null, $encoding);
     }
 
     /**
@@ -8723,7 +8723,7 @@ 
             &&
             self::$SUPPORT['iconv'] === false
         ) {
-            \trigger_error('UTF8::strlen() without mbstring / iconv cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::strlen() without mbstring / iconv cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         //
@@ -8834,7 +8834,7 @@ 
      */
     public static function strnatcmp(string $str1, string $str2): int
     {
-        return $str1 . '' === $str2 . '' ? 0 : \strnatcmp((string) self::strtonatfold($str1), (string) self::strtonatfold($str2));
+        return $str1.'' === $str2.'' ? 0 : \strnatcmp((string)self::strtonatfold($str1), (string)self::strtonatfold($str2));
     }
 
     /**
@@ -8891,11 +8891,11 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            $str1 = (string) \mb_substr($str1, 0, $len);
-            $str2 = (string) \mb_substr($str2, 0, $len);
+            $str1 = (string)\mb_substr($str1, 0, $len);
+            $str2 = (string)\mb_substr($str2, 0, $len);
         } else {
-            $str1 = (string) self::substr($str1, 0, $len, $encoding);
-            $str2 = (string) self::substr($str2, 0, $len, $encoding);
+            $str1 = (string)self::substr($str1, 0, $len, $encoding);
+            $str2 = (string)self::substr($str2, 0, $len, $encoding);
         }
 
         return self::strcmp($str1, $str2);
@@ -8917,8 +8917,8 @@ 
             return false;
         }
 
-        if (\preg_match('/' . self::rxClass($char_list) . '/us', $haystack, $m)) {
-            return \substr($haystack, (int) \strpos($haystack, $m[0]));
+        if (\preg_match('/'.self::rxClass($char_list).'/us', $haystack, $m)) {
+            return \substr($haystack, (int)\strpos($haystack, $m[0]));
         }
 
         return false;
@@ -8951,10 +8951,10 @@ 
         }
 
         // iconv and mbstring do not support integer $needle
-        if ((int) $needle === $needle) {
-            $needle = (string) self::chr($needle);
+        if ((int)$needle === $needle) {
+            $needle = (string)self::chr($needle);
         }
-        $needle = (string) $needle;
+        $needle = (string)$needle;
 
         if ($needle === '') {
             return false;
@@ -9001,7 +9001,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::strpos() without mbstring / iconv cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::strpos() without mbstring / iconv cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         //
@@ -9042,7 +9042,7 @@ 
         // fallback for ascii only
         //
 
-        if (self::is_ascii($haystack . $needle)) {
+        if (self::is_ascii($haystack.$needle)) {
             return \strpos($haystack, $needle, $offset);
         }
 
@@ -9054,7 +9054,7 @@ 
         if ($haystackTmp === false) {
             $haystackTmp = '';
         }
-        $haystack = (string) $haystackTmp;
+        $haystack = (string)$haystackTmp;
 
         if ($offset < 0) {
             $offset = 0;
@@ -9066,7 +9066,7 @@ 
         }
 
         if ($pos) {
-            return $offset + (int) self::strlen(\substr($haystack, 0, $pos), $encoding);
+            return $offset + (int)self::strlen(\substr($haystack, 0, $pos), $encoding);
         }
 
         return $offset + 0;
@@ -9177,7 +9177,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::strrchr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::strrchr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         //
@@ -9189,7 +9189,7 @@ 
             if ($needleTmp === false) {
                 return false;
             }
-            $needle = (string) $needleTmp;
+            $needle = (string)$needleTmp;
 
             $pos = \iconv_strrpos($haystack, $needle, $encoding);
             if ($pos === false) {
@@ -9211,7 +9211,7 @@ 
         if ($needleTmp === false) {
             return false;
         }
-        $needle = (string) $needleTmp;
+        $needle = (string)$needleTmp;
 
         $pos = self::strrpos($haystack, $needle, 0, $encoding);
         if ($pos === false) {
@@ -9247,7 +9247,7 @@ 
         if ($encoding === 'UTF-8') {
             if (self::$SUPPORT['intl'] === true) {
                 // try "grapheme" first: https://stackoverflow.com/questions/17496493/strrev-dosent-support-utf-8
-                $i = (int) \grapheme_strlen($str);
+                $i = (int)\grapheme_strlen($str);
                 while ($i--) {
                     $reversedTmp = \grapheme_substr($str, $i, 1);
                     if ($reversedTmp !== false) {
@@ -9255,7 +9255,7 @@ 
                     }
                 }
             } else {
-                $i = (int) \mb_strlen($str);
+                $i = (int)\mb_strlen($str);
                 while ($i--) {
                     $reversedTmp = \mb_substr($str, $i, 1);
                     if ($reversedTmp !== false) {
@@ -9266,7 +9266,7 @@ 
         } else {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            $i = (int) self::strlen($str, $encoding);
+            $i = (int)self::strlen($str, $encoding);
             while ($i--) {
                 $reversedTmp = self::substr($str, $i, 1, $encoding);
                 if ($reversedTmp !== false) {
@@ -9340,7 +9340,7 @@ 
         if ($needleTmp === false) {
             return false;
         }
-        $needle = (string) $needleTmp;
+        $needle = (string)$needleTmp;
 
         $pos = self::strripos($haystack, $needle, 0, $encoding);
         if ($pos === false) {
@@ -9379,10 +9379,10 @@ 
         }
 
         // iconv and mbstring do not support integer $needle
-        if ((int) $needle === $needle && $needle >= 0) {
-            $needle = (string) self::chr($needle);
+        if ((int)$needle === $needle && $needle >= 0) {
+            $needle = (string)self::chr($needle);
         }
-        $needle = (string) $needle;
+        $needle = (string)$needle;
 
         if ($needle === '') {
             return false;
@@ -9427,7 +9427,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::strripos() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::strripos() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         //
@@ -9451,7 +9451,7 @@ 
         // fallback for ascii only
         //
 
-        if (self::is_ascii($haystack . $needle)) {
+        if (self::is_ascii($haystack.$needle)) {
             return \strripos($haystack, $needle, $offset);
         }
 
@@ -9527,10 +9527,10 @@ 
         }
 
         // iconv and mbstring do not support integer $needle
-        if ((int) $needle === $needle && $needle >= 0) {
-            $needle = (string) self::chr($needle);
+        if ((int)$needle === $needle && $needle >= 0) {
+            $needle = (string)self::chr($needle);
         }
-        $needle = (string) $needle;
+        $needle = (string)$needle;
 
         if ($needle === '') {
             return false;
@@ -9575,7 +9575,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::strrpos() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::strrpos() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         //
@@ -9599,7 +9599,7 @@ 
         // fallback for ascii only
         //
 
-        if (self::is_ascii($haystack . $needle)) {
+        if (self::is_ascii($haystack.$needle)) {
             return \strrpos($haystack, $needle, $offset);
         }
 
@@ -9619,7 +9619,7 @@ 
             if ($haystackTmp === false) {
                 $haystackTmp = '';
             }
-            $haystack = (string) $haystackTmp;
+            $haystack = (string)$haystackTmp;
         }
 
         $pos = \strrpos($haystack, $needle);
@@ -9632,7 +9632,7 @@ 
             return false;
         }
 
-        return $offset + (int) self::strlen($strTmp);
+        return $offset + (int)self::strlen($strTmp);
     }
 
     /**
@@ -9692,12 +9692,12 @@ 
         if ($offset || $length !== null) {
             if ($encoding === 'UTF-8') {
                 if ($length === null) {
-                    $str = (string) \mb_substr($str, $offset);
+                    $str = (string)\mb_substr($str, $offset);
                 } else {
-                    $str = (string) \mb_substr($str, $offset, $length);
+                    $str = (string)\mb_substr($str, $offset, $length);
                 }
             } else {
-                $str = (string) self::substr($str, $offset, $length, $encoding);
+                $str = (string)self::substr($str, $offset, $length, $encoding);
             }
         }
 
@@ -9707,7 +9707,7 @@ 
 
         $matches = [];
 
-        return \preg_match('/^' . self::rxClass($mask) . '+/u', $str, $matches) ? (int) self::strlen($matches[0], $encoding) : 0;
+        return \preg_match('/^'.self::rxClass($mask).'+/u', $str, $matches) ? (int)self::strlen($matches[0], $encoding) : 0;
     }
 
     /**
@@ -9776,7 +9776,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::strstr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::strstr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         //
@@ -9798,7 +9798,7 @@ 
         // fallback for ascii only
         //
 
-        if (self::is_ascii($haystack . $needle)) {
+        if (self::is_ascii($haystack.$needle)) {
             return \strstr($haystack, $needle, $before_needle);
         }
 
@@ -9806,7 +9806,7 @@ 
         // fallback via vanilla php
         //
 
-        \preg_match('/^(.*?)' . \preg_quote($needle, '/') . '/us', $haystack, $match);
+        \preg_match('/^(.*?)'.\preg_quote($needle, '/').'/us', $haystack, $match);
 
         if (!isset($match[1])) {
             return false;
@@ -9816,7 +9816,7 @@ 
             return $match[1];
         }
 
-        return self::substr($haystack, (int) self::strlen($match[1]));
+        return self::substr($haystack, (int)self::strlen($match[1]));
     }
 
     /**
@@ -9930,7 +9930,7 @@ 
         bool $tryToKeepStringLength = false
     ): string {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return '';
@@ -9959,19 +9959,19 @@ 
                     self::$INTL_TRANSLITERATOR_LIST = self::getData('transliterator_list');
                 }
 
-                $langCode = $lang . '-Lower';
+                $langCode = $lang.'-Lower';
                 if (!\in_array($langCode, self::$INTL_TRANSLITERATOR_LIST, true)) {
-                    \trigger_error('UTF8::strtolower() cannot handle special language: ' . $lang, \E_USER_WARNING);
+                    \trigger_error('UTF8::strtolower() cannot handle special language: '.$lang, \E_USER_WARNING);
 
                     $langCode = 'Any-Lower';
                 }
 
                 /** @noinspection PhpComposerExtensionStubsInspection */
                 /** @noinspection UnnecessaryCastingInspection */
-                return (string) \transliterator_transliterate($langCode, $str);
+                return (string)\transliterator_transliterate($langCode, $str);
             }
 
-            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang" parameter: ' . $lang, \E_USER_WARNING);
+            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang" parameter: '.$lang, \E_USER_WARNING);
         }
 
         // always fallback via symfony polyfill
@@ -10000,7 +10000,7 @@ 
         bool $tryToKeepStringLength = false
     ): string {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return '';
@@ -10029,19 +10029,19 @@ 
                     self::$INTL_TRANSLITERATOR_LIST = self::getData('transliterator_list');
                 }
 
-                $langCode = $lang . '-Upper';
+                $langCode = $lang.'-Upper';
                 if (!\in_array($langCode, self::$INTL_TRANSLITERATOR_LIST, true)) {
-                    \trigger_error('UTF8::strtoupper() without intl for special language: ' . $lang, \E_USER_WARNING);
+                    \trigger_error('UTF8::strtoupper() without intl for special language: '.$lang, \E_USER_WARNING);
 
                     $langCode = 'Any-Upper';
                 }
 
                 /** @noinspection PhpComposerExtensionStubsInspection */
                 /** @noinspection UnnecessaryCastingInspection */
-                return (string) \transliterator_transliterate($langCode, $str);
+                return (string)\transliterator_transliterate($langCode, $str);
             }
 
-            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang"-parameter: ' . $lang, \E_USER_WARNING);
+            \trigger_error('UTF8::strtolower() without intl cannot handle the "lang"-parameter: '.$lang, \E_USER_WARNING);
         }
 
         // always fallback via symfony polyfill
@@ -10085,7 +10085,7 @@ 
 
             $from = \array_combine($from, $to);
             if ($from === false) {
-                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) . ')');
+                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).')');
             }
         }
 
@@ -10142,9 +10142,9 @@ 
         }
 
         $wide = 0;
-        $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);
+        $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);
 
-        return ($wide << 1) + (int) self::strlen($str, 'UTF-8');
+        return ($wide << 1) + (int)self::strlen($str, 'UTF-8');
     }
 
     /**
@@ -10244,9 +10244,9 @@ 
         }
 
         if ($length === null) {
-            $length = (int) $str_length;
+            $length = (int)$str_length;
         } else {
-            $length = (int) $length;
+            $length = (int)$length;
         }
 
         if (
@@ -10254,7 +10254,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::substr() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::substr() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         //
@@ -10342,16 +10342,16 @@ 
         ) {
             if ($encoding === 'UTF-8') {
                 if ($length === null) {
-                    $str1 = (string) \mb_substr($str1, $offset);
+                    $str1 = (string)\mb_substr($str1, $offset);
                 } else {
-                    $str1 = (string) \mb_substr($str1, $offset, $length);
+                    $str1 = (string)\mb_substr($str1, $offset, $length);
                 }
-                $str2 = (string) \mb_substr($str2, 0, (int) self::strlen($str1));
+                $str2 = (string)\mb_substr($str2, 0, (int)self::strlen($str1));
             } else {
                 $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-                $str1 = (string) self::substr($str1, $offset, $length, $encoding);
-                $str2 = (string) self::substr($str2, 0, (int) self::strlen($str1), $encoding);
+                $str1 = (string)self::substr($str1, $offset, $length, $encoding);
+                $str2 = (string)self::substr($str2, 0, (int)self::strlen($str1), $encoding);
             }
         }
 
@@ -10413,13 +10413,13 @@ 
                 if ($lengthTmp === false) {
                     return false;
                 }
-                $length = (int) $lengthTmp;
+                $length = (int)$lengthTmp;
             }
 
             if ($encoding === 'UTF-8') {
-                $haystack = (string) \mb_substr($haystack, $offset, $length);
+                $haystack = (string)\mb_substr($haystack, $offset, $length);
             } else {
-                $haystack = (string) \mb_substr($haystack, $offset, $length, $encoding);
+                $haystack = (string)\mb_substr($haystack, $offset, $length, $encoding);
             }
         }
 
@@ -10428,7 +10428,7 @@ 
             &&
             self::$SUPPORT['mbstring'] === false
         ) {
-            \trigger_error('UTF8::substr_count() without mbstring cannot handle "' . $encoding . '" encoding', \E_USER_WARNING);
+            \trigger_error('UTF8::substr_count() without mbstring cannot handle "'.$encoding.'" encoding', \E_USER_WARNING);
         }
 
         if (self::$SUPPORT['mbstring'] === true) {
@@ -10439,7 +10439,7 @@ 
             return \mb_substr_count($haystack, $needle, $encoding);
         }
 
-        \preg_match_all('/' . \preg_quote($needle, '/') . '/us', $haystack, $matches, \PREG_SET_ORDER);
+        \preg_match_all('/'.\preg_quote($needle, '/').'/us', $haystack, $matches, \PREG_SET_ORDER);
 
         return \count($matches);
     }
@@ -10486,7 +10486,7 @@ 
                 if ($lengthTmp === false) {
                     return false;
                 }
-                $length = (int) $lengthTmp;
+                $length = (int)$lengthTmp;
             }
 
             if (
@@ -10507,7 +10507,7 @@ 
             if ($haystackTmp === false) {
                 $haystackTmp = '';
             }
-            $haystack = (string) $haystackTmp;
+            $haystack = (string)$haystackTmp;
         }
 
         if (self::$SUPPORT['mbstring_func_overload'] === true) {
@@ -10546,10 +10546,10 @@ 
 
         if ($encoding === 'UTF-8') {
             if ($caseSensitive) {
-                return (int) \mb_substr_count($str, $substring);
+                return (int)\mb_substr_count($str, $substring);
             }
 
-            return (int) \mb_substr_count(
+            return (int)\mb_substr_count(
                 \mb_strtoupper($str),
                 \mb_strtoupper($substring)
 
@@ -10559,10 +10559,10 @@ 
         $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
         if ($caseSensitive) {
-            return (int) \mb_substr_count($str, $substring, $encoding);
+            return (int)\mb_substr_count($str, $substring, $encoding);
         }
 
-        return (int) \mb_substr_count(
+        return (int)\mb_substr_count(
             self::strtocasefold($str, true, false, $encoding, null, false),
             self::strtocasefold($substring, true, false, $encoding, null, false),
             $encoding
@@ -10588,7 +10588,7 @@ 
         }
 
         if (self::str_istarts_with($haystack, $needle) === true) {
-            $haystack = (string) \mb_substr($haystack, (int) self::strlen($needle));
+            $haystack = (string)\mb_substr($haystack, (int)self::strlen($needle));
         }
 
         return $haystack;
@@ -10645,7 +10645,7 @@ 
         }
 
         if (self::str_iends_with($haystack, $needle) === true) {
-            $haystack = (string) \mb_substr($haystack, 0, (int) self::strlen($haystack) - (int) self::strlen($needle));
+            $haystack = (string)\mb_substr($haystack, 0, (int)self::strlen($haystack) - (int)self::strlen($needle));
         }
 
         return $haystack;
@@ -10670,7 +10670,7 @@ 
         }
 
         if (self::str_starts_with($haystack, $needle) === true) {
-            $haystack = (string) \mb_substr($haystack, (int) self::strlen($needle));
+            $haystack = (string)\mb_substr($haystack, (int)self::strlen($needle));
         }
 
         return $haystack;
@@ -10722,7 +10722,7 @@ 
             if (\is_array($offset) === true) {
                 $offset = \array_slice($offset, 0, $num);
                 foreach ($offset as &$valueTmp) {
-                    $valueTmp = (int) $valueTmp === $valueTmp ? $valueTmp : 0;
+                    $valueTmp = (int)$valueTmp === $valueTmp ? $valueTmp : 0;
                 }
                 unset($valueTmp);
             } else {
@@ -10735,7 +10735,7 @@ 
             } elseif (\is_array($length) === true) {
                 $length = \array_slice($length, 0, $num);
                 foreach ($length as &$valueTmpV2) {
-                    $valueTmpV2 = (int) $valueTmpV2 === $valueTmpV2 ? $valueTmpV2 : $num;
+                    $valueTmpV2 = (int)$valueTmpV2 === $valueTmpV2 ? $valueTmpV2 : $num;
                 }
                 unset($valueTmpV2);
             } else {
@@ -10755,8 +10755,8 @@ 
         }
 
         // init
-        $str = (string) $str;
-        $replacement = (string) $replacement;
+        $str = (string)$str;
+        $replacement = (string)$replacement;
 
         if (\is_array($length) === true) {
             throw new \InvalidArgumentException('Parameter "$length" can only be an array, if "$str" is also an array.');
@@ -10771,16 +10771,16 @@ 
         }
 
         if (self::$SUPPORT['mbstring'] === true) {
-            $string_length = (int) self::strlen($str, $encoding);
+            $string_length = (int)self::strlen($str, $encoding);
 
             if ($offset < 0) {
-                $offset = (int) \max(0, $string_length + $offset);
+                $offset = (int)\max(0, $string_length + $offset);
             } elseif ($offset > $string_length) {
                 $offset = $string_length;
             }
 
             if ($length !== null && $length < 0) {
-                $length = (int) \max(0, $string_length - $offset + $length);
+                $length = (int)\max(0, $string_length - $offset + $length);
             } elseif ($length === null || $length > $string_length) {
                 $length = $string_length;
             }
@@ -10791,9 +10791,9 @@ 
             }
 
             /** @noinspection AdditionOperationOnArraysInspection */
-            return ((string) \mb_substr($str, 0, $offset, $encoding)) .
-                   $replacement .
-                   ((string) \mb_substr($str, $offset + $length, $string_length - $offset - $length, $encoding));
+            return ((string)\mb_substr($str, 0, $offset, $encoding)).
+                   $replacement.
+                   ((string)\mb_substr($str, $offset + $length, $string_length - $offset - $length, $encoding));
         }
 
         //
@@ -10802,8 +10802,7 @@ 
 
         if (self::is_ascii($str)) {
             return ($length === null) ?
-                \substr_replace($str, $replacement, $offset) :
-                \substr_replace($str, $replacement, $offset, $length);
+                \substr_replace($str, $replacement, $offset) : \substr_replace($str, $replacement, $offset, $length);
         }
 
         //
@@ -10819,7 +10818,7 @@ 
                 // e.g.: non mbstring support + invalid chars
                 return '';
             }
-            $length = (int) $lengthTmp;
+            $length = (int)$lengthTmp;
         }
 
         \array_splice($smatches[0], $offset, $length, $rmatches[0]);
@@ -10854,14 +10853,14 @@ 
             &&
             \substr($haystack, -\strlen($needle)) === $needle
         ) {
-            return (string) \mb_substr($haystack, 0, (int) \mb_strlen($haystack) - (int) \mb_strlen($needle));
+            return (string)\mb_substr($haystack, 0, (int)\mb_strlen($haystack) - (int)\mb_strlen($needle));
         }
 
         if (\substr($haystack, -\strlen($needle)) === $needle) {
-            return (string) self::substr(
+            return (string)self::substr(
                 $haystack,
                 0,
-                (int) self::strlen($haystack, $encoding) - (int) self::strlen($needle, $encoding),
+                (int)self::strlen($haystack, $encoding) - (int)self::strlen($needle, $encoding),
                 $encoding
             );
         }
@@ -10891,10 +10890,10 @@ 
         }
 
         if ($encoding === 'UTF-8') {
-            return (string) (\mb_strtolower($str) ^ \mb_strtoupper($str) ^ $str);
+            return (string)(\mb_strtolower($str) ^ \mb_strtoupper($str) ^ $str);
         }
 
-        return (string) (self::strtolower($str, $encoding) ^ self::strtoupper($str, $encoding) ^ $str);
+        return (string)(self::strtolower($str, $encoding) ^ self::strtoupper($str, $encoding) ^ $str);
     }
 
     /**
@@ -11090,7 +11089,7 @@ 
             // INFO: https://unicode.org/cldr/utility/character.jsp?a=%E2%84%8C
             /** @noinspection PhpComposerExtensionStubsInspection */
             /** @noinspection UnnecessaryCastingInspection */
-            $str = (string) \transliterator_transliterate('NFKC; [:Nonspacing Mark:] Remove; NFKC; Any-Latin; Latin-ASCII;', $str);
+            $str = (string)\transliterator_transliterate('NFKC; [:Nonspacing Mark:] Remove; NFKC; Any-Latin; Latin-ASCII;', $str);
 
             // check again, if we only have ASCII, now ...
             if (self::is_ascii($str) === true) {
@@ -11213,7 +11212,7 @@ 
     public static function to_boolean($str): bool
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return false;
@@ -11241,10 +11240,10 @@ 
         }
 
         if (\is_numeric($str)) {
-            return ((float) $str + 0) > 0;
+            return ((float)$str + 0) > 0;
         }
 
-        return (bool) \trim($str);
+        return (bool)\trim($str);
     }
 
     /**
@@ -11265,11 +11264,11 @@ 
 
         $fallback_char_escaped = \preg_quote($fallback_char, '/');
 
-        $string = (string) \preg_replace(
+        $string = (string)\preg_replace(
             [
-                '/[^' . $fallback_char_escaped . '\.\-a-zA-Z0-9\s]/', // 1) remove un-needed chars
-                '/[\s]+/u',                                           // 2) convert spaces to $fallback_char
-                '/[' . $fallback_char_escaped . ']+/u',               // 3) remove double $fallback_char's
+                '/[^'.$fallback_char_escaped.'\.\-a-zA-Z0-9\s]/', // 1) remove un-needed chars
+                '/[\s]+/u', // 2) convert spaces to $fallback_char
+                '/['.$fallback_char_escaped.']+/u', // 3) remove double $fallback_char's
             ],
             [
                 '',
@@ -11300,7 +11299,7 @@ 
             return $str;
         }
 
-        $str = (string) $str;
+        $str = (string)$str;
         if ($str === '') {
             return '';
         }
@@ -11347,7 +11346,7 @@ 
             return $str;
         }
 
-        $str = (string) $str;
+        $str = (string)$str;
         if ($str === '') {
             return $str;
         }
@@ -11365,7 +11364,7 @@ 
                     $c2 = $i + 1 >= $max ? "\x00" : $str[$i + 1];
 
                     if ($c2 >= "\x80" && $c2 <= "\xBF") { // yeah, almost sure it's UTF8 already
-                        $buf .= $c1 . $c2;
+                        $buf .= $c1.$c2;
                         ++$i;
                     } else { // not valid UTF8 - convert it
                         $buf .= self::to_utf8_convert_helper($c1);
@@ -11376,7 +11375,7 @@ 
                     $c3 = $i + 2 >= $max ? "\x00" : $str[$i + 2];
 
                     if ($c2 >= "\x80" && $c2 <= "\xBF" && $c3 >= "\x80" && $c3 <= "\xBF") { // yeah, almost sure it's UTF8 already
-                        $buf .= $c1 . $c2 . $c3;
+                        $buf .= $c1.$c2.$c3;
                         $i += 2;
                     } else { // not valid UTF8 - convert it
                         $buf .= self::to_utf8_convert_helper($c1);
@@ -11388,7 +11387,7 @@ 
                     $c4 = $i + 3 >= $max ? "\x00" : $str[$i + 3];
 
                     if ($c2 >= "\x80" && $c2 <= "\xBF" && $c3 >= "\x80" && $c3 <= "\xBF" && $c4 >= "\x80" && $c4 <= "\xBF") { // yeah, almost sure it's UTF8 already
-                        $buf .= $c1 . $c2 . $c3 . $c4;
+                        $buf .= $c1.$c2.$c3.$c4;
                         $i += 3;
                     } else { // not valid UTF8 - convert it
                         $buf .= self::to_utf8_convert_helper($c1);
@@ -11414,13 +11413,13 @@ 
              *
              * @return string
              */
-            static function (array $matches): string {
+            static function(array $matches): string {
                 if (isset($matches[3])) {
-                    $cp = (int) \hexdec($matches[3]);
+                    $cp = (int)\hexdec($matches[3]);
                 } else {
                     // http://unicode.org/faq/utf_bom.html#utf16-4
-                    $cp = ((int) \hexdec($matches[1]) << 10)
-                          + (int) \hexdec($matches[2])
+                    $cp = ((int)\hexdec($matches[1]) << 10)
+                          + (int)\hexdec($matches[2])
                           + 0x10000
                           - (0xD800 << 10)
                           - 0xDC00;
@@ -11431,12 +11430,12 @@ 
                 // php_utf32_utf8(unsigned char *buf, unsigned k)
 
                 if ($cp < 0x80) {
-                    return (string) self::chr($cp);
+                    return (string)self::chr($cp);
                 }
 
                 if ($cp < 0xA0) {
                     /** @noinspection UnnecessaryCastingInspection */
-                    return (string) self::chr(0xC0 | $cp >> 6) . (string) self::chr(0x80 | $cp & 0x3F);
+                    return (string)self::chr(0xC0 | $cp >> 6).(string)self::chr(0x80 | $cp & 0x3F);
                 }
 
                 return self::decimal_to_chr($cp);
@@ -11484,7 +11483,7 @@ 
 
         if (self::$SUPPORT['mbstring'] === true) {
             /** @noinspection PhpComposerExtensionStubsInspection */
-            return (string) \mb_ereg_replace($pattern, '', $str);
+            return (string)\mb_ereg_replace($pattern, '', $str);
         }
 
         return self::regex_replace($str, $pattern, '', '', '/');
@@ -11521,15 +11520,15 @@ 
         $useMbFunction = $lang === null && $tryToKeepStringLength === false;
 
         if ($encoding === 'UTF-8') {
-            $strPartTwo = (string) \mb_substr($str, 1);
+            $strPartTwo = (string)\mb_substr($str, 1);
 
             if ($useMbFunction === true) {
                 $strPartOne = \mb_strtoupper(
-                    (string) \mb_substr($str, 0, 1)
+                    (string)\mb_substr($str, 0, 1)
                 );
             } else {
                 $strPartOne = self::strtoupper(
-                    (string) \mb_substr($str, 0, 1),
+                    (string)\mb_substr($str, 0, 1),
                     $encoding,
                     false,
                     $lang,
@@ -11539,16 +11538,16 @@ 
         } else {
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
 
-            $strPartTwo = (string) self::substr($str, 1, null, $encoding);
+            $strPartTwo = (string)self::substr($str, 1, null, $encoding);
 
             if ($useMbFunction === true) {
                 $strPartOne = \mb_strtoupper(
-                    (string) \mb_substr($str, 0, 1, $encoding),
+                    (string)\mb_substr($str, 0, 1, $encoding),
                     $encoding
                 );
             } else {
                 $strPartOne = self::strtoupper(
-                    (string) self::substr($str, 0, 1, $encoding),
+                    (string)self::substr($str, 0, 1, $encoding),
                     $encoding,
                     false,
                     $lang,
@@ -11557,7 +11556,7 @@ 
             }
         }
 
-        return $strPartOne . $strPartTwo;
+        return $strPartOne.$strPartTwo;
     }
 
     /**
@@ -11608,7 +11607,7 @@ 
             $str = self::clean($str);
         }
 
-        $usePhpDefaultFunctions = !(bool) ($charlist . \implode('', $exceptions));
+        $usePhpDefaultFunctions = !(bool)($charlist.\implode('', $exceptions));
 
         if (
             $usePhpDefaultFunctions === true
@@ -12010,7 +12009,7 @@ 
         if (
             $keepUtf8Chars === true
             &&
-            self::strlen($return) >= (int) self::strlen($str_backup)
+            self::strlen($return) >= (int)self::strlen($str_backup)
         ) {
             return $str_backup;
         }
@@ -12088,17 +12087,17 @@ 
             return '';
         }
 
-        \preg_match('/^\s*+(?:\S++\s*+){1,' . $limit . '}/u', $str, $matches);
+        \preg_match('/^\s*+(?:\S++\s*+){1,'.$limit.'}/u', $str, $matches);
 
         if (
             !isset($matches[0])
             ||
-            \mb_strlen($str) === (int) \mb_strlen($matches[0])
+            \mb_strlen($str) === (int)\mb_strlen($matches[0])
         ) {
             return $str;
         }
 
-        return \rtrim($matches[0]) . $strAddOn;
+        return \rtrim($matches[0]).$strAddOn;
     }
 
     /**
@@ -12169,7 +12168,7 @@ 
             $strReturn .= $break;
         }
 
-        return $strReturn . \implode('', $chars);
+        return $strReturn.\implode('', $chars);
     }
 
     /**
@@ -12182,7 +12181,7 @@ 
      */
     public static function wordwrap_per_line(string $str, int $limit): string
     {
-        $strings = (array) \preg_split('/\\r\\n|\\r|\\n/', $str);
+        $strings = (array)\preg_split('/\\r\\n|\\r|\\n/', $str);
 
         $string = '';
         foreach ($strings as &$value) {
@@ -12219,7 +12218,7 @@ 
 
             \uksort(
                 self::$EMOJI,
-                static function (string $a, string $b): int {
+                static function(string $a, string $b): int {
                     return \strlen($b) <=> \strlen($a);
                 }
             );
@@ -12229,7 +12228,7 @@ 
 
             foreach (self::$EMOJI_KEYS_CACHE as $key) {
                 $tmpKey = \crc32($key);
-                self::$EMOJI_KEYS_REVERSIBLE_CACHE[] = '_-_PORTABLE_UTF8_-_' . $tmpKey . '_-_' . \strrev((string) $tmpKey) . '_-_8FTU_ELBATROP_-_';
+                self::$EMOJI_KEYS_REVERSIBLE_CACHE[] = '_-_PORTABLE_UTF8_-_'.$tmpKey.'_-_'.\strrev((string)$tmpKey).'_-_8FTU_ELBATROP_-_';
             }
 
             return true;
@@ -12292,7 +12291,7 @@ 
         /** @noinspection PhpIncludeInspection */
         /** @noinspection UsingInclusionReturnValueInspection */
         /** @psalm-suppress UnresolvableInclude */
-        return include __DIR__ . '/data/' . $file . '.php';
+        return include __DIR__.'/data/'.$file.'.php';
     }
 
     /**
@@ -12304,7 +12303,7 @@ 
      */
     private static function getDataIfExists(string $file)
     {
-        $file = __DIR__ . '/data/' . $file . '.php';
+        $file = __DIR__.'/data/'.$file.'.php';
         if (\file_exists($file)) {
             /** @noinspection PhpIncludeInspection */
             /** @noinspection UsingInclusionReturnValueInspection */
@@ -12329,7 +12328,7 @@ 
         /** @noinspection PhpUsageOfSilenceOperatorInspection */
         return \defined('MB_OVERLOAD_STRING')
                &&
-               ((int) @\ini_get('mbstring.func_overload') & \MB_OVERLOAD_STRING);
+               ((int)@\ini_get('mbstring.func_overload') & \MB_OVERLOAD_STRING);
     }
 
     /**
@@ -12379,7 +12378,7 @@ 
     {
         static $RX_CLASS_CACHE = [];
 
-        $cacheKey = $s . $class;
+        $cacheKey = $s.$class;
 
         if (isset($RX_CLASS_CACHE[$cacheKey])) {
             return $RX_CLASS_CACHE[$cacheKey];
@@ -12391,7 +12390,7 @@ 
         /** @noinspection AlterInForeachInspection */
         foreach (self::str_split($s) as &$s) {
             if ($s === '-') {
-                $classArray[0] = '-' . $classArray[0];
+                $classArray[0] = '-'.$classArray[0];
             } elseif (!isset($s[2])) {
                 $classArray[0] .= \preg_quote($s, '/');
             } elseif (self::strlen($s) === 1) {
@@ -12402,13 +12401,13 @@ 
         }
 
         if ($classArray[0]) {
-            $classArray[0] = '[' . $classArray[0] . ']';
+            $classArray[0] = '['.$classArray[0].']';
         }
 
         if (\count($classArray) === 1) {
             $return = $classArray[0];
         } else {
-            $return = '(?:' . \implode('|', $classArray) . ')';
+            $return = '(?:'.\implode('|', $classArray).')';
         }
 
         $RX_CLASS_CACHE[$cacheKey] = $return;
@@ -12482,7 +12481,7 @@ 
             $continue = false;
 
             if ($delimiter === '-') {
-                foreach ((array) $specialCases['names'] as &$beginning) {
+                foreach ((array)$specialCases['names'] as &$beginning) {
                     if (self::strpos($name, $beginning, 0, $encoding) === 0) {
                         $continue = true;
                     }
@@ -12490,7 +12489,7 @@ 
                 unset($beginning);
             }
 
-            foreach ((array) $specialCases['prefixes'] as &$beginning) {
+            foreach ((array)$specialCases['prefixes'] as &$beginning) {
                 if (self::strpos($name, $beginning, 0, $encoding) === 0) {
                     $continue = true;
                 }
@@ -12550,8 +12549,8 @@ 
             $buf .= self::$WIN1252_TO_UTF8[$ordC1];
         } else {
             $cc1 = self::$CHR[$ordC1 / 64] | "\xC0";
-            $cc2 = ((string) $input & "\x3F") | "\x80";
-            $buf .= $cc1 . $cc2;
+            $cc2 = ((string)$input & "\x3F") | "\x80";
+            $buf .= $cc1.$cc2;
         }
 
         return $buf;