voku / portable-utf8

src/voku/helper/UTF8.php

Indentation +8 added lines, -8 removed lines

@@ -573,16 +573,16 @@ 
             $chr = self::$CHR[$code_point];
         } elseif ($code_point <= 0x7FF) {
             $chr = self::$CHR[($code_point >> 6) + 0xC0] .
-                   self::$CHR[($code_point & 0x3F) + 0x80];
+                    self::$CHR[($code_point & 0x3F) + 0x80];
         } elseif ($code_point <= 0xFFFF) {
             $chr = self::$CHR[($code_point >> 12) + 0xE0] .
-                   self::$CHR[(($code_point >> 6) & 0x3F) + 0x80] .
-                   self::$CHR[($code_point & 0x3F) + 0x80];
+                    self::$CHR[(($code_point >> 6) & 0x3F) + 0x80] .
+                    self::$CHR[($code_point & 0x3F) + 0x80];
         } else {
             $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];
+                    self::$CHR[(($code_point >> 12) & 0x3F) + 0x80] .
+                    self::$CHR[(($code_point >> 6) & 0x3F) + 0x80] .
+                    self::$CHR[($code_point & 0x3F) + 0x80];
         }
 
         if ($encoding !== 'UTF-8') {
@@ -3189,10 +3189,10 @@ 
 
         /** @noinspection PhpComposerExtensionStubsInspection */
         return (
-                   \is_object($json) === true
+                    \is_object($json) === true
                    ||
                    \is_array($json) === true
-               )
+                )
                &&
                \json_last_error() === \JSON_ERROR_NONE;
     }

Spacing +273 added lines, -274 removed lines

@@ -243,7 +243,7 @@ 
             return '';
         }
 
-        return (string) self::substr($str, $pos, 1);
+        return (string)self::substr($str, $pos, 1);
     }
 
     /**
@@ -258,7 +258,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;
@@ -428,7 +428,7 @@ 
      */
     public static function char_at(string $str, int $index, string $encoding = 'UTF-8'): string
     {
-        return (string) self::substr($str, $index, 1, $encoding);
+        return (string)self::substr($str, $index, 1, $encoding);
     }
 
     /**
@@ -524,10 +524,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];
         }
@@ -537,7 +537,7 @@ 
             if (self::$CHR === null) {
                 $chrTmp = self::getData('chr');
                 if ($chrTmp) {
-                    self::$CHR = (array) $chrTmp;
+                    self::$CHR = (array)$chrTmp;
                 }
             }
 
@@ -564,24 +564,24 @@ 
         if (self::$CHR === null) {
             $chrTmp = self::getData('chr');
             if ($chrTmp) {
-                self::$CHR = (array) $chrTmp;
+                self::$CHR = (array)$chrTmp;
             }
         }
 
-        $code_point = (int) $code_point;
+        $code_point = (int)$code_point;
         if ($code_point <= 0x7F) {
             $chr = self::$CHR[$code_point];
         } elseif ($code_point <= 0x7FF) {
-            $chr = self::$CHR[($code_point >> 6) + 0xC0] .
+            $chr = self::$CHR[($code_point >> 6) + 0xC0].
                    self::$CHR[($code_point & 0x3F) + 0x80];
         } elseif ($code_point <= 0xFFFF) {
-            $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 {
-            $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];
         }
 
@@ -633,7 +633,7 @@ 
 
         if (self::$SUPPORT['mbstring_func_overload'] === true) {
             return \array_map(
-                function ($data) {
+                function($data) {
                     return self::strlen_in_byte($data);
                 },
                 $strSplit
@@ -774,7 +774,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, '');
@@ -809,7 +809,7 @@ 
     public static function cleanup($str): string
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return '';
@@ -918,7 +918,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*#misU',
             '',
             $str
@@ -945,7 +945,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);
     }
 
     /**
@@ -1101,7 +1101,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 (!isset(self::$SUPPORT['already_checked_via_portable_utf8'])) {
@@ -1190,7 +1190,7 @@ 
         $trimChars = "\t\r\n -_()!~?=+/*\\,.:;\"'[]{}`&";
 
         if ($length === null) {
-            $length = (int) \round(self::strlen($str, $encoding) / 2, 0);
+            $length = (int)\round(self::strlen($str, $encoding) / 2, 0);
         }
 
         if (empty($search)) {
@@ -1202,7 +1202,7 @@ 
                 $end = 0;
             }
 
-            $pos = (int) \min(
+            $pos = (int)\min(
                 self::strpos($str, ' ', $end, $encoding),
                 self::strpos($str, '.', $end, $encoding)
             );
@@ -1213,20 +1213,20 @@ 
                     return '';
                 }
 
-                return \rtrim($strSub, $trimChars) . $replacerForSkippedText;
+                return \rtrim($strSub, $trimChars).$replacerForSkippedText;
             }
 
             return $str;
         }
 
         $wordPos = self::stripos($str, $search, 0, $encoding);
-        $halfSide = (int) ($wordPos - $length / 2 + self::strlen($search, $encoding) / 2);
+        $halfSide = (int)($wordPos - $length / 2 + self::strlen($search, $encoding) / 2);
 
         $pos_start = 0;
         if ($halfSide > 0) {
             $halfText = self::substr($str, 0, $halfSide, $encoding);
             if ($halfText !== false) {
-                $pos_start = (int) \max(
+                $pos_start = (int)\max(
                     self::strrpos($halfText, ' ', 0, $encoding),
                     self::strrpos($halfText, '.', 0, $encoding)
                 );
@@ -1241,7 +1241,7 @@ 
                 $l = $realLength;
             }
 
-            $pos_end = (int) \min(
+            $pos_end = (int)\min(
                     self::strpos($str, ' ', $l, $encoding),
                     self::strpos($str, '.', $l, $encoding)
                 ) - $pos_start;
@@ -1249,14 +1249,14 @@ 
             if (!$pos_end || $pos_end <= 0) {
                 $strSub = self::substr($str, $pos_start, self::strlen($str), $encoding);
                 if ($strSub !== false) {
-                    $extract = $replacerForSkippedText . \ltrim($strSub, $trimChars);
+                    $extract = $replacerForSkippedText.\ltrim($strSub, $trimChars);
                 } else {
                     $extract = '';
                 }
             } else {
                 $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 = '';
                 }
@@ -1277,7 +1277,7 @@ 
             if ($pos_end) {
                 $strSub = self::substr($str, 0, $pos_end, $encoding);
                 if ($strSub !== false) {
-                    $extract = \rtrim($strSub, $trimChars) . $replacerForSkippedText;
+                    $extract = \rtrim($strSub, $trimChars).$replacerForSkippedText;
                 } else {
                     $extract = '';
                 }
@@ -1397,7 +1397,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);
@@ -1459,7 +1459,7 @@ 
                     ) {
                         // Prevent leading combining chars
                         // for NFC-safe concatenations.
-                        $var = $leading_combining . $var;
+                        $var = $leading_combining.$var;
                     }
                 }
 
@@ -1727,13 +1727,13 @@ 
         $lower = self::$COMMON_CASE_FOLD['lower'];
 
         if ($useLower === true) {
-            $str = (string) \str_replace(
+            $str = (string)\str_replace(
                 $upper,
                 $lower,
                 $str
             );
         } else {
-            $str = (string) \str_replace(
+            $str = (string)\str_replace(
                 $lower,
                 $upper,
                 $str
@@ -1747,9 +1747,9 @@ 
             }
 
             if ($useLower === true) {
-                $str = (string) \str_replace($FULL_CASE_FOLD[0], $FULL_CASE_FOLD[1], $str);
+                $str = (string)\str_replace($FULL_CASE_FOLD[0], $FULL_CASE_FOLD[1], $str);
             } else {
-                $str = (string) \str_replace($FULL_CASE_FOLD[1], $FULL_CASE_FOLD[0], $str);
+                $str = (string)\str_replace($FULL_CASE_FOLD[1], $FULL_CASE_FOLD[0], $str);
             }
         }
 
@@ -1809,7 +1809,7 @@ 
             return $str;
         }
 
-        $str = (string) $str;
+        $str = (string)$str;
         $last = '';
         while ($last !== $str) {
             $last = $str;
@@ -1948,7 +1948,7 @@ 
      */
     private static function getData(string $file)
     {
-        $file = __DIR__ . '/data/' . $file . '.php';
+        $file = __DIR__.'/data/'.$file.'.php';
         if (\file_exists($file)) {
             /** @noinspection PhpIncludeInspection */
             return require $file;
@@ -2012,7 +2012,7 @@ 
         }
 
         $str_info = \unpack('C2chars', $str_info);
-        $type_code = (int) ($str_info['chars1'] . $str_info['chars2']);
+        $type_code = (int)($str_info['chars1'].$str_info['chars2']);
 
         // DEBUG
         //var_dump($type_code);
@@ -2125,16 +2125,16 @@ 
      */
     public static function get_unique_string($entropyExtra = '', bool $md5 = true): string
     {
-        $uniqueHelper = \mt_rand() .
-                        \session_id() .
-                        ($_SERVER['REMOTE_ADDR'] ?? '') .
-                        ($_SERVER['SERVER_ADDR'] ?? '') .
+        $uniqueHelper = \mt_rand().
+                        \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;
@@ -2204,7 +2204,7 @@ 
     public static function hex_to_int($hexDec)
     {
         // init
-        $hexDec = (string) $hexDec;
+        $hexDec = (string)$hexDec;
 
         if ($hexDec === '') {
             return false;
@@ -2279,7 +2279,7 @@ 
         return \implode(
             '',
             \array_map(
-                function ($chr) use ($keepAsciiChars, $encoding) {
+                function($chr) use ($keepAsciiChars, $encoding) {
                     return self::single_chr_html_encode($chr, $keepAsciiChars, $encoding);
                 },
                 self::split($str)
@@ -2395,7 +2395,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);
         }
 
         if (!isset(self::$SUPPORT['already_checked_via_portable_utf8'])) {
@@ -2413,9 +2413,9 @@ 
                     $encoding
                 );
             } else {
-                $str = (string) \preg_replace_callback(
+                $str = (string)\preg_replace_callback(
                     "/&#\d{2,6};/",
-                    function ($matches) use ($encoding) {
+                    function($matches) use ($encoding) {
                         // always fallback via symfony polyfill
                         $returnTmp = \mb_convert_encoding($matches[0], $encoding, 'HTML-ENTITIES');
 
@@ -2468,7 +2468,7 @@ 
      */
     public static function html_stripe_empty_tags(string $str): string
     {
-        return (string) \preg_replace(
+        return (string)\preg_replace(
             "/<[^\/>]*>(([\s]?)*|)<\/[^>]*>/iu",
             '',
             $str
@@ -2755,9 +2755,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.'';
     }
 
     /**
@@ -2995,7 +2995,7 @@ 
             return false;
         }
 
-        $base64String = (string) \base64_decode($str, true);
+        $base64String = (string)\base64_decode($str, true);
 
         return $base64String && \base64_encode($base64String) === $str;
     }
@@ -3010,7 +3010,7 @@ 
      */
     public static function is_binary($input, bool $strict = false): bool
     {
-        $input = (string) $input;
+        $input = (string)$input;
         if ($input === '') {
             return false;
         }
@@ -3259,7 +3259,7 @@ 
     public static function is_utf16($str, $checkIfStringIsBinary = true)
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
         $strChars = [];
 
         if (
@@ -3335,7 +3335,7 @@ 
     public static function is_utf32($str, $checkIfStringIsBinary = true)
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
         $strChars = [];
 
         if (
@@ -3457,7 +3457,7 @@ 
             self::$ORD = self::getData('ord');
         }
 
-        $len = self::strlen_in_byte((string) $str);
+        $len = self::strlen_in_byte((string)$str);
         /** @noinspection ForeachInvariantsInspection */
         for ($i = 0; $i < $len; $i++) {
             $in = self::$ORD[$str[$i]];
@@ -3692,14 +3692,14 @@ 
         }
 
         $strPartOne = self::strtolower(
-            (string) self::substr($str, 0, 1, $encoding, $cleanUtf8),
+            (string)self::substr($str, 0, 1, $encoding, $cleanUtf8),
             $encoding,
             $cleanUtf8,
             $lang,
             $tryToKeepStringLength
         );
 
-        return $strPartOne . $strPartTwo;
+        return $strPartOne.$strPartTwo;
     }
 
     /**
@@ -3867,7 +3867,7 @@ 
     {
         $bytes = self::chr_size_list($str);
         if (\count($bytes) > 0) {
-            return (int) \max($bytes);
+            return (int)\max($bytes);
         }
 
         return 0;
@@ -3961,7 +3961,7 @@ 
         static $STATIC_NORMALIZE_ENCODING_CACHE = [];
 
         // init
-        $encoding = (string) $encoding;
+        $encoding = (string)$encoding;
 
         if (
             !$encoding
@@ -4099,7 +4099,7 @@ 
      */
     public static function normalize_line_ending(string $str): string
     {
-        return (string) \str_replace(["\r\n", "\r"], "\n", $str);
+        return (string)\str_replace(["\r\n", "\r"], "\n", $str);
     }
 
     /**
@@ -4147,7 +4147,7 @@ 
         }
 
         static $WHITESPACE_CACHE = [];
-        $cacheKey = (int) $keepNonBreakingSpace;
+        $cacheKey = (int)$keepNonBreakingSpace;
 
         if (!isset($WHITESPACE_CACHE[$cacheKey])) {
             $WHITESPACE_CACHE[$cacheKey] = self::$WHITESPACE_TABLE;
@@ -4187,7 +4187,7 @@ 
     public static function ord($chr, string $encoding = 'UTF-8'): int
     {
         // init
-        $chr = (string) $chr;
+        $chr = (string)$chr;
 
         static $CHAR_CACHE = [];
 
@@ -4198,7 +4198,7 @@ 
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
         }
 
-        $cacheKey = $chr_orig . $encoding;
+        $cacheKey = $chr_orig.$encoding;
         if (isset($CHAR_CACHE[$cacheKey]) === true) {
             return $CHAR_CACHE[$cacheKey];
         }
@@ -4229,22 +4229,22 @@ 
         }
 
         /** @noinspection CallableParameterUseCaseInTypeContextInspection */
-        $chr = \unpack('C*', (string) self::substr($chr, 0, 4, 'CP850'));
+        $chr = \unpack('C*', (string)self::substr($chr, 0, 4, 'CP850'));
         $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;
@@ -4297,7 +4297,7 @@ 
     public static function pcre_utf8_support(): bool
     {
         /** @noinspection PhpUsageOfSilenceOperatorInspection */
-        return (bool) @\preg_match('//u', '');
+        return (bool)@\preg_match('//u', '');
     }
 
     /**
@@ -4323,10 +4323,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);
         }
@@ -4336,10 +4336,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);
         }
@@ -4384,7 +4384,7 @@ 
 
         $pattern = '/%u([0-9a-f]{3,4})/i';
         if (\preg_match($pattern, $str)) {
-            $str = (string) \preg_replace($pattern, '&#x\\1;', \rawurldecode($str));
+            $str = (string)\preg_replace($pattern, '&#x\\1;', \rawurldecode($str));
         }
 
         $flags = \ENT_QUOTES | \ENT_HTML5;
@@ -4462,8 +4462,8 @@ 
             $delimiter = '/';
         }
 
-        return (string) \preg_replace(
-            $delimiter . $pattern . $delimiter . 'u' . $options,
+        return (string)\preg_replace(
+            $delimiter.$pattern.$delimiter.'u'.$options,
             $replacement,
             $str
         );
@@ -4508,7 +4508,7 @@ 
 
                 $strLength -= $bomByteLength;
 
-                $str = (string) $strTmp;
+                $str = (string)$strTmp;
             }
         }
 
@@ -4532,7 +4532,7 @@ 
         if (\is_array($what) === true) {
             /** @noinspection ForeachSourceInspection */
             foreach ($what as $item) {
-                $str = (string) \preg_replace('/(' . \preg_quote($item, '/') . ')+/', $item, $str);
+                $str = (string)\preg_replace('/('.\preg_quote($item, '/').')+/', $item, $str);
             }
         }
 
@@ -4564,7 +4564,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);
     }
 
     /**
@@ -4595,7 +4595,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;
@@ -4613,7 +4613,7 @@ 
     public static function remove_left(string $str, string $substring, string $encoding = 'UTF-8'): string
     {
         if (self::str_starts_with($str, $substring)) {
-            return (string) self::substr(
+            return (string)self::substr(
                 $str,
                 self::strlen($substring, $encoding),
                 null,
@@ -4636,7 +4636,7 @@ 
     public static function remove_right(string $str, string $substring, string $encoding = 'UTF-8'): string
     {
         if (self::str_ends_with($str, $substring)) {
-            return (string) self::substr(
+            return (string)self::substr(
                 $str,
                 0,
                 self::strlen($str, $encoding) - self::strlen($substring, $encoding)
@@ -4778,7 +4778,7 @@ 
     {
         static $RX_CLASSS_CACHE = [];
 
-        $cacheKey = $s . $class;
+        $cacheKey = $s.$class;
 
         if (isset($RX_CLASSS_CACHE[$cacheKey])) {
             return $RX_CLASSS_CACHE[$cacheKey];
@@ -4790,7 +4790,7 @@ 
         /** @noinspection SuspiciousLoopInspection */
         foreach (self::str_split($s) as $s) {
             if ($s === '-') {
-                $class[0] = '-' . $class[0];
+                $class[0] = '-'.$class[0];
             } elseif (!isset($s[2])) {
                 $class[0] .= \preg_quote($s, '/');
             } elseif (self::strlen($s) === 1) {
@@ -4801,13 +4801,13 @@ 
         }
 
         if ($class[0]) {
-            $class[0] = '[' . $class[0] . ']';
+            $class[0] = '['.$class[0].']';
         }
 
         if (\count($class) === 1) {
             $return = $class[0];
         } else {
-            $return = '(?:' . \implode('|', $class) . ')';
+            $return = '(?:'.\implode('|', $class).')';
         }
 
         $RX_CLASSS_CACHE[$cacheKey] = $return;
@@ -4826,7 +4826,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>";
         }
         echo '</pre>';
     }
@@ -4858,7 +4858,7 @@ 
             $encoding = self::normalize_encoding($encoding, 'UTF-8');
         }
 
-        return '&#' . self::ord($char, $encoding) . ';';
+        return '&#'.self::ord($char, $encoding).';';
     }
 
     /**
@@ -4896,7 +4896,7 @@ 
         }
 
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return [];
@@ -4939,7 +4939,7 @@ 
                     ($str[$i] & "\xE0") === "\xC0"
                 ) {
                     if (($str[$i + 1] & "\xC0") === "\x80") {
-                        $ret[] = $str[$i] . $str[$i + 1];
+                        $ret[] = $str[$i].$str[$i + 1];
 
                         $i++;
                     }
@@ -4953,7 +4953,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;
                     }
@@ -4969,7 +4969,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;
                     }
@@ -4981,7 +4981,7 @@ 
             $ret = \array_chunk($ret, $length);
 
             return \array_map(
-                function ($item) {
+                function($item) {
                     return \implode('', $item);
                 },
                 $ret
@@ -5011,11 +5011,11 @@ 
     public static function str_camelize(string $str, string $encoding = 'UTF-8', bool $cleanUtf8 = false, string $lang = null, bool $tryToKeepStringLength = false): string
     {
         $str = self::lcfirst(self::trim($str), $encoding, $cleanUtf8, $lang, $tryToKeepStringLength);
-        $str = (string) \preg_replace('/^[-_]+/', '', $str);
+        $str = (string)\preg_replace('/^[-_]+/', '', $str);
 
-        $str = (string) \preg_replace_callback(
+        $str = (string)\preg_replace_callback(
             '/[-_\s]+(.)?/u',
-            function ($match) use ($encoding, $cleanUtf8, $lang, $tryToKeepStringLength) {
+            function($match) use ($encoding, $cleanUtf8, $lang, $tryToKeepStringLength) {
                 if (isset($match[1])) {
                     return self::strtoupper($match[1], $encoding, $cleanUtf8, $lang, $tryToKeepStringLength);
                 }
@@ -5025,9 +5025,9 @@ 
             $str
         );
 
-        $str = (string) \preg_replace_callback(
+        $str = (string)\preg_replace_callback(
             '/[\d]+(.)?/u',
-            function ($match) use ($encoding, $cleanUtf8, $lang, $tryToKeepStringLength) {
+            function($match) use ($encoding, $cleanUtf8, $lang, $tryToKeepStringLength) {
                 return self::strtoupper($match[0], $encoding, $cleanUtf8, $lang, $tryToKeepStringLength);
             },
             $str
@@ -5162,7 +5162,7 @@ 
 
         // only a fallback to prevent BC in the api ...
         if ($caseSensitive !== false && $caseSensitive !== true) {
-            $encoding = (string) $caseSensitive;
+            $encoding = (string)$caseSensitive;
         }
 
         if ($caseSensitive) {
@@ -5196,7 +5196,7 @@ 
 
         // only a fallback to prevent BC in the api ...
         if ($caseSensitive !== false && $caseSensitive !== true) {
-            $encoding = (string) $caseSensitive;
+            $encoding = (string)$caseSensitive;
         }
 
         foreach ($needles as $needle) {
@@ -5278,11 +5278,11 @@ 
     ): string {
         $str = self::trim($str);
 
-        $str = (string) \preg_replace('/\B([A-Z])/u', '-\1', $str);
+        $str = (string)\preg_replace('/\B([A-Z])/u', '-\1', $str);
 
         $str = self::strtolower($str, $encoding, $cleanUtf8, $lang, $tryToKeepStringLength);
 
-        return (string) \preg_replace('/[-_\s]+/u', $delimiter, $str);
+        return (string)\preg_replace('/[-_\s]+/u', $delimiter, $str);
     }
 
     /**
@@ -5297,7 +5297,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 / ...
@@ -5403,7 +5403,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;
             }
         }
@@ -5465,7 +5465,7 @@ 
     public static function str_ensure_left(string $str, string $substring): string
     {
         if (!self::str_starts_with($str, $substring)) {
-            $str = $substring . $str;
+            $str = $substring.$str;
         }
 
         return $str;
@@ -5674,7 +5674,7 @@ 
         $start = self::substr($str, 0, $index, $encoding);
         $end = self::substr($str, $index, $len, $encoding);
 
-        return $start . $substring . $end;
+        return $start.$substring.$end;
     }
 
     /**
@@ -5704,15 +5704,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';
             }
         }
 
@@ -5744,11 +5744,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;
@@ -5776,11 +5776,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;
@@ -5860,7 +5860,7 @@ 
             return '';
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
             $offset + self::strlen($separator, $encoding),
             null,
@@ -5892,7 +5892,7 @@ 
             return '';
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
             $offset + self::strlen($separator, $encoding),
             null,
@@ -5924,7 +5924,7 @@ 
             return '';
         }
 
-        return (string) self::substr($str, 0, $offset, $encoding);
+        return (string)self::substr($str, 0, $offset, $encoding);
     }
 
     /**
@@ -5951,7 +5951,7 @@ 
             return '';
         }
 
-        return (string) self::substr($str, 0, $offset, $encoding);
+        return (string)self::substr($str, 0, $offset, $encoding);
     }
 
     /**
@@ -6059,7 +6059,7 @@ 
             return $str;
         }
 
-        return self::substr($str, 0, $length - self::strlen($strAddOn), $encoding) . $strAddOn;
+        return self::substr($str, 0, $length - self::strlen($strAddOn), $encoding).$strAddOn;
     }
 
     /**
@@ -6087,18 +6087,18 @@ 
         }
 
         if (self::substr($str, $length - 1, 1, $encoding) === ' ') {
-            return self::substr($str, 0, $length - 1, $encoding) . $strAddOn;
+            return self::substr($str, 0, $length - 1, $encoding).$strAddOn;
         }
 
-        $str = (string) self::substr($str, 0, $length, $encoding);
+        $str = (string)self::substr($str, 0, $length, $encoding);
         $array = \explode(' ', $str);
         \array_pop($array);
         $new_str = \implode(' ', $array);
 
         if ($new_str === '') {
-            $str = self::substr($str, 0, $length - 1, $encoding) . $strAddOn;
+            $str = self::substr($str, 0, $length - 1, $encoding).$strAddOn;
         } else {
-            $str = $new_str . $strAddOn;
+            $str = $new_str.$strAddOn;
         }
 
         return $str;
@@ -6201,7 +6201,7 @@ 
             $char = self::substr($str, -$i, 1, $encoding);
 
             if ($char === self::substr($otherStr, -$i, 1, $encoding)) {
-                $longestCommonSuffix = $char . $longestCommonSuffix;
+                $longestCommonSuffix = $char.$longestCommonSuffix;
             } else {
                 break;
             }
@@ -6220,7 +6220,7 @@ 
      */
     public static function str_matches_pattern(string $str, string $pattern): bool
     {
-        if (\preg_match('/' . $pattern . '/u', $str)) {
+        if (\preg_match('/'.$pattern.'/u', $str)) {
             return true;
         }
 
@@ -6300,7 +6300,7 @@ 
             return '';
         }
 
-        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') {
@@ -6309,7 +6309,7 @@ 
                 $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'"
                 );
             }
         }
@@ -6327,28 +6327,28 @@ 
 
             switch ($pad_type) {
                 case \STR_PAD_LEFT:
-                    $pre = \str_repeat($pad_string, (int) \ceil($diff / $ps_length));
-                    $pre = (string) self::substr($pre, 0, $diff, $encoding);
+                    $pre = \str_repeat($pad_string, (int)\ceil($diff / $ps_length));
+                    $pre = (string)self::substr($pre, 0, $diff, $encoding);
                     $post = '';
 
                     break;
 
                 case \STR_PAD_BOTH:
-                    $pre = \str_repeat($pad_string, (int) \ceil($diff / $ps_length / 2));
-                    $pre = (string) self::substr($pre, 0, (int) \floor($diff / 2), $encoding);
-                    $post = \str_repeat($pad_string, (int) \ceil($diff / $ps_length / 2));
-                    $post = (string) self::substr($post, 0, (int) \ceil($diff / 2), $encoding);
+                    $pre = \str_repeat($pad_string, (int)\ceil($diff / $ps_length / 2));
+                    $pre = (string)self::substr($pre, 0, (int)\floor($diff / 2), $encoding);
+                    $post = \str_repeat($pad_string, (int)\ceil($diff / $ps_length / 2));
+                    $post = (string)self::substr($post, 0, (int)\ceil($diff / 2), $encoding);
 
                     break;
 
                 case \STR_PAD_RIGHT:
                 default:
-                    $post = \str_repeat($pad_string, (int) \ceil($diff / $ps_length));
-                    $post = (string) self::substr($post, 0, $diff, $encoding);
+                    $post = \str_repeat($pad_string, (int)\ceil($diff / $ps_length));
+                    $post = (string)self::substr($post, 0, $diff, $encoding);
                     $pre = '';
             }
 
-            return $pre . $str . $post;
+            return $pre.$str.$post;
         }
 
         return $str;
@@ -6369,7 +6369,7 @@ 
     {
         $padding = $length - self::strlen($str, $encoding);
 
-        return self::apply_padding($str, (int) \floor($padding / 2), (int) \ceil($padding / 2), $padStr, $encoding);
+        return self::apply_padding($str, (int)\floor($padding / 2), (int)\ceil($padding / 2), $padStr, $encoding);
     }
 
     /**
@@ -6485,11 +6485,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;
@@ -6517,11 +6517,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;
@@ -6631,26 +6631,26 @@ 
         $str = self::normalize_whitespace($str);
         $str = \str_replace('-', '_', $str);
 
-        $str = (string) \preg_replace_callback(
+        $str = (string)\preg_replace_callback(
             '/([\d|A-Z])/u',
-            function ($matches) use ($encoding) {
+            function($matches) use ($encoding) {
                 $match = $matches[1];
-                $matchInt = (int) $match;
+                $matchInt = (int)$match;
 
-                if ((string) $matchInt === $match) {
-                    return '_' . $match . '_';
+                if ((string)$matchInt === $match) {
+                    return '_'.$match.'_';
                 }
 
-                return '_' . self::strtolower($match, $encoding);
+                return '_'.self::strtolower($match, $encoding);
             },
             $str
         );
 
-        $str = (string) \preg_replace(
+        $str = (string)\preg_replace(
             [
-                '/\s+/',        // convert spaces to "_"
-                '/^\s+|\s+$/',  // trim leading & trailing spaces
-                '/_+/',         // remove double "_"
+                '/\s+/', // convert spaces to "_"
+                '/^\s+|\s+$/', // trim leading & trailing spaces
+                '/_+/', // remove double "_"
             ],
             [
                 '_',
@@ -6737,7 +6737,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 [];
@@ -6824,7 +6824,7 @@ 
             return '';
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
             $offset + self::strlen($separator, $encoding),
             null,
@@ -6856,7 +6856,7 @@ 
             return '';
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
             $offset + self::strlen($separator, $encoding),
             null,
@@ -6888,7 +6888,7 @@ 
             return '';
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
             0,
             $offset,
@@ -6920,7 +6920,7 @@ 
             return '';
         }
 
-        return (string) self::substr(
+        return (string)self::substr(
             $str,
             0,
             $offset,
@@ -7111,19 +7111,19 @@ 
         }
 
         // 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',
-            function ($matches) use ($encoding) {
+            function($matches) use ($encoding) {
                 // Preserve leading underscore
                 $str = $matches[1];
                 if ($matches[2]) {
@@ -7148,25 +7148,25 @@ 
         );
 
         // 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',
-            function ($matches) use ($encoding) {
-                return $matches[1] . static::str_upper_first($matches[2], $encoding);
+            function($matches) use ($encoding) {
+                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',
-            function ($matches) use ($encoding) {
+            function($matches) use ($encoding) {
                 return static::str_upper_first($matches[1], $encoding);
             },
             $str
@@ -7174,28 +7174,28 @@ 
 
         // 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',
-            function ($matches) use ($encoding) {
+            function($matches) use ($encoding) {
                 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',
-            function ($matches) use ($encoding) {
-                return $matches[1] . static::str_upper_first($matches[2], $encoding);
+            function($matches) use ($encoding) {
+                return $matches[1].static::str_upper_first($matches[2], $encoding);
             },
             $str
         );
@@ -7290,7 +7290,7 @@ 
         );
 
         foreach ($tmpReturn as &$item) {
-            $item = (string) $item;
+            $item = (string)$item;
         }
 
         return $tmpReturn;
@@ -7327,7 +7327,7 @@ 
     public static function str_truncate($str, int $length, string $substring = '', string $encoding = 'UTF-8'): string
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return '';
@@ -7343,7 +7343,7 @@ 
 
         $truncated = self::substr($str, 0, $length, $encoding);
 
-        return $truncated . $substring;
+        return $truncated.$substring;
     }
 
     /**
@@ -7381,11 +7381,11 @@ 
             $lastPos = self::strrpos($truncated, ' ', 0, $encoding);
 
             if ($lastPos !== false || $strPosSpace !== false) {
-                $truncated = self::substr($truncated, 0, (int) $lastPos, $encoding);
+                $truncated = self::substr($truncated, 0, (int)$lastPos, $encoding);
             }
         }
 
-        return $truncated . $substring;
+        return $truncated.$substring;
     }
 
     /**
@@ -7471,7 +7471,7 @@ 
                 $offset += self::strlen($strParts[$i]) + self::strlen($strParts[$i + 1]);
             }
         } else {
-            $numberOfWords = (int) (($len - 1) / 2);
+            $numberOfWords = (int)(($len - 1) / 2);
         }
 
         return $numberOfWords;
@@ -7531,7 +7531,7 @@ 
     public static function strcmp(string $str1, string $str2): int
     {
         /** @noinspection PhpUndefinedClassInspection */
-        return $str1 . '' === $str2 . '' ? 0 : \strcmp(
+        return $str1.'' === $str2.'' ? 0 : \strcmp(
             \Normalizer::normalize($str1, \Normalizer::NFD),
             \Normalizer::normalize($str2, \Normalizer::NFD)
         );
@@ -7565,7 +7565,7 @@ 
             return null;
         }
 
-        if (\preg_match('/^(.*?)' . self::rxClass($charList) . '/us', $str, $length)) {
+        if (\preg_match('/^(.*?)'.self::rxClass($charList).'/us', $str, $length)) {
             return self::strlen($length[1]);
         }
 
@@ -7681,7 +7681,7 @@ 
             return '';
         }
 
-        return (string) \preg_replace('/[[:space:]]+/u', '', $str);
+        return (string)\preg_replace('/[[:space:]]+/u', '', $str);
     }
 
     /**
@@ -7802,7 +7802,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 (self::$SUPPORT['mbstring'] === true) {
@@ -7824,7 +7824,7 @@ 
             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;
@@ -7892,7 +7892,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);
         }
 
         //
@@ -8018,7 +8018,7 @@ 
      */
     public static function strnatcmp(string $str1, string $str2): int
     {
-        return $str1 . '' === $str2 . '' ? 0 : \strnatcmp(self::strtonatfold($str1), self::strtonatfold($str2));
+        return $str1.'' === $str2.'' ? 0 : \strnatcmp(self::strtonatfold($str1), self::strtonatfold($str2));
     }
 
     /**
@@ -8061,8 +8061,8 @@ 
      */
     public static function strncmp(string $str1, string $str2, int $len): int
     {
-        $str1 = (string) self::substr($str1, 0, $len);
-        $str2 = (string) self::substr($str2, 0, $len);
+        $str1 = (string)self::substr($str1, 0, $len);
+        $str2 = (string)self::substr($str2, 0, $len);
 
         return self::strcmp($str1, $str2);
     }
@@ -8083,8 +8083,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;
@@ -8112,10 +8112,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;
@@ -8155,7 +8155,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);
         }
 
         //
@@ -8223,7 +8223,7 @@ 
         if ($haystackTmp === false) {
             $haystackTmp = '';
         }
-        $haystack = (string) $haystackTmp;
+        $haystack = (string)$haystackTmp;
 
         if ($offset < 0) {
             $offset = 0;
@@ -8321,7 +8321,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);
         }
 
         if (self::$SUPPORT['mbstring'] === true) {
@@ -8353,7 +8353,7 @@ 
             if ($needleTmp === false) {
                 return false;
             }
-            $needle = (string) $needleTmp;
+            $needle = (string)$needleTmp;
 
             $pos = \iconv_strrpos($haystack, $needle, $encoding);
             if ($pos === false) {
@@ -8375,7 +8375,7 @@ 
         if ($needleTmp === false) {
             return false;
         }
-        $needle = (string) $needleTmp;
+        $needle = (string)$needleTmp;
 
         $pos = self::strrpos($haystack, $needle, null, $encoding);
         if ($pos === false) {
@@ -8468,7 +8468,7 @@ 
         if ($needleTmp === false) {
             return false;
         }
-        $needle = (string) $needleTmp;
+        $needle = (string)$needleTmp;
 
         $pos = self::strripos($haystack, $needle, 0, $encoding);
         if ($pos === false) {
@@ -8502,10 +8502,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;
@@ -8542,7 +8542,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);
         }
 
         //
@@ -8649,10 +8649,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;
@@ -8689,7 +8689,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);
         }
 
         //
@@ -8749,7 +8749,7 @@ 
             if ($haystackTmp === false) {
                 $haystackTmp = '';
             }
-            $haystack = (string) $haystackTmp;
+            $haystack = (string)$haystackTmp;
         }
 
         $pos = self::strrpos_in_byte($haystack, $needle);
@@ -8813,14 +8813,14 @@ 
             if ($strTmp === false) {
                 $strTmp = '';
             }
-            $str = (string) $strTmp;
+            $str = (string)$strTmp;
         }
 
         if ($str === '' || $mask === '') {
             return 0;
         }
 
-        return \preg_match('/^' . self::rxClass($mask) . '+/u', $str, $str) ? self::strlen($str[0]) : 0;
+        return \preg_match('/^'.self::rxClass($mask).'+/u', $str, $str) ? self::strlen($str[0]) : 0;
     }
 
     /**
@@ -8876,7 +8876,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);
         }
 
         //
@@ -8914,7 +8914,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;
@@ -9022,7 +9022,7 @@ 
     public static function strtolower($str, string $encoding = 'UTF-8', bool $cleanUtf8 = false, string $lang = null, bool $tryToKeepStringLength = false): string
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return '';
@@ -9049,9 +9049,9 @@ 
             }
 
             if (self::$SUPPORT['intl'] === true) {
-                $langCode = $lang . '-Lower';
+                $langCode = $lang.'-Lower';
                 if (!\in_array($langCode, self::$SUPPORT['intl__transliterator_list_ids'], 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';
                 }
@@ -9060,7 +9060,7 @@ 
                 return \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
@@ -9096,7 +9096,7 @@ 
     public static function strtoupper($str, string $encoding = 'UTF-8', bool $cleanUtf8 = false, string $lang = null, bool $tryToKeepStringLength = false): string
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return '';
@@ -9123,9 +9123,9 @@ 
             }
 
             if (self::$SUPPORT['intl'] === true) {
-                $langCode = $lang . '-Upper';
+                $langCode = $lang.'-Upper';
                 if (!\in_array($langCode, self::$SUPPORT['intl__transliterator_list_ids'], 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';
                 }
@@ -9134,7 +9134,7 @@ 
                 return \transliterator_transliterate($langCode, $str);
             }
 
-            \trigger_error('UTF8::strtolower() without intl + PHP >= 5.4 cannot handle the "lang"-parameter: ' . $lang, \E_USER_WARNING);
+            \trigger_error('UTF8::strtolower() without intl + PHP >= 5.4 cannot handle the "lang"-parameter: '.$lang, \E_USER_WARNING);
         }
 
         // always fallback via symfony polyfill
@@ -9232,7 +9232,7 @@ 
         }
 
         $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) + self::strlen($str, 'UTF-8');
     }
@@ -9330,9 +9330,9 @@ 
         }
 
         if ($length === null) {
-            $length = (int) $str_length;
+            $length = (int)$str_length;
         } else {
-            $length = (int) $length;
+            $length = (int)$length;
         }
 
         if (
@@ -9340,7 +9340,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);
         }
 
         //
@@ -9423,13 +9423,13 @@ 
             if ($str1Tmp === false) {
                 $str1Tmp = '';
             }
-            $str1 = (string) $str1Tmp;
+            $str1 = (string)$str1Tmp;
 
             $str2Tmp = self::substr($str2, 0, self::strlen($str1));
             if ($str2Tmp === false) {
                 $str2Tmp = '';
             }
-            $str2 = (string) $str2Tmp;
+            $str2 = (string)$str2Tmp;
         }
 
         if ($case_insensitivity === true) {
@@ -9475,7 +9475,7 @@ 
                 if ($lengthTmp === false) {
                     return false;
                 }
-                $length = (int) $lengthTmp;
+                $length = (int)$lengthTmp;
             }
 
             if (
@@ -9496,7 +9496,7 @@ 
             if ($haystackTmp === false) {
                 $haystackTmp = '';
             }
-            $haystack = (string) $haystackTmp;
+            $haystack = (string)$haystackTmp;
         }
 
         if ($encoding !== 'UTF-8' && $encoding !== 'CP850') {
@@ -9519,14 +9519,14 @@ 
             &&
             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) {
             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);
     }
@@ -9573,7 +9573,7 @@ 
                 if ($lengthTmp === false) {
                     return false;
                 }
-                $length = (int) $lengthTmp;
+                $length = (int)$lengthTmp;
             }
 
             if (
@@ -9594,7 +9594,7 @@ 
             if ($haystackTmp === false) {
                 $haystackTmp = '';
             }
-            $haystack = (string) $haystackTmp;
+            $haystack = (string)$haystackTmp;
         }
 
         if (self::$SUPPORT['mbstring_func_overload'] === true) {
@@ -9625,7 +9625,7 @@ 
 
         // only a fallback to prevent BC in the api ...
         if ($caseSensitive !== false && $caseSensitive !== true) {
-            $encoding = (string) $caseSensitive;
+            $encoding = (string)$caseSensitive;
         }
 
         if (!$caseSensitive) {
@@ -9633,7 +9633,7 @@ 
             $substring = self::strtocasefold($substring, true, false, $encoding, null, false);
         }
 
-        return (int) self::substr_count($str, $substring, 0, null, $encoding);
+        return (int)self::substr_count($str, $substring, 0, null, $encoding);
     }
 
     /**
@@ -9659,7 +9659,7 @@ 
             if ($haystackTmp === false) {
                 $haystackTmp = '';
             }
-            $haystack = (string) $haystackTmp;
+            $haystack = (string)$haystackTmp;
         }
 
         return $haystack;
@@ -9728,7 +9728,7 @@ 
             if ($haystackTmp === false) {
                 $haystackTmp = '';
             }
-            $haystack = (string) $haystackTmp;
+            $haystack = (string)$haystackTmp;
         }
 
         return $haystack;
@@ -9757,7 +9757,7 @@ 
             if ($haystackTmp === false) {
                 $haystackTmp = '';
             }
-            $haystack = (string) $haystackTmp;
+            $haystack = (string)$haystackTmp;
         }
 
         return $haystack;
@@ -9804,7 +9804,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 {
@@ -9818,7 +9818,7 @@ 
                 $length = \array_slice($length, 0, $num);
                 foreach ($length as &$valueTmpV2) {
                     if ($valueTmpV2 !== null) {
-                        $valueTmpV2 = (int) $valueTmpV2 === $valueTmpV2 ? $valueTmpV2 : $num;
+                        $valueTmpV2 = (int)$valueTmpV2 === $valueTmpV2 ? $valueTmpV2 : $num;
                     } else {
                         $valueTmpV2 = 0;
                     }
@@ -9841,8 +9841,8 @@ 
         }
 
         // init
-        $str = (string) $str;
-        $replacement = (string) $replacement;
+        $str = (string)$str;
+        $replacement = (string)$replacement;
 
         if ($str === '') {
             return $replacement;
@@ -9850,8 +9850,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);
         }
 
         if (!isset(self::$SUPPORT['already_checked_via_portable_utf8'])) {
@@ -9877,7 +9876,7 @@ 
                 $length = $string_length - $offset;
             }
 
-            return self::substr($str, 0, $offset, $encoding) . $replacement . self::substr($str, $offset + $length, $string_length - $offset - $length, $encoding);
+            return self::substr($str, 0, $offset, $encoding).$replacement.self::substr($str, $offset + $length, $string_length - $offset - $length, $encoding);
         }
 
         \preg_match_all('/./us', $str, $smatches);
@@ -9889,7 +9888,7 @@ 
                 // e.g.: non mbstring support + invalid chars
                 return '';
             }
-            $length = (int) $lengthTmp;
+            $length = (int)$lengthTmp;
         }
 
         \array_splice($smatches[0], $offset, $length, $rmatches[0]);
@@ -9920,7 +9919,7 @@ 
             if ($haystackTmp === false) {
                 $haystackTmp = '';
             }
-            $haystack = (string) $haystackTmp;
+            $haystack = (string)$haystackTmp;
         }
 
         return $haystack;
@@ -9951,7 +9950,7 @@ 
             $str = self::clean($str);
         }
 
-        return (string) (self::strtolower($str, $encoding) ^ self::strtoupper($str, $encoding) ^ $str);
+        return (string)(self::strtolower($str, $encoding) ^ self::strtoupper($str, $encoding) ^ $str);
     }
 
     /**
@@ -10245,7 +10244,7 @@ 
     public static function to_boolean($str): bool
     {
         // init
-        $str = (string) $str;
+        $str = (string)$str;
 
         if ($str === '') {
             return false;
@@ -10271,10 +10270,10 @@ 
 
         /** @noinspection CallableParameterUseCaseInTypeContextInspection */
         if (\is_numeric($str)) {
-            return ((float) $str + 0) > 0;
+            return ((float)$str + 0) > 0;
         }
 
-        return (bool) self::trim($str);
+        return (bool)self::trim($str);
     }
 
     /**
@@ -10295,11 +10294,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]+/',                                            // 2) convert spaces to $fallback_char
-                '/[' . $fallback_char_escaped . ']+/',                // 3) remove double $fallback_char's
+                '/[^'.$fallback_char_escaped.'\.\-a-zA-Z0-9\s]/', // 1) remove un-needed chars
+                '/[\s]+/', // 2) convert spaces to $fallback_char
+                '/['.$fallback_char_escaped.']+/', // 3) remove double $fallback_char's
             ],
             [
                 '',
@@ -10330,7 +10329,7 @@ 
             return $str;
         }
 
-        $str = (string) $str;
+        $str = (string)$str;
         if ($str === '') {
             return '';
         }
@@ -10377,7 +10376,7 @@ 
             return $str;
         }
 
-        $str = (string) $str;
+        $str = (string)$str;
         if ($str === '') {
             return $str;
         }
@@ -10400,7 +10399,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);
@@ -10411,7 +10410,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);
@@ -10423,7 +10422,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);
@@ -10442,7 +10441,7 @@ 
         // decode unicode escape sequences
         $buf = \preg_replace_callback(
             '/\\\\u([0-9a-f]{4})/i',
-            function ($match) {
+            function($match) {
                 // always fallback via symfony polyfill
                 return \mb_convert_encoding(\pack('H*', $match[1]), 'UTF-8', 'UCS-2BE');
             },
@@ -10484,8 +10483,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;
@@ -10546,14 +10545,14 @@ 
         }
 
         $strPartOne = self::strtoupper(
-            (string) self::substr($str, 0, 1, $encoding),
+            (string)self::substr($str, 0, 1, $encoding),
             $encoding,
             $cleanUtf8,
             $lang,
             $tryToKeepStringLength
         );
 
-        return $strPartOne . $strPartTwo;
+        return $strPartOne.$strPartTwo;
     }
 
     /**
@@ -10599,7 +10598,7 @@ 
             $str = self::clean($str);
         }
 
-        $usePhpDefaultFunctions = !(bool) ($charlist . \implode('', $exceptions));
+        $usePhpDefaultFunctions = !(bool)($charlist.\implode('', $exceptions));
 
         if (
             $usePhpDefaultFunctions === true
@@ -10668,7 +10667,7 @@ 
 
         $pattern = '/%u([0-9a-f]{3,4})/i';
         if (\preg_match($pattern, $str)) {
-            $str = (string) \preg_replace($pattern, '&#x\\1;', \urldecode($str));
+            $str = (string)\preg_replace($pattern, '&#x\\1;', \urldecode($str));
         }
 
         $flags = \ENT_QUOTES | \ENT_HTML5;
@@ -11102,7 +11101,7 @@ 
             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])
@@ -11112,7 +11111,7 @@ 
             return $str;
         }
 
-        return self::rtrim($matches[0]) . $strAddOn;
+        return self::rtrim($matches[0]).$strAddOn;
     }
 
     /**
@@ -11182,7 +11181,7 @@ 
             $strReturn .= $break;
         }
 
-        return $strReturn . \implode('', $chars);
+        return $strReturn.\implode('', $chars);
     }
 
     /**
@@ -11195,7 +11194,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) {

src/voku/helper/Bootup.php

Spacing +9 added lines, -9 removed lines

@@ -70,7 +70,7 @@ 
                 return false;
             }
 
-            $uri = (string) $_SERVER['REQUEST_URI'];
+            $uri = (string)$_SERVER['REQUEST_URI'];
         }
 
         $uriOrig = $uri;
@@ -87,17 +87,17 @@ 
         // When not, assumes Windows-1252 and redirects to the corresponding UTF-8 encoded URL
         //
 
-        $uri = (string) \preg_replace_callback(
+        $uri = (string)\preg_replace_callback(
             '/[\x80-\xFF]+/',
-            function ($m) {
+            function($m) {
                 return \rawurlencode($m[0]);
             },
             $uri
         );
 
-        $uri = (string) \preg_replace_callback(
+        $uri = (string)\preg_replace_callback(
             '/(?:%[89A-F][0-9A-F])+/i',
-            function ($m) {
+            function($m) {
                 return \rawurlencode(UTF8::rawurldecode($m[0]));
             },
             $uri
@@ -112,8 +112,8 @@ 
         ) {
             // Use ob_start() to buffer content and avoid problem of headers already sent...
             $severProtocol = ($_SERVER['SERVER_PROTOCOL'] ?? 'HTTP/1.1');
-            \header($severProtocol . ' 301 Moved Permanently');
-            \header('Location: ' . $uri);
+            \header($severProtocol.' 301 Moved Permanently');
+            \header('Location: '.$uri);
             exit();
         }
 
@@ -150,7 +150,7 @@ 
             return false;
         }
 
-        $length = (int) $length;
+        $length = (int)$length;
 
         if ($length <= 0) {
             return false;
@@ -181,7 +181,7 @@ 
     {
         static $_IS_PHP;
 
-        $version = (string) $version;
+        $version = (string)$version;
 
         if (!isset($_IS_PHP[$version])) {
             $_IS_PHP[$version] = \version_compare(\PHP_VERSION, $version, '>=');

src/voku/helper/data/win1252_to_utf8.php

Spacing +104 added lines, -104 removed lines

@@ -3,17 +3,17 @@ 
 return [
     0x80 => "\xe2\x82\xac", // €
     0x82 => "\xe2\x80\x9a", // ‚
-    0x83 => "\xc6\x92",     // ƒ
+    0x83 => "\xc6\x92", // ƒ
     0x84 => "\xe2\x80\x9e", // „
     0x85 => "\xe2\x80\xa6", // …
     0x86 => "\xe2\x80\xa0", // †
     0x87 => "\xe2\x80\xa1", // ‡
-    0x88 => "\xcb\x86",     // ˆ
+    0x88 => "\xcb\x86", // ˆ
     0x89 => "\xe2\x80\xb0", // ‰
-    0x8a => "\xc5\xa0",     // Š
+    0x8a => "\xc5\xa0", // Š
     0x8b => "\xe2\x80\xb9", // ‹
-    0x8c => "\xc5\x92",     // Œ
-    0x8e => "\xc5\xbd",     // Ž
+    0x8c => "\xc5\x92", // Œ
+    0x8e => "\xc5\xbd", // Ž
     0x91 => "\xe2\x80\x98", // ‘
     0x92 => "\xe2\x80\x99", // ’
     0x93 => "\xe2\x80\x9c", // “
@@ -21,106 +21,106 @@ 
     0x95 => "\xe2\x80\xa2", // •
     0x96 => "\xe2\x80\x93", // –
     0x97 => "\xe2\x80\x94", // —
-    0x98 => "\xcb\x9c",     // ˜
+    0x98 => "\xcb\x9c", // ˜
     0x99 => "\xe2\x84\xa2", // ™
-    0x9a => "\xc5\xa1",     // š
+    0x9a => "\xc5\xa1", // š
     0x9b => "\xe2\x80\xba", // ›
-    0x9c => "\xc5\x93",     // œ
-    0x9e => "\xc5\xbe",     // ž
-    0x9f => "\xc5\xb8",     // Ÿ
+    0x9c => "\xc5\x93", // œ
+    0x9e => "\xc5\xbe", // ž
+    0x9f => "\xc5\xb8", // Ÿ
     0xa0 => "\xc2\xa0",
-    0xa1 => "\xc2\xa1",     // ¡
-    0xa2 => "\xc2\xa2",     // ¢
-    0xa3 => "\xc2\xa3",     // £
-    0xa4 => "\xc2\xa4",     // ¤
-    0xa5 => "\xc2\xa5",     // ¥
-    0xa6 => "\xc2\xa6",     // ¦
-    0xa7 => "\xc2\xa7",     // §
-    0xa8 => "\xc2\xa8",     // ¨
-    0xa9 => "\xc2\xa9",     // ©
-    0xaa => "\xc2\xaa",     // ª
-    0xab => "\xc2\xab",     // «
-    0xac => "\xc2\xac",     // ¬
-    0xad => "\xc2\xad",     // ­
-    0xae => "\xc2\xae",     // ®
-    0xaf => "\xc2\xaf",     // ¯
-    0xb0 => "\xc2\xb0",     // °
-    0xb1 => "\xc2\xb1",     // ±
-    0xb2 => "\xc2\xb2",     // ²
-    0xb3 => "\xc2\xb3",     // ³
-    0xb4 => "\xc2\xb4",     // ´
-    0xb5 => "\xc2\xb5",     // µ
-    0xb6 => "\xc2\xb6",     // ¶
-    0xb7 => "\xc2\xb7",     // ·
-    0xb8 => "\xc2\xb8",     // ¸
-    0xb9 => "\xc2\xb9",     // ¹
-    0xba => "\xc2\xba",     // º
-    0xbb => "\xc2\xbb",     // »
-    0xbc => "\xc2\xbc",     // ¼
-    0xbd => "\xc2\xbd",     // ½
-    0xbe => "\xc2\xbe",     // ¾
-    0xbf => "\xc2\xbf",     // ¿
-    0xc0 => "\xc3\x80",     // À
-    0xc1 => "\xc3\x81",     // Á
-    0xc2 => "\xc3\x82",     // Â
-    0xc3 => "\xc3\x83",     // Ã
-    0xc4 => "\xc3\x84",     // Ä
-    0xc5 => "\xc3\x85",     // Å
-    0xc6 => "\xc3\x86",     // Æ
-    0xc7 => "\xc3\x87",     // Ç
-    0xc8 => "\xc3\x88",     // È
-    0xc9 => "\xc3\x89",     // É
-    0xca => "\xc3\x8a",     // Ê
-    0xcb => "\xc3\x8b",     // Ë
-    0xcc => "\xc3\x8c",     // Ì
-    0xcd => "\xc3\x8d",     // Í
-    0xce => "\xc3\x8e",     // Î
-    0xcf => "\xc3\x8f",     // Ï
-    0xd0 => "\xc3\x90",     // Ð
-    0xd1 => "\xc3\x91",     // Ñ
-    0xd2 => "\xc3\x92",     // Ò
-    0xd3 => "\xc3\x93",     // Ó
-    0xd4 => "\xc3\x94",     // Ô
-    0xd5 => "\xc3\x95",     // Õ
-    0xd6 => "\xc3\x96",     // Ö
-    0xd7 => "\xc3\x97",     // ×
-    0xd8 => "\xc3\x98",     // Ø
-    0xd9 => "\xc3\x99",     // Ù
-    0xda => "\xc3\x9a",     // Ú
-    0xdb => "\xc3\x9b",     // Û
-    0xdc => "\xc3\x9c",     // Ü
-    0xdd => "\xc3\x9d",     // Ý
-    0xde => "\xc3\x9e",     // Þ
-    0xdf => "\xc3\x9f",     // ß
-    0xe0 => "\xc3\xa0",     // à
-    0xe1 => "\xa1",         // á
-    0xe2 => "\xc3\xa2",     // â
-    0xe3 => "\xc3\xa3",     // ã
-    0xe4 => "\xc3\xa4",     // ä
-    0xe5 => "\xc3\xa5",     // å
-    0xe6 => "\xc3\xa6",     // æ
-    0xe7 => "\xc3\xa7",     // ç
-    0xe8 => "\xc3\xa8",     // è
-    0xe9 => "\xc3\xa9",     // é
-    0xea => "\xc3\xaa",     // ê
-    0xeb => "\xc3\xab",     // ë
-    0xec => "\xc3\xac",     // ì
-    0xed => "\xc3\xad",     // í
-    0xee => "\xc3\xae",     // î
-    0xef => "\xc3\xaf",     // ï
-    0xf0 => "\xc3\xb0",     // ð
-    0xf1 => "\xc3\xb1",     // ñ
-    0xf2 => "\xc3\xb2",     // ò
-    0xf3 => "\xc3\xb3",     // ó
-    0xf4 => "\xc3\xb4",     // ô
-    0xf5 => "\xc3\xb5",     // õ
-    0xf6 => "\xc3\xb6",     // ö
-    0xf7 => "\xc3\xb7",     // ÷
-    0xf8 => "\xc3\xb8",     // ø
-    0xf9 => "\xc3\xb9",     // ù
-    0xfa => "\xc3\xba",     // ú
-    0xfb => "\xc3\xbb",     // û
-    0xfc => "\xc3\xbc",     // ü
-    0xfd => "\xc3\xbd",     // ý
-    0xfe => "\xc3\xbe",     // þ
+    0xa1 => "\xc2\xa1", // ¡
+    0xa2 => "\xc2\xa2", // ¢
+    0xa3 => "\xc2\xa3", // £
+    0xa4 => "\xc2\xa4", // ¤
+    0xa5 => "\xc2\xa5", // ¥
+    0xa6 => "\xc2\xa6", // ¦
+    0xa7 => "\xc2\xa7", // §
+    0xa8 => "\xc2\xa8", // ¨
+    0xa9 => "\xc2\xa9", // ©
+    0xaa => "\xc2\xaa", // ª
+    0xab => "\xc2\xab", // «
+    0xac => "\xc2\xac", // ¬
+    0xad => "\xc2\xad", // ­
+    0xae => "\xc2\xae", // ®
+    0xaf => "\xc2\xaf", // ¯
+    0xb0 => "\xc2\xb0", // °
+    0xb1 => "\xc2\xb1", // ±
+    0xb2 => "\xc2\xb2", // ²
+    0xb3 => "\xc2\xb3", // ³
+    0xb4 => "\xc2\xb4", // ´
+    0xb5 => "\xc2\xb5", // µ
+    0xb6 => "\xc2\xb6", // ¶
+    0xb7 => "\xc2\xb7", // ·
+    0xb8 => "\xc2\xb8", // ¸
+    0xb9 => "\xc2\xb9", // ¹
+    0xba => "\xc2\xba", // º
+    0xbb => "\xc2\xbb", // »
+    0xbc => "\xc2\xbc", // ¼
+    0xbd => "\xc2\xbd", // ½
+    0xbe => "\xc2\xbe", // ¾
+    0xbf => "\xc2\xbf", // ¿
+    0xc0 => "\xc3\x80", // À
+    0xc1 => "\xc3\x81", // Á
+    0xc2 => "\xc3\x82", // Â
+    0xc3 => "\xc3\x83", // Ã
+    0xc4 => "\xc3\x84", // Ä
+    0xc5 => "\xc3\x85", // Å
+    0xc6 => "\xc3\x86", // Æ
+    0xc7 => "\xc3\x87", // Ç
+    0xc8 => "\xc3\x88", // È
+    0xc9 => "\xc3\x89", // É
+    0xca => "\xc3\x8a", // Ê
+    0xcb => "\xc3\x8b", // Ë
+    0xcc => "\xc3\x8c", // Ì
+    0xcd => "\xc3\x8d", // Í
+    0xce => "\xc3\x8e", // Î
+    0xcf => "\xc3\x8f", // Ï
+    0xd0 => "\xc3\x90", // Ð
+    0xd1 => "\xc3\x91", // Ñ
+    0xd2 => "\xc3\x92", // Ò
+    0xd3 => "\xc3\x93", // Ó
+    0xd4 => "\xc3\x94", // Ô
+    0xd5 => "\xc3\x95", // Õ
+    0xd6 => "\xc3\x96", // Ö
+    0xd7 => "\xc3\x97", // ×
+    0xd8 => "\xc3\x98", // Ø
+    0xd9 => "\xc3\x99", // Ù
+    0xda => "\xc3\x9a", // Ú
+    0xdb => "\xc3\x9b", // Û
+    0xdc => "\xc3\x9c", // Ü
+    0xdd => "\xc3\x9d", // Ý
+    0xde => "\xc3\x9e", // Þ
+    0xdf => "\xc3\x9f", // ß
+    0xe0 => "\xc3\xa0", // à
+    0xe1 => "\xa1", // á
+    0xe2 => "\xc3\xa2", // â
+    0xe3 => "\xc3\xa3", // ã
+    0xe4 => "\xc3\xa4", // ä
+    0xe5 => "\xc3\xa5", // å
+    0xe6 => "\xc3\xa6", // æ
+    0xe7 => "\xc3\xa7", // ç
+    0xe8 => "\xc3\xa8", // è
+    0xe9 => "\xc3\xa9", // é
+    0xea => "\xc3\xaa", // ê
+    0xeb => "\xc3\xab", // ë
+    0xec => "\xc3\xac", // ì
+    0xed => "\xc3\xad", // í
+    0xee => "\xc3\xae", // î
+    0xef => "\xc3\xaf", // ï
+    0xf0 => "\xc3\xb0", // ð
+    0xf1 => "\xc3\xb1", // ñ
+    0xf2 => "\xc3\xb2", // ò
+    0xf3 => "\xc3\xb3", // ó
+    0xf4 => "\xc3\xb4", // ô
+    0xf5 => "\xc3\xb5", // õ
+    0xf6 => "\xc3\xb6", // ö
+    0xf7 => "\xc3\xb7", // ÷
+    0xf8 => "\xc3\xb8", // ø
+    0xf9 => "\xc3\xb9", // ù
+    0xfa => "\xc3\xba", // ú
+    0xfb => "\xc3\xbb", // û
+    0xfc => "\xc3\xbc", // ü
+    0xfd => "\xc3\xbd", // ý
+    0xfe => "\xc3\xbe", // þ
 ];